Comment supprimer tout dans Redis?

Je souhaite supprimer toutes les clés. Je veux que tout soit effacé et me donne une base de données vierge.

Existe-t-il un moyen de le faire dans le client Redis ?

Avec redis-cli:

• FLUSHDB - Supprime toutes les clés de la base de données actuelle de la connexion.
• FLUSHALL - Supprime toutes les clés de toutes les bases de données.

Par exemple, dans votre shell:

redis-cli flushall

Attention qui FLUSHALLpeut être exagéré. FLUSHDBest le seul à vider une base de données. FLUSHALLeffacera tout le serveur. Comme dans toutes les bases de données du serveur. Étant donné que la question portait sur le vidage d'une base de données, je pense que c'est une distinction suffisamment importante pour mériter une réponse distincte.

Jusqu'à présent, les réponses sont absolument correctes; ils suppriment toutes les clés.

Cependant, si vous souhaitez également supprimer tous les Lua scripts de l'instance Redis, vous devez le suivre en:

SCRIPT FLUSH

Le PO pose deux questions; ceci termine la deuxième question ( tout effacé).

FLUSHALL Supprimer toutes les clés de toutes les bases de données

FLUSHDB Supprimer toutes les clés de la base de données actuelle

SCRIPT FLUSH Supprimez tous les scripts du cache de scripts.

Si vous utilisez la gemme redis-rb, vous pouvez simplement appeler:

your_redis_client.flushdb

Cette méthode a fonctionné pour moi - supprimez tout de la base de données connectée actuelle sur votre cluster Jedis.

public static void resetRedis() {
    jedisCluster = RedisManager.getJedis(); // your JedisCluster instance

    for (JedisPool pool : jedisCluster.getClusterNodes().values()) {

        try (Jedis jedis = pool.getResource()) {
            jedis.flushAll();
        }
        catch (Exception ex){
            System.out.println(ex.getMessage());
        }
    }

}

Une option de plus de mon côté:

Dans nos bases de données de production et de pré-production, il y a des milliers de clés. De temps en temps, nous devons supprimer certaines clés (par un masque), les modifier selon certains critères, etc. Bien sûr, il n'y a aucun moyen de le faire manuellement à partir de la CLI, en particulier avec le partage (512 dbs logiques dans chaque physique).

Dans ce but, j'écris un outil client java qui fait tout ce travail. En cas de suppression de clés, l'utilitaire peut être très simple, il n'y a qu'une seule classe:

public class DataCleaner {

    public static void main(String args[]) {
        String keyPattern = args[0];
        String host = args[1];
        int port = Integer.valueOf(args[2]);
        int dbIndex = Integer.valueOf(args[3]);

        Jedis jedis = new Jedis(host, port);

        int deletedKeysNumber = 0;
        if(dbIndex >= 0){
            deletedKeysNumber += deleteDataFromDB(jedis, keyPattern, dbIndex);
        } else {
            int dbSize = Integer.valueOf(jedis.configGet("databases").get(1));
            for(int i = 0; i < dbSize; i++){
                deletedKeysNumber += deleteDataFromDB(jedis, keyPattern, i);
            }
        }

        if(deletedKeysNumber == 0) {
            System.out.println("There is no keys with key pattern: " + keyPattern + " was found in database with host: " + host);
        }
    }

    private static int deleteDataFromDB(Jedis jedis, String keyPattern, int dbIndex) {
        jedis.select(dbIndex);
        Set<String> keys = jedis.keys(keyPattern);
        for(String key : keys){
            jedis.del(key);
            System.out.println("The key: " + key + " has been deleted from database index: " + dbIndex);
        }

        return keys.size();
    }

}

Écrire ce genre d'outils me semble très facile et ne passe pas plus de 5 à 10 minutes.

FLUSHALL Supprime toutes les bases de données existantes de Keys of All. Pour Redis version> 4.0, FLUSHALL ASYNC est pris en charge et s'exécute dans un thread d'arrière-plan sans bloquer le serveur https://redis.io/commands/flushall

FLUSHDB - Supprime toutes les clés de la base de données sélectionnée. https://redis.io/commands/flushdb

La complexité temporelle pour effectuer les opérations sera O (N) où N étant le nombre de clés dans la base de données.

La réponse du redis sera une simple chaîne "OK"

Vous pouvez utiliser FLUSHALL qui supprimera toutes les clés de chacune de vos bases de données. Où FLUSHDB supprimera toutes les clés de notre base de données actuelle.

1. Arrêtez l'instance Redis.
2. Supprimez le fichier RDB.
3. Démarrez l'instance Redis.

À utiliser FLUSHALL ASYNCsi vous utilisez (Redis 4.0.0 ou supérieur) autrement FLUSHALL.

https://redis.io/commands/flushall

Remarque : Tout avant l'exécution FLUSHALL ASYNCsera expulsé. Les modifications apportées lors de l'exécution FLUSHALL ASYNCne seront pas affectées.

Ouvrez redis-cli et tapez:

FLUSHALL

je pense que parfois arrêter le redis-server et supprimer rdb r aof fichiers。 assurez-vous qu'il n'y a pas de données pouvant être rechargées. puis démarrez le serveur redis, maintenant il est nouveau et vide.

redis-cli -h <host> -p <port> flushall

Il supprimera toutes les données du client connecté (avec l'hôte et le port)

Après avoir démarré le serveur Redis à l'aide de: service redis-server start --port 8000ou redis-server.

Permet redis-cli -p 8000de se connecter au serveur en tant que client dans un autre terminal.

Vous pouvez utiliser soit

1. FLUSHDB - Supprime toutes les clés du DB actuellement sélectionné. Cette commande n'échoue jamais. La complexité temporelle de cette opération est O (N), N étant le nombre de clés dans la base de données.
2. FLUSHALL - Supprimez toutes les clés de toutes les bases de données existantes, pas seulement celle actuellement sélectionnée. Cette commande n'échoue jamais. La complexité temporelle de cette opération est O (N), N étant le nombre de clés dans toutes les bases de données existantes.

Consultez la documentation de l' option ASYNC pour les deux.

Si vous utilisez Redis via son interface python, utilisez ces deux fonctions pour la même fonctionnalité:

def flushall(self):
    "Delete all keys in all databases on the current host"
    return self.execute_command('FLUSHALL')

et

def flushdb(self):
    "Delete all keys in the current database"
    return self.execute_command('FLUSHDB')

Vos questions semblent concerner la suppression de clés entières dans une base de données. Dans ce cas, vous devez essayer:

1. Connectez-vous à redis. Vous pouvez utiliser la commande redis-cli(si elle s'exécute sur le port 6379), sinon vous devrez également spécifier le numéro de port.
2. Sélectionnez votre base de données (commande select {Index})
3. Exécutez la commande flushdb

Si vous souhaitez vider les clés de toutes les bases de données, essayez flushall.

Un clic dans FastoRedis / FastoNoSQL

Vous pouvez utiliser FLUSHDB

par exemple

Liste des bases de données:

127.0.0.1:6379> info keyspace
# Keyspace

Liste des clés

127.0.0.1:6379> keys *
(empty list or set)

Ajouter une valeur à une clé

127.0.0.1:6379> lpush key1 1
(integer) 1
127.0.0.1:6379> keys *
1) "key1"
127.0.0.1:6379> info keyspace
# Keyspace
db0:keys=1,expires=0,avg_ttl=0

Créer une autre clé avec deux valeurs

127.0.0.1:6379> lpush key2 1
(integer) 1
127.0.0.1:6379> lpush key2 2
(integer) 2
127.0.0.1:6379> keys *
1) "key1"
2) "key2"
127.0.0.1:6379> info keyspace
# Keyspace
db0:keys=2,expires=0,avg_ttl=0

Liste toutes les valeurs dans key2

127.0.0.1:6379> lrange key2 0 -1
1) "2"
2) "1"

Do FLUSHDB

127.0.0.1:6379> flushdb
OK

Liste des clés et des bases de données

127.0.0.1:6379> keys *
(empty list or set)
127.0.0.1:6379> info keyspace
# Keyspace

vous pouvez utiliser l'approche suivante en python

def redis_clear_cache(self):

    try:
        redis_keys = self.redis_client.keys('*')
    except Exception as e:
        # print('redis_client.keys() raised exception => ' + str(e))
        return 1

    try:
        if len(redis_keys) != 0:
            self.redis_client.delete(*redis_keys)
    except Exception as e:
        # print('redis_client.delete() raised exception => ' + str(e))
        return 1

    # print("cleared cache")
    return 0

C'est mieux si vous pouvez avoir RDM (Redis Desktop Manager). Vous pouvez vous connecter à votre serveur redis en créant une nouvelle connexion dans RDM.

Une fois connecté, vous pouvez vérifier les données en direct, vous pouvez également jouer avec n'importe quelle commande redis.

Ouverture d'un cli dans RDM.

1) Faites un clic droit sur la connexion, vous verrez une option de console, cliquez simplement dessus, une nouvelle fenêtre de console s'ouvrira en bas de RDM.

Pour revenir à votre question FLUSHALL est la commande, vous pouvez simplement taper FLUSHALL dans le redis cli.

De plus, si vous souhaitez en savoir plus sur une commande redis et son utilisation appropriée, cliquez sur le lien ci-dessous. https://redis.io/commands .

Il existe différentes approches. Si vous souhaitez le faire à distance, lancez flushall vers cette instance, via l'outil de ligne de commande redis-cli ou tout autre outil tel que telnet, un SDK de langage de programmation. Ou connectez-vous simplement à ce serveur, supprimez le processus, supprimez son fichier dump.rdb et appendonly.aof (sauvegardez-les avant la suppression).

Si vous utilisez Java, puis à partir de la documentation, vous pouvez utiliser l'un d'eux en fonction de votre cas d'utilisation.

/**
 * Remove all keys from all databases.
 *
 * @return String simple-string-reply
 */
String flushall();

/**
 * Remove all keys asynchronously from all databases.
 *
 * @return String simple-string-reply
 */
String flushallAsync();

/**
 * Remove all keys from the current database.
 *
 * @return String simple-string-reply
 */
String flushdb();

/**
 * Remove all keys asynchronously from the current database.
 *
 * @return String simple-string-reply
 */
String flushdbAsync();

Code:

RedisAdvancedClusterCommands syncCommands = // get sync() or async() commands 
syncCommands.flushdb();

En savoir plus: https://github.com/lettuce-io/lettuce-core/wiki/Redis-Cluster