¿Cómo elimino todo en Redis?

Quiero borrar todas las claves. Quiero que todo se borre y me dé una base de datos en blanco.

¿Hay alguna manera de hacer esto en el cliente Redis ?

Con redis-cli:

• FLUSHDB : elimina todas las claves de la base de datos actual de la conexión.
• FLUSHALL : elimina todas las claves de todas las bases de datos.

Por ejemplo, en su shell:

redis-cli flushall

Atención que FLUSHALLpuede ser exagerado. FLUSHDBes el único para vaciar una base de datos. FLUSHALLeliminará todo el servidor. Como en todas las bases de datos en el servidor. Dado que la pregunta era sobre vaciar una base de datos, creo que esta es una distinción lo suficientemente importante como para merecer una respuesta por separado.

Las respuestas hasta ahora son absolutamente correctas; ellos eliminan todas las claves.

Sin embargo, si también desea eliminar todos los scripts de Lua de la instancia de Redis, debe seguirlo:

SCRIPT FLUSH

El OP hace dos preguntas; Esto completa la segunda pregunta ( todo borrado).

FLUSHALL Eliminar todas las claves de todas las bases de datos

FLUSHDB Eliminar todas las claves de la base de datos actual

SCRIPT FLUSH Elimina todos los scripts de la caché de scripts.

Si está utilizando la gema redis-rb, simplemente puede llamar:

your_redis_client.flushdb

Este método funcionó para mí: elimine todo de la base de datos conectada actual en su clúster 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());
        }
    }

}

Una opción más de mi lado:

En nuestras bases de datos de producción y preproducción hay miles de claves. De vez en cuando necesitamos eliminar algunas claves (mediante alguna máscara), modificarlas según algunos criterios, etc. Por supuesto, no hay forma de hacerlo manualmente desde la CLI, especialmente si se tiene fragmentación (512 dbs lógicos en cada físico).

Para este propósito, escribo la herramienta de cliente java que hace todo este trabajo. En caso de eliminación de claves, la utilidad puede ser muy simple, solo hay una clase allí:

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();
    }

}

Escribir este tipo de herramientas me parece muy fácil y no paso más de 5-10 minutos.

FLUSHALL elimina todas las claves de todas las bases de datos existentes. Para Redis versión> 4.0, se admite FLUSHALL ASYNC que se ejecuta en un subproceso en segundo plano sin bloquear el servidor https://redis.io/commands/flushall

FLUSHDB: elimina todas las claves de la base de datos seleccionada. https://redis.io/commands/flushdb

La complejidad de tiempo para realizar las operaciones será O (N) donde N es el número de claves en la base de datos.

La respuesta del redis será una cadena simple "OK"

Puede usar FLUSHALL que eliminará todas las claves de cada una de sus bases de datos. Donde como FLUSHDB borrará todas las claves de nuestra base de datos actual.

1. Detener la instancia de Redis.
2. Eliminar el archivo RDB.
3. Inicie la instancia de Redis.

Úselo FLUSHALL ASYNCsi usa (Redis 4.0.0 o superior) más FLUSHALL.

https://redis.io/commands/flushall

Nota : Todo antes de ejecutar FLUSHALL ASYNCserá desalojado. Los cambios realizados durante la ejecución no FLUSHALL ASYNCse verán afectados.

Abra redis-cli y escriba:

FLUSHALL

Creo que a veces detengo el servidor redis y borro rdb, algunos archivos, asegurándome de que no se puedan volver a cargar datos. luego inicie el servidor redis, ahora es nuevo y está vacío.

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

Eliminará todos los datos del cliente conectado (con el host y el puerto)

Después de iniciar el servidor Redis con: service redis-server start --port 8000o redis-server.

Utilícelo redis-cli -p 8000para conectarse al servidor como cliente en un terminal diferente.

Puedes usar cualquiera

1. FLUSHDB : elimina todas las claves del DB actualmente seleccionado. Este comando nunca falla. La complejidad temporal para esta operación es O (N), N es el número de claves en la base de datos.
2. FLUSHALL : elimine todas las claves de todas las bases de datos existentes, no solo la seleccionada actualmente. Este comando nunca falla. La complejidad temporal para esta operación es O (N), siendo N el número de claves en todas las bases de datos existentes.

Consulte la documentación para la opción ASYNC para ambos.

Si está utilizando Redis a través de su interfaz de Python, use estas dos funciones para la misma funcionalidad:

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

y

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

Sus preguntas parecen ser sobre la eliminación de claves completas en una base de datos. En este caso deberías probar:

1. Conéctate a redis. Puede usar el comando redis-cli(si se ejecuta en el puerto 6379), de lo contrario también deberá especificar el número de puerto.
2. Seleccione su base de datos (comando select {Index})
3. Ejecutar el comando flushdb

Si desea vaciar claves en todas las bases de datos, entonces debería intentarlo flushall.

Un clic en FastoRedis / FastoNoSQL

Puedes usar FLUSHDB

p.ej

Lista de bases de datos:

127.0.0.1:6379> info keyspace
# Keyspace

Lista de claves

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

Agregar un valor a una clave

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

Crea otra clave con dos valores

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

Listar todos los valores en clave2

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

Hacer FLUSHDB

127.0.0.1:6379> flushdb
OK

Lista de claves y bases de datos

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

puedes usar el siguiente enfoque 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

Es mejor si puede tener RDM (Redis Desktop Manager). Puede conectarse a su servidor redis creando una nueva conexión en RDM.

Una vez que está conectado, puede verificar los datos en vivo, también puede jugar con cualquier comando redis.

Abrir un cli en RDM.

1) Haga clic derecho en la conexión, verá una opción de consola, solo haga clic en ella y se abrirá una nueva ventana de consola en la parte inferior de RDM.

Volviendo a su pregunta FLUSHALL es el comando, simplemente puede escribir FLUSHALL en el redis cli.

Además, si desea conocer cualquier comando de redis y su uso adecuado, vaya al enlace a continuación. https://redis.io/commands .

Hay diferentes enfoques. Si desea hacer esto desde remoto, emita flushall a esa instancia, a través de la herramienta de línea de comandos redis-cli o cualquier herramienta, es decir, telnet, un SDK de lenguaje de programación. O simplemente inicie sesión en ese servidor, elimine el proceso, elimine su archivo dump.rdb y appendonly.aof (realice una copia de seguridad antes de eliminarlo).

Si está utilizando Java , a partir de la documentación, puede utilizar cualquiera de ellos según su caso de uso.

/**
 * 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();

Código:

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

Leer más: https://github.com/lettuce-io/lettuce-core/wiki/Redis-Cluster