minhas informações de contato
Correspondência[email protected]
2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Redis (RemoteDictionaryServer, tipo de dicionário remoto) é um banco de dados NoSQL de código aberto escrito em linguagem C. Redis é executado com base na memória e suporta persistência. Ele adota a forma de armazenamento de valor-chave (par de valores-chave) e é uma parte indispensável da arquitetura distribuída atual.
NoSQL (NoSQL = Not Only SQL), que significa “não apenas SQL”, é o termo geral para bancos de dados não relacionais. Os principais bancos de dados NoSQL incluem Redis, MongBD, Hbase, CouhDB, etc. Os bancos de dados não relacionais acima são completamente diferentes em seus métodos de armazenamento, estruturas de armazenamento e cenários de uso. Então pensamos que é uma coleção de bancos de dados não relacionais, e não um termo geral como bancos de dados relacionais. Em outras palavras, outros bancos de dados que não sejam os bancos de dados relacionais convencionais podem ser considerados não relacionais. O banco de dados NOSQL é considerado o produto de banco de dados da próxima geração devido às suas vantagens de expansão não relacional, distribuída, de código aberto e horizontal.
Um banco de dados relacional é um banco de dados estruturado baseado em um modelo relacional e geralmente orientado a registros. Ele processa dados em bancos de dados com a ajuda de conceitos e métodos matemáticos como álgebra de conjuntos. O modelo relacional refere-se ao modelo de tabela bidimensional, portanto um banco de dados relacional é uma organização de dados composta por tabelas bidimensionais e os relacionamentos entre elas. No mundo real, várias entidades e vários relacionamentos entre entidades podem ser representados por modelos relacionais. A instrução SQL (Standard Data Query Language) é uma linguagem baseada em um banco de dados relacional e é usada para recuperar e operar dados em um banco de dados relacional.
Com o surgimento dos sites Web2.0, os bancos de dados relacionais são expostos ao lidar com sites Web2.0, especialmente sites Web2.0 puramente dinâmicos com dados massivos e SNS (Serviços de Rede Social, ou seja, serviços de rede social) de alta simultaneidade. que são difíceis de resolver, como o problema dos três altos.
Os sites Web2.0 gerarão páginas dinâmicas e fornecerão informações dinâmicas em tempo real com base nas informações personalizadas do usuário, portanto, a tecnologia estática de páginas dinâmicas não pode ser usada. Portanto, a carga simultânea do banco de dados é muito alta, geralmente atingindo mais de 10.000 solicitações/s de leitura e gravação. O banco de dados relacional ainda mal consegue suportar dezenas de milhares de solicitações de consulta, mas se houver dezenas de milhares de solicitações de gravação de dados, o disco rígido I0 não poderá mais suportá-lo. Para sites BBS comuns, muitas vezes há muitas solicitações simultâneas de gravação de dados.
Sites SNS como Facebook e Friendfeed geram uma grande quantidade de informações dinâmicas do usuário todos os dias. Por exemplo, o Friendfeed gerará nada menos que 250 milhões de informações dinâmicas de usuários em um mês. Para bancos de dados relacionais, a eficiência da consulta é muito baixa ao executar consultas SQL em uma tabela contendo 250 milhões de registros.
Na arquitetura Web, o banco de dados é o mais difícil de escalar horizontalmente. Quando o número de usuários e visitas ao sistema de aplicação aumenta dia a dia, o banco de dados não pode simplesmente expandir seu desempenho e capacidade de carga adicionando hardware e nós de servidor, como serviços Web. Especialmente para alguns sites que precisam fornecer serviços 24 horas por dia, as atualizações e expansões de banco de dados são frequentemente acompanhadas de manutenção de inatividade e migração de dados, e a carga de trabalho é muito grande.
Bancos de dados relacionais e bancos de dados não relacionais têm características e cenários de aplicação próprios. A combinação próxima dos dois trará novas ideias para o desenvolvimento de bancos de dados Web2.0. Deixe que os bancos de dados relacionais se concentrem nos relacionamentos e os bancos de dados não relacionais se concentrem no armazenamento. Por exemplo, em um ambiente de banco de dados MySQL onde a leitura e a gravação são separadas, os dados acessados com frequência podem ser armazenados em um banco de dados não relacional para melhorar a velocidade de acesso.
Possui velocidades de leitura e gravação de dados extremamente altas. A velocidade de leitura de dados pode chegar a até 110.000 vezes/s, e a velocidade de gravação de dados pode chegar a até 81.000 vezes/s.
Suporta tipos de dados ricos, não apenas suporta dados simples de tipo de valor-chave, mas também suporta operações de tipo de dados, como Strings, Listas, Hashes, Conjuntos e Conjuntos Ordenados.
Suporta persistência de dados Os dados na memória podem ser salvos em disco e carregados novamente para uso ao reiniciar.
Atômica, todas as operações do Redis são atômicas.
Suporta backup de dados, ou seja, backup de dados no modo master-salve.
Redis é um banco de dados baseado em memória e o cache é um dos cenários de aplicação mais comuns. Além disso, os cenários de aplicativos comuns do Redis também incluem operações para obter os dados N mais recentes, classificação de aplicativos, aplicativos de contador, relacionamentos de armazenamento, sistemas de análise em tempo real e registro em log.
[root@localhost ~]# systemctl stop firewalld //No ambiente experimental, desligar o firewall não tem efeito. Não é recomendado desligá-lo no ambiente de produção.
[root@localhost ~]# setenforce 0 //Desativa o kernel, o que bloqueará a execução do aplicativo.
[root@localhost ~]# yum -y install gcc* zlib-devel //Baixa as ferramentas necessárias para descompactar o pacote tar
[root@localhost ~]#tar xvzf redis-4.0.9.tar.gz //redis é um aplicativo de código aberto e gratuito. Você pode baixar este pacote no site oficial.
[root@localhost ~]#cd redis-4.0.9/
[root@localhost redis-4.0.9]# fazer
Perceber:
Ao fazer, pode aparecer a seguinte mensagem de erro:
Solução 1: usarfaça MALLOC=libc especifica o alocador de memória para libccompilar
Solução 2: make clean && make distclean
[root@localhost redis-4.0.9]# make PREFIX=/usr/local/redis install
[root@localhost ~]# ln -s /usr/local/redis/bin/* /usr/local/bin/
[root@localhost redis-4.0.9]# cd /root/redis-4.0.9/utils/
[utilitários root@localhost]# ./install_server.sh
Observação:
Arquivo de configuração: /etc/redis/6379.conf //Caminho do arquivo de configuração
Arquivo de log: /var/log/redis_6379.log //Caminho do arquivo de log
Diretório de dados: /var/lib/redis/6379 //Caminho do arquivo de dados
Executável: /usr/local/redis/bin/redis-server //caminho do arquivo executável
Executável Cli: /usr/local/redis/bin/redis-cli //Ferramenta de linha de comando do cliente
[utilitários root@localhost]# netstat -anpt | grep redis
[root@localhost ~]#/etc/init.d/redis_6379 parar
[root@localhost ~]#/etc/init.d/redis_6379 iniciar
[root@localhost ~]#/etc/init.d/redis_6379 reiniciar
[root@localhost ~]#/etc/init.d/redis_6379 estado
[root@localhost ~]#vim /etc/redis/6379.conf
vincular 127.0.0.1 192.168.10.101 //Escutando endereço do host
porto 6379 //porta
demonizar sim //Habilita processo daemon
arquivo pid /var/run/redis_6379.pid //Especifica o arquivo PID
aviso de nível de log //nível de registro
arquivo de log /var/log/redis_6379.log //Especifica o arquivo de log
[root@localhost~]#/etc/init.d/redis_6379 reiniciar
[utilitários root@localhost]# netstat -anpt | grep redis
Ø redis-server: ferramenta para iniciar o Redis;
Ø redis-benchmark: usado para detectar a eficiência de execução do Redis nesta máquina;
Ø redis-check-aof: Repara o arquivo de persistência AOF;
Ø redis-check-rdb: Repara arquivos de persistência RDB;
Ø redis-cli: ferramenta de linha de comando do Redis.
[root@localhost ~]# redis-cli
127.0.0.1:6379>
127.0.0.1:6379> ping
PONG
[root@localhost ~]#redis-cli -h 192.168.10.101 -p 6379
Ø ajuda@<group> :Obtivermos<group> lista de comandos em ;
Ø ajuda<command> : Obtenha ajuda para um comando;
Ø ajuda<tab> : obtenha uma lista de tópicos que podem ajudar.
Observação:
Ø ajuda<tab> : obtenha uma lista de tópicos que podem ajudar.
Depois de digitar help, pressione a tecla tab
127.0.0.1:6379>ajuda @lista
127.0.0.1:6379>ajuda definir
redis-benchmark é a ferramenta oficial de teste de desempenho do Redis que pode testar com eficácia o desempenho dos serviços Redis.
Ø -h: Especifique o nome do host do servidor;
Ø -p: Especifique a porta do servidor;
Ø -s: Especifique o soquete do servidor;
Ø -c: Especifique o número de conexões simultâneas;
Ø -n: Especifique o número de solicitações;
Ø -d: Especifique o tamanho dos dados do valor SET/GET em bytes;
Ø -k：1=manter vivo 0=reconectar；
Ø -r: SET/GET/INCR usa chaves aleatórias, SADD usa valores aleatórios;
Ø -P: Transmissão através de tubos<numreq> perguntar;
Ø -q: Força o encerramento do redis. Somente valores de consulta/seg são exibidos;
Ø --csv: saída em formato CSV;
Ø -l: Gera um loop e executa o teste permanentemente;
Ø -t: executa apenas uma lista de comandos de teste separados por vírgula;
Ø -I: Modo inativo. Abra apenas N conexões ociosas e aguarde.
[root@localhost ~]#redis-benchmark -h 192.168.10.101 -p 6379 -c 100 -n 100000 //Envia 100 conexões simultâneas e 100.000 testes de solicitação para o servidor Redis com endereço IP 192.168.10.101 e desempenho da porta 6379
Observação:
Ø -h: Especifique o nome do host do servidor;
Ø -p: Especifique a porta do servidor;
Ø -c: Especifique o número de conexões simultâneas;
Ø -n: Especifique o número de solicitações;
====== MSET (10 teclas) ======
100000 solicitações concluídas em 1,02 segundos
100 clientes paralelos ##100 conexões simultâneas
Carga útil de 3 bytes
manter vivo: 1
87,25% <= 1 milissegundo ##87,25% dos tempos de execução de comandos são menores ou iguais a 1 milissegundo
99,90% <= 2 milissegundos
100,00% <= 2 milissegundos
97943,19 solicitações por segundo #Número de solicitações por segundo
[root@localhost ~]#redis-benchmark -h 192.168.10.101 -p 6379 -q -d 100
Observação:
Ø -h: Especifique o nome do host do servidor;
Ø -p: Especifique a porta do servidor;
Ø -d: Especifique o tamanho dos dados do valor SET/GET em bytes;
Ø -q: Força o encerramento do redis. Somente valores de consulta/seg são exibidos;
PING_INLINE: 121506,68 solicitações por segundo //Quantas operações PING são concluídas por segundo
PING_BULK: 124378,11 solicitações por segundo
SET: 121654,50 solicitações por segundo //Quantas vezes por segundo o valor da chave SET é concluído
GET: 122100,12 solicitações por segundo //Quantos valores de chave GET foram concluídos por segundo
INCR: 118764,84 solicitações por segundo //Quantas contagens atômicas são concluídas por segundo
LPUSH: 112612,61 solicitações por segundo
RPUSH: 118623,96 solicitações por segundo
LPOP: 107874,87 solicitações por segundo
RPOP: 114416,48 solicitações por segundo
SADD: 123304,56 solicitações por segundo
HSET: 122249,38 solicitações por segundo
SPOP: 128040,97 solicitações por segundo
LPUSH (necessário para comparar LRANGE): 116686,12 solicitações por segundo
LRANGE_100 (primeiros 100 elementos): 40016,00 solicitações por segundo
LRANGE_300 (primeiros 300 elementos): 11991,85 solicitações por segundo
LRANGE_500 (primeiros 450 elementos): 7381,71 solicitações por segundo
LRANGE_600 (primeiros 600 elementos): 5230,67 solicitações por segundo
MSET (10 chaves): 92421,44 solicitações por segundo //Chave múltipla v por segundolouvorNúmero de solicitações
[root@localhost ~]# redis-benchmark -t definir,lpush -n 100000 -q //Teste o desempenho do serviço Redis nesta máquina durante operações set e lpush.
Observação:
Ø -n: Especifique o número de solicitações;
Ø -q: Força o encerramento do redis. Somente valores de consulta/seg são exibidos;
Ø -t: executa apenas uma lista de comandos de teste separados por vírgula;
SET: 121951,22 solicitações por segundo
LPUSH: 127226,46 solicitações por segundo
Ø definir: Armazene dados. O formato básico do comando é. definir valor chave。
Ø pegar: Obtenha dados, o formato básico do comando é pegue a chave。
existir Redis no banco de dados, com chave Os comandos relevantes incluem principalmente o seguinte.
usar chaves O comando pode receber uma lista de valores-chave que estão em conformidade com as regras. Geralmente, pode ser combinado.* ,? opções para usar.
127.0.0.1:6379>conjunto k1 1
OK
127.0.0.1:6379>conjunto k2 2
OK
127.0.0.1:6379>conjunto k3 3
OK
127.0.0.1:6379>conjunto v1 4
OK
127.0.0.1:6379>conjunto v5 5
OK
127.0.0.1:6379>CHAVES *
1) "professor"
2) "k1"
3) "k2"
4) "k3"
5) "v1"
6) "v5"
127.0.0.1:6379>conjunto v22 5
OK
127.0.0.1:6379>CHAVES v*
1) "v1"
2) "v5"
3) "v22"
127.0.0.1:6379>CHAVES v?
1) "v1"
2) "v5"
127.0.0.1:6379>CHAVES v??
1) "v22"
existe O comando pode determinar se o valor da chave existe
127.0.0.1:6379>existe professor
(inteiro) 1
O resultado é 1, o que significa professor a chave existe
127.0.0.1:6379>existe chá
(inteiro) 0
O resultado é 0, o que significa chá chave não existe
do O comando pode excluir o especificado chave
127.0.0.1:6379>chaves *
1) "professor"
2) "v1"
3) "v22"
4) "k3"
5) "k1"
6) "k2"
7) "v5"
127.0.0.1:6379> do v5
(inteiro) 1
127.0.0.1:6379>obter v5
(nada)
usar tipo O comando pode ser obtido chave correspondente valor tipo de valor
127.0.0.1:6379>tipo k1
corda
Observação:
Tipos de dados suportados pelo redis
renomear O comando é para um existente chave renomear
No uso real, é recomendado usar existe Comando para visualizar o alvo chave existe e então decidir se deseja executar renomear comando para evitar a substituição de dados importantes
127.0.0.1:6379>chaves v*
1) "v1"
2) "v22"
127.0.0.1:6379>renomear v22 v2
OK
127.0.0.1:6379>chaves v*
1) "v1"
2) "v2"
127.0.0.1:6379>obter v1
"4"
127.0.0.1:6379>obter v2
"5"
127.0.0.1:6379>renomear v1 v2
OK
127.0.0.1:6379>obter v1
(nada)
127.0.0.1:6379>obter v2
"4"
renomear A função do comando é modificar o existente chave Execute uma renomeação e verifique se o novo nome existe.
usarrenomear Quando o comando for renomeado, se o destino chave Se existir, não será renomeado.
127.0.0.1:6379>chaves *
1) "professor"
2) "k3"
3) "k1"
4) "k2"
5) "v2"
127.0.0.1:6379>pegue o professor
"Zhanglong" (em chinês)
127.0.0.1:6379>obter v2
"4"
127.0.0.1:6379>renamenx v2 professor
(inteiro) 0
127.0.0.1:6379>chaves *
1) "professor"
2) "k3"
3) "k1"
4) "k2"
5) "v2"
127.0.0.1:6379>pegue o professor
"Zhanglong" (em chinês)
127.0.0.1:6379>obter v2
"4
tamanho do banco de dados O objetivo do comando é visualizar o banco de dados atual chave Número de.
127.0.0.1:6379> tamanho do banco de dados
(inteiro) 5
Redis Incluído por padrão sem quaisquer alterações 16 banco de dados, o nome do banco de dados é um número 0-15 ser nomeado em ordem
（1）Mude para o número de série 10 base de dados
127.0.0.1:6379>selecione 10
OK
（2）Mude para o número de série 15 base de dados
127.0.0.1:6379[10]>selecione 15
OK
（3）Mude para o número de série 0 base de dados
127.0.0.1:6379[15]>selecione 0
Redis Os vários bancos de dados são relativamente independentes até certo ponto, por exemplo, no banco de dados 0 Armazenar acima k1 dados, em outros 1-15 Não pode ser visualizado no banco de dados.
127.0.0.1:6379>conjunto k1 100
OK
127.0.0.1:6379>pegue k1
"100"
127.0.0.1:6379>selecione 1
OK
127.0.0.1:6379[1]>pegue k1
(nada)
127.0.0.1:6379[1]>selecione 0 //Mudar para banco de dados de destino 0
OK
127.0.0.1:6379>pegue k1 //Verifique se os dados de destino existem
"100"
127.0.0.1:6379>mover k1 1 //base de dados 0 meio k1 Mover para banco de dados 1 meio
(inteiro) 1
127.0.0.1:6379>selecione 1 //Mudar para banco de dados de destino 1
OK
127.0.0.1:6379[1]>pegue k1 //Ver dados movidos
"100"
127.0.0.1:6379[1]> selecione 0
OK
127.0.0.1:6379> pegue k1 //no banco de dados 0 Não pode ser visualizado em k1 valor
(nada)
Para limpar os dados atuais do banco de dados, use FLUSHDB
Implementação de comando; limpe todos os dados do banco de dados, use DESCARGA Implementação de comando
Redis Todos os dados são armazenados na memória e, de tempos em tempos, salvos de forma assíncrona no disco.(Isso é chamado“Modo semipersistente”); Você também pode gravar todas as alterações de dados em um anexar somente arquivo(aof)em(Isso é chamado“Modo de persistência total”)。
Como os dados do Redis são armazenados na memória, se a persistência não estiver configurada,Redis Após reiniciar, todos os dados serão perdidos.Portanto, é necessário habilitarRedis A função de persistência salva dados no disco. Redis Após uma reinicialização, os dados podem ser recuperados do disco.Redis Dois métodos são fornecidos para persistência, um é RDB（Banco de dados Redis） Persistência (o princípio é Reid-Re ...Tempo de registro do banco de dados na memória jogar fora para disco RDB persistência), o outro é AOF（anexar somente arquivo）Persistência (o princípio é Reid-Re ... O log de operação é gravado no arquivo de maneira anexada).
O método padrão
A persistência RDB é o processo de gerar um instantâneo dos dados do processo atual e salvá-los no disco rígido. O processo de acionamento da persistência RDB é dividido em acionamento manual e acionamento automático.
Mecanismo de disparo: O disparo manual corresponde aos comandos save e bgsave respectivamente.
Comando save: bloqueia o servidor Redis atual até que o processo RDB seja concluído. Para instâncias com grande quantidade de memória, isso causará bloqueio de tempo. Não recomendado para uso em ambientes online.
Comando bgsave: O processo Redis executa a operação fork (função usada para criar um processo) para criar um processo filho. O processo de persistência RDB é responsável pelo processo filho e termina automaticamente após a conclusão. O bloqueio ocorre apenas durante a fase de bifurcação.
Vantagens do RDB:
RDB é um arquivo binário compacto e compactado que representa um instantâneo dos dados do Redis em um determinado momento. É muito adequado para backup, cópia completa e outros cenários. Por exemplo, execute o backup bgsave a cada 6 horas e copie o arquivo RDB para a máquina remota ou sistema de arquivos para recuperação de desastres.
O Redis carrega RDB e recupera dados muito mais rápido que o método AOF.
Desvantagens do RDB:
Os dados no modo RDB não podem alcançar persistência em tempo real/persistência de segundo nível. Porque toda vez que o bgsave é executado, uma operação de bifurcação é executada para criar um processo filho, que é uma operação pesada e o custo da execução frequente é muito alto.
Os arquivos RDB são salvos em um formato binário específico Durante a evolução das versões do Redis, existem vários formatos de versões do RDB. Há um problema de que a versão antiga do serviço Redis não é compatível com a nova versão do formato RDB.
Persistência AOF (anexar apenas arquivo): registre cada comando de gravação em um log independente e, em seguida, execute novamente o comando no arquivo AOF para restaurar os dados ao reiniciar. A principal função do AOF é resolver o problema de persistência de dados em tempo real. Agora é a corrente principal da persistência do Redis.
Critérios para escolher entre os dois:
Sacrifique algum desempenho em troca de maior consistência de cache (AOF），
Quando as operações de gravação são frequentes, não habilite o backup em troca de maior desempenho e aguarde a operação manual. salvar quando, faça um backup novamente (RDB）
Observação:
Se um arquivo persistente precisar ser carregado após a reinicialização do redies, os arquivos AOF serão selecionados.
Se o RDB for habilitado primeiro e depois o AOF for habilitado, e o RDB for persistido primeiro, o conteúdo do arquivo RDB será substituído pelo AOF.
[root@localhost ~]# vim /etc/redis/6379.conf
Abra 6379.conf Após o arquivo, pesquise salvar, você pode ver as informações de configuração conforme mostrado abaixo.
existir Redis Existem três métodos de sincronização no arquivo de configuração, são eles:
sempre: persistência síncrona, sempre que os dados forem alterados, eles serão gravados no disco imediatamente
Everysec: recomendado por padrão, registre de forma assíncrona a cada segundo (valor padrão)
não: Sem sincronização, deixando para o sistema operacional decidir como sincronizar
Ignore a última instrução potencialmente problemática
[root@localhost ~]#/etc/init.d/redis_6379 reiniciar
a fim de resolver AOF Se o tamanho do arquivo continuar a aumentar, os usuários poderão reportar Redis enviar BGREWRITEAOFOrdem.BGREWRITEAOF O comando será removido via AOF comandos redundantes no arquivo para substituir (reescrever）AOFarquivo, faça AOF Mantenha o tamanho do arquivo o menor possível.
127.0.0.1:6379> bgrewriteaof
Reescrita de arquivo somente anexado em segundo plano iniciada
# Quando o log for BGREWRITEAOF,seno-appendfsync-na-reescritaDefinido como sim, o que significa que novas operações de gravação não serão sincronizadas com fsync, mas serão armazenadas apenas temporariamente no buffer. , para evitar conflitos de operação de E/S de disco, aguarde até que a reescrita seja concluída antes de gravar. O padrão no Redis é não
no-appendfsync-on-rewrite não
# Quando o tamanho do arquivo AOF atual é duas vezes maior que o tamanho do arquivo AOF durante a última reescrita do log, ocorre a operação BGREWRITEAOF.
auto-aof-rewrite-porcentagem 100
Observação:
100 refere-se aA taxa de crescimento do arquivo AOF refere-se à taxa de crescimento do arquivo AOF atual em comparação com a última reescrita.，100 é duas vezes
#O valor mínimo do arquivo AOF atual para executar o comando BGREWRITEAOF para evitar BGREWRITEAOF frequente devido ao pequeno tamanho do arquivo quando o Reids é iniciado pela primeira vez.
auto-aof-rewrite-tamanho-mínimo 64mb
192.168.9.236:7001> informação memória
used_memory:1210776 #O tamanho da memória usada,em bytes
used_memory_human:1.15M # Display com unidade,em M
used_memory_rss:7802880 # Quanta memória o redis ocupa da perspectiva do sistema operacional?
used_memory_rss_human:7.44M # Exibição com unidade
maxmemory:1073741824 # Tamanho máximo da memória
maxmemory_human:1.00G # Display com unidade
política-de-memória-máxima: Estratégia de reciclagem
Ø volátil-lru: permite Redis Escolha o menos usado recentemente em todo o conjunto de dados chave Excluir
Ø volátil-ttl：Elimine de acordo com o prazo de validade da chave
Ø volátil-aleatório: Selecione aleatoriamente os dados para eliminação da coleta de dados com tempo de expiração definido;
Ø todas as chaves-lru:usar LRU Os algoritmos eliminam dados de todos os conjuntos de dados;
Ø todas as chaves-aleatórias: Selecione aleatoriamente os dados para eliminação da coleta de dados;
Ø não despejo: Desativa a eliminação de dados (valor padrão)
Observação:
Defina o tempo de expiração da chave
expirar v1 10
v1 tem um tempo de expiração de 10 segundos
Observação:
quando Redis Precisa recuperar um devido à pressão de memória chave hora,Redis A primeira consideração não é reciclar os dados mais antigos, mas sim os dados menos utilizados recentemente. chave ou prestes a expirar chave Escolha um aleatoriamente entre chave, removido do conjunto de dados
Encontre a palavra-chave requirepass, seguida da senha. Ela é comentada por padrão, ou seja, nenhuma senha é exigida por padrão, como segue:
Abra o comentário, defina-o como sua própria senha e reinicie
Use redis-cli para conectar-se ao redis e execute o seguinte comando
conjunto de configuração requirepass 123456
Após a conclusão da execução, não há necessidade de reiniciar. Você precisará inserir sua senha ao sair do cliente e fazer login novamente.
[root@localhost bin]# ./redis-cli -a 123456
[root@localhost bin]# ./redis-cli127.0.0.1:6379> autenticação 123456
[root@localhost bin]# ./redis-cli -a 123456 desligamento
1) A senha definida pela modificação do arquivo de configuração terá efeito permanente; a senha definida pelo comando terá efeito temporário e se tornará inválida após a reinicialização;
2) A modificação da senha definida no arquivo de configuração requer uma reinicialização para ter efeito; use a senha definida pelo comando para entrar em vigor após efetuar logout e login novamente, e ela se tornará inválida após a reinicialização.
3) A prioridade do comando é maior que a prioridade do arquivo de configuração
Ele se dedica à pesquisa de tecnologia há mais de 30 anos e é proficiente em diversas linguagens como java, linux, javascript, php, css, etc. estação de documentação do desenvolvedor para compartilhar alguns problemas no desenvolvimento de tecnologia para referência futura.
Correspondência[email protected]