Como faço para excluir tudo no Redis?

Eu quero excluir todas as chaves. Quero que tudo seja apagado e me dê um banco de dados em branco.

Existe uma maneira de fazer isso no cliente Redis ?

Com redis-cli:

• FLUSHDB - Exclui todas as chaves do banco de dados atual da conexão.
• FLUSHALL - Exclui todas as chaves de todos os bancos de dados.

Por exemplo, no seu shell:

redis-cli flushall

Atenção que FLUSHALLpode ser um exagero. FLUSHDBé o único a liberar apenas um banco de dados. FLUSHALLirá destruir todo o servidor. Como em todos os bancos de dados no servidor. Como a pergunta era sobre liberar um banco de dados, acho que essa é uma distinção importante o suficiente para merecer uma resposta separada.

As respostas até agora estão absolutamente corretas; eles excluem todas as chaves.

No entanto, se você também deseja excluir todos os scripts Lua da instância Redis, siga-o:

SCRIPT FLUSH

O OP faz duas perguntas; isso completa a segunda pergunta ( tudo apagado).

FLUSHALL Remova todas as chaves de todos os bancos de dados

FLUSHDB Remover todas as chaves do banco de dados atual

DESCARGA DE SCRIPT Remova todos os scripts do cache de scripts.

Se você estiver usando a gema redis-rb, basta ligar para:

your_redis_client.flushdb

Esse método funcionou para mim - exclua tudo do banco de dados conectado atual no seu 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());
        }
    }

}

Mais uma opção do meu lado:

Nos nossos bancos de dados de produção e pré-produção, existem milhares de chaves. Ocasionalmente, precisamos excluir algumas chaves (por alguma máscara), modificar por alguns critérios etc. É claro que não há como fazê-lo manualmente a partir da CLI, principalmente com sharding (512 dbs lógicos em cada físico).

Para esse propósito, escrevo a ferramenta cliente java que faz todo esse trabalho. No caso de exclusão de chaves, o utilitário pode ser muito simples, apenas uma 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();
    }

}

Ao escrever esse tipo de ferramenta, acho muito fácil e não gasto mais que 5 a 10 minutos.

FLUSHALL Exclui todos os bancos de dados de Keys of All existentes. Para a versão Redis> 4.0, é suportado o FLUSHALL ASYNC, que é executado em um encadeamento em segundo plano sem bloquear o servidor https://redis.io/commands/flushall

FLUSHDB - Exclui todas as chaves no banco de dados selecionado. https://redis.io/commands/flushdb

A complexidade do tempo para executar as operações será O (N), onde N é o número de chaves no banco de dados.

A resposta dos redis será uma sequência simples "OK"

Você pode usar o FLUSHALL, que excluirá todas as chaves de todos os seus bancos de dados. Onde FLUSHDB excluirá todas as chaves do nosso banco de dados atual.

1. Pare a instância do Redis.
2. Exclua o arquivo RDB.
3. Inicie a instância do Redis.

Use FLUSHALL ASYNCse estiver usando (Redis 4.0.0 ou superior) mais FLUSHALL.

https://redis.io/commands/flushall

Nota : Tudo antes da execução FLUSHALL ASYNCserá despejado. As alterações feitas durante a execução FLUSHALL ASYNCpermanecerão inalteradas.

Abra redis-cli e digite:

FLUSHALL

acho que às vezes para o redis-server e exclui rdb (aof files), verifique se não há dados que possam ser recarregados. depois inicie o redis-server, agora está novo e vazio.

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

Ele removerá todos os dados do cliente conectado (com host e porta)

Depois de iniciar o servidor Redis usando: service redis-server start --port 8000ou redis-server.

Use redis-cli -p 8000para se conectar ao servidor como um cliente em um terminal diferente.

Você pode usar

1. FLUSHDB - Exclua todas as chaves do banco de dados selecionado no momento. Este comando nunca falha. A complexidade de tempo para esta operação é O (N), N sendo o número de chaves no banco de dados.
2. FLUSHALL - Exclua todas as chaves de todos os bancos de dados existentes, não apenas o atualmente selecionado. Este comando nunca falha. A complexidade de tempo para esta operação é O (N), N sendo o número de chaves em todos os bancos de dados existentes.

Verifique a documentação para a opção ASYNC para ambos.

Se você estiver usando o Redis através de sua interface python, use estas duas funções para a mesma funcionalidade:

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

e

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

Suas perguntas parecem ser sobre a exclusão de chaves inteiras em um banco de dados. Nesse caso, você deve tentar:

1. Conecte-se ao redis. Você pode usar o comando redis-cli(se estiver executando na porta 6379); caso contrário, também precisará especificar o número da porta.
2. Selecione seu banco de dados (comando select {Index})
3. Execute o comando flushdb

Se você deseja liberar chaves em todos os bancos de dados, tente flushall.

Um clique em FastoRedis / FastoNoSQL

Você pode usar FLUSHDB

por exemplo

Listar bancos de dados:

127.0.0.1:6379> info keyspace
# Keyspace

Chaves de lista

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

Adicione um valor a uma chave

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

Crie outra chave com dois 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 os valores na chave2

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

Faça FLUSHDB

127.0.0.1:6379> flushdb
OK

Listar chaves e bancos de dados

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

você pode usar a seguinte abordagem em 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

É melhor se você pode ter RDM (Redis Desktop Manager). Você pode se conectar ao seu servidor redis criando uma nova conexão no RDM.

Uma vez conectado, você pode verificar os dados ao vivo, também pode brincar com qualquer comando redis.

Abrindo um CLI no RDM.

1) Clique com o botão direito do mouse na conexão em que você verá uma opção de console; basta clicar nela; uma nova janela do console será aberta na parte inferior do RDM.

Voltando à sua pergunta FLUSHALL é o comando, você pode simplesmente digitar FLUSHALL no redis cli.

Além disso, se você quiser saber sobre qualquer comando redis e seu uso adequado, acesse o link abaixo. https://redis.io/commands .

Existem abordagens diferentes. Se você quiser fazer isso de forma remota, emita o comando flushall para essa instância, por meio da ferramenta de linha de comando redis-cli ou de qualquer outra ferramenta, por exemplo, telnet, um SDK da linguagem de programação. Ou simplesmente faça login no servidor, interrompa o processo, exclua seu arquivo dump.rdb e appendonly.aof (faça backup deles antes da exclusão).

Se você estiver usando Java e, a partir da documentação, poderá usar qualquer um deles com base no seu 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();

Leia mais: https://github.com/lettuce-io/lettuce-core/wiki/Redis-Cluster