Redis - Guia rápido
Redis é um armazenamento avançado de chave-valor de código aberto e uma solução adequada para a construção de aplicativos da web escaláveis de alto desempenho.
O Redis tem três particularidades principais que o diferenciam.
O Redis mantém seu banco de dados inteiramente na memória, usando o disco apenas para persistência.
O Redis tem um conjunto relativamente rico de tipos de dados quando comparado a muitos armazenamentos de dados de valor-chave.
O Redis pode replicar dados para qualquer número de escravos.
Vantagens do Redis
A seguir estão algumas vantagens do Redis.
Exceptionally fast - O Redis é muito rápido e pode realizar cerca de 110000 SETs por segundo, cerca de 81000 GETs por segundo.
Supports rich data types- O Redis suporta nativamente a maioria dos tipos de dados que os desenvolvedores já conhecem, como lista, conjunto, conjunto classificado e hashes. Isso facilita a solução de uma variedade de problemas, pois sabemos qual problema pode ser tratado melhor por qual tipo de dados.
Operations are atomic - Todas as operações do Redis são atômicas, o que garante que, se dois clientes acessarem simultaneamente, o servidor Redis receberá o valor atualizado.
Multi-utility tool - Redis é uma ferramenta multi-utilitários e pode ser usada em uma série de casos de uso, como cache, filas de mensagens (o Redis oferece suporte nativo para Publicação / Assinatura), quaisquer dados de curta duração em seu aplicativo, como sessões de aplicativos da web, web contagens de visitas de página, etc.
Redis versus outras lojas de valores-chave
Redis é um caminho de evolução diferente nos bancos de dados de valor-chave, onde os valores podem conter tipos de dados mais complexos, com operações atômicas definidas nesses tipos de dados.
O Redis é um banco de dados na memória, mas é persistente no banco de dados do disco, portanto, representa uma troca diferente, onde a velocidade de gravação e leitura muito alta é alcançada com a limitação de conjuntos de dados que não podem ser maiores do que a memória.
Outra vantagem dos bancos de dados na memória é que a representação da memória de estruturas de dados complexas é muito mais simples de manipular em comparação com a mesma estrutura de dados no disco. Assim, o Redis pode fazer muito com pouca complexidade interna.
Neste capítulo, você aprenderá sobre a configuração ambiental do Redis.
Instale o Redis no Ubuntu
Para instalar o Redis no Ubuntu, vá para o terminal e digite os seguintes comandos -
$sudo apt-get update $sudo apt-get install redis-serverIsso instalará o Redis em sua máquina.
Iniciar Redis
$redis-serverVerifique se o Redis está funcionando
$redis-cliIsso abrirá um prompt do redis.
redis 127.0.0.1:6379>No prompt acima, 127.0.0.1 é o endereço IP da sua máquina e 6379é a porta na qual o servidor Redis está sendo executado. Agora digite o seguintePING comando.
redis 127.0.0.1:6379> ping
PONGIsso mostra que o Redis foi instalado com sucesso em sua máquina.
Instale o Redis Desktop Manager no Ubuntu
Para instalar o gerenciador de desktop Redis no Ubuntu, basta baixar o pacote em https://redisdesktop.com/download
Abra o pacote baixado e instale-o.
O gerenciador de área de trabalho Redis fornecerá a interface do usuário para gerenciar suas chaves e dados Redis.
No Redis, existe um arquivo de configuração (redis.conf) disponível no diretório raiz do Redis. Embora você possa obter e definir todas as configurações do Redis pelo RedisCONFIG comando.
Sintaxe
A seguir está a sintaxe básica do Redis CONFIG comando.
redis 127.0.0.1:6379> CONFIG GET CONFIG_SETTING_NAMEExemplo
redis 127.0.0.1:6379> CONFIG GET loglevel
1) "loglevel"
2) "notice"Para obter todas as definições de configuração, use * no lugar de CONFIG_SETTING_NAME
Exemplo
redis 127.0.0.1:6379> CONFIG GET *
1) "dbfilename"
2) "dump.rdb"
3) "requirepass"
4) ""
5) "masterauth"
6) ""
7) "unixsocket"
8) ""
9) "logfile"
10) ""
11) "pidfile"
12) "/var/run/redis.pid"
13) "maxmemory"
14) "0"
15) "maxmemory-samples"
16) "3"
17) "timeout"
18) "0"
19) "tcp-keepalive"
20) "0"
21) "auto-aof-rewrite-percentage"
22) "100"
23) "auto-aof-rewrite-min-size"
24) "67108864"
25) "hash-max-ziplist-entries"
26) "512"
27) "hash-max-ziplist-value"
28) "64"
29) "list-max-ziplist-entries"
30) "512"
31) "list-max-ziplist-value"
32) "64"
33) "set-max-intset-entries"
34) "512"
35) "zset-max-ziplist-entries"
36) "128"
37) "zset-max-ziplist-value"
38) "64"
39) "hll-sparse-max-bytes"
40) "3000"
41) "lua-time-limit"
42) "5000"
43) "slowlog-log-slower-than"
44) "10000"
45) "latency-monitor-threshold"
46) "0"
47) "slowlog-max-len"
48) "128"
49) "port"
50) "6379"
51) "tcp-backlog"
52) "511"
53) "databases"
54) "16"
55) "repl-ping-slave-period"
56) "10"
57) "repl-timeout"
58) "60"
59) "repl-backlog-size"
60) "1048576"
61) "repl-backlog-ttl"
62) "3600"
63) "maxclients"
64) "4064"
65) "watchdog-period"
66) "0"
67) "slave-priority"
68) "100"
69) "min-slaves-to-write"
70) "0"
71) "min-slaves-max-lag"
72) "10"
73) "hz"
74) "10"
75) "no-appendfsync-on-rewrite"
76) "no"
77) "slave-serve-stale-data"
78) "yes"
79) "slave-read-only"
80) "yes"
81) "stop-writes-on-bgsave-error"
82) "yes"
83) "daemonize"
84) "no"
85) "rdbcompression"
86) "yes"
87) "rdbchecksum"
88) "yes"
89) "activerehashing"
90) "yes"
91) "repl-disable-tcp-nodelay"
92) "no"
93) "aof-rewrite-incremental-fsync"
94) "yes"
95) "appendonly"
96) "no"
97) "dir"
98) "/home/deepak/Downloads/redis-2.8.13/src"
99) "maxmemory-policy"
100) "volatile-lru"
101) "appendfsync"
102) "everysec"
103) "save"
104) "3600 1 300 100 60 10000"
105) "loglevel"
106) "notice"
107) "client-output-buffer-limit"
108) "normal 0 0 0 slave 268435456 67108864 60 pubsub 33554432 8388608 60"
109) "unixsocketperm"
110) "0"
111) "slaveof"
112) ""
113) "notify-keyspace-events"
114) ""
115) "bind"
116) ""Editar configuração
Para atualizar a configuração, você pode editar redis.conf arquivo diretamente ou você pode atualizar as configurações via CONFIG set comando.
Sintaxe
A seguir está a sintaxe básica de CONFIG SET comando.
redis 127.0.0.1:6379> CONFIG SET CONFIG_SETTING_NAME NEW_CONFIG_VALUEExemplo
redis 127.0.0.1:6379> CONFIG SET loglevel "notice"
OK
redis 127.0.0.1:6379> CONFIG GET loglevel
1) "loglevel"
2) "notice"O Redis oferece suporte a 5 tipos de dados.
Cordas
A string Redis é uma sequência de bytes. Strings no Redis são binárias seguras, o que significa que têm um comprimento conhecido não determinado por nenhum caractere especial de terminação. Assim, você pode armazenar qualquer coisa até 512 megabytes em uma string.
Exemplo
redis 127.0.0.1:6379> SET name "tutorialspoint"
OK
redis 127.0.0.1:6379> GET name
"tutorialspoint"No exemplo acima, SET e GET são comandos Redis, name é a chave usada no Redis e tutorialspoint é o valor da string armazenado no Redis.
Note - Um valor de string pode ter no máximo 512 megabytes de comprimento.
Hashes
Um hash Redis é uma coleção de pares de valores-chave. Redis Hashes são mapas entre campos de string e valores de string. Portanto, eles são usados para representar objetos.
Exemplo
redis 127.0.0.1:6379> HMSET user:1 username tutorialspoint password
tutorialspoint points 200
OK
redis 127.0.0.1:6379> HGETALL user:1
1) "username"
2) "tutorialspoint"
3) "password"
4) "tutorialspoint"
5) "points"
6) "200"No exemplo acima, o tipo de dados hash é usado para armazenar o objeto do usuário que contém informações básicas do usuário. AquiHMSET, HGETALL são comandos para Redis, enquanto user − 1 É a chave.
Cada hash pode armazenar até 2 32-1 pares de valor de campo (mais de 4 bilhões).
Listas
Listas Redis são simplesmente listas de strings, classificadas por ordem de inserção. Você pode adicionar elementos a uma Lista Redis no cabeçalho ou no final.
Exemplo
redis 127.0.0.1:6379> lpush tutoriallist redis
(integer) 1
redis 127.0.0.1:6379> lpush tutoriallist mongodb
(integer) 2
redis 127.0.0.1:6379> lpush tutoriallist rabitmq
(integer) 3
redis 127.0.0.1:6379> lrange tutoriallist 0 10
1) "rabitmq"
2) "mongodb"
3) "redis"O comprimento máximo de uma lista é de 2 32 - 1 elementos (4294967295, mais de 4 bilhões de elementos por lista).
Jogos
Conjuntos Redis são uma coleção não ordenada de strings. No Redis, você pode adicionar, remover e testar a existência de membros na complexidade de tempo O (1).
Exemplo
redis 127.0.0.1:6379> sadd tutoriallist redis
(integer) 1
redis 127.0.0.1:6379> sadd tutoriallist mongodb
(integer) 1
redis 127.0.0.1:6379> sadd tutoriallist rabitmq
(integer) 1
redis 127.0.0.1:6379> sadd tutoriallist rabitmq
(integer) 0
redis 127.0.0.1:6379> smembers tutoriallist
1) "rabitmq"
2) "mongodb"
3) "redis"Note - No exemplo acima, rabitmq é adicionado duas vezes, no entanto, devido à propriedade exclusiva do conjunto, ele é adicionado apenas uma vez.
O número máximo de membros em um conjunto é 2 32 - 1 (4294967295, mais de 4 bilhões de membros por conjunto).
Conjuntos Ordenados
Os conjuntos classificados do Redis são semelhantes aos conjuntos do Redis, coleções não repetidas de strings. A diferença é que cada membro de um conjunto classificado está associado a uma pontuação, que é usada para obter o conjunto classificado ordenado, da menor para a maior pontuação. Embora os membros sejam únicos, as pontuações podem ser repetidas.
Exemplo
redis 127.0.0.1:6379> zadd tutoriallist 0 redis
(integer) 1
redis 127.0.0.1:6379> zadd tutoriallist 0 mongodb
(integer) 1
redis 127.0.0.1:6379> zadd tutoriallist 0 rabitmq
(integer) 1
redis 127.0.0.1:6379> zadd tutoriallist 0 rabitmq
(integer) 0
redis 127.0.0.1:6379> ZRANGEBYSCORE tutoriallist 0 1000
1) "redis"
2) "mongodb"
3) "rabitmq"Os comandos do Redis são usados para realizar algumas operações no servidor Redis.
Para executar comandos no servidor Redis, você precisa de um cliente Redis. O cliente Redis está disponível no pacote Redis, que instalamos anteriormente.
Sintaxe
A seguir está a sintaxe básica do cliente Redis.
$redis-cliExemplo
O exemplo a seguir explica como podemos iniciar o cliente Redis.
Para iniciar o cliente Redis, abra o terminal e digite o comando redis-cli. Isso se conectará ao seu servidor local e agora você pode executar qualquer comando.
$redis-cli
redis 127.0.0.1:6379>
redis 127.0.0.1:6379> PING
PONGNo exemplo acima, nos conectamos ao servidor Redis em execução na máquina local e executamos um comando PING, que verifica se o servidor está em execução ou não.
Executar comandos no servidor remoto
Para executar comandos no servidor remoto Redis, você precisa se conectar ao servidor pelo mesmo cliente redis-cli
Sintaxe
$ redis-cli -h host -p port -a passwordExemplo
O exemplo a seguir mostra como se conectar ao servidor remoto Redis, em execução no host 127.0.0.1, porta 6379 e tem a senha mypass.
$redis-cli -h 127.0.0.1 -p 6379 -a "mypass"
redis 127.0.0.1:6379>
redis 127.0.0.1:6379> PING
PONGOs comandos de teclas do Redis são usados para gerenciar chaves no Redis. A seguir está a sintaxe para usar comandos de teclas redis.
Sintaxe
redis 127.0.0.1:6379> COMMAND KEY_NAMEExemplo
redis 127.0.0.1:6379> SET tutorialspoint redis
OK
redis 127.0.0.1:6379> DEL tutorialspoint
(integer) 1No exemplo acima, DEL é o comando, enquanto tutorialspointÉ a chave. Se a chave for excluída, a saída do comando será (inteiro) 1, caso contrário, será (inteiro) 0.
Comandos de teclas Redis
A tabela a seguir lista alguns comandos básicos relacionados às teclas.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | Tecla DEL Este comando exclui a chave, se houver. |
| 2 | Chave DUMP Este comando retorna uma versão serializada do valor armazenado na chave especificada. |
| 3 | Chave EXISTS Este comando verifica se a chave existe ou não. |
| 4 | EXPIRE os segundos principais Define a expiração da chave após o tempo especificado. |
| 5 | Carimbo de data e hora da chave EXPIREAT Define a expiração da chave após o tempo especificado. Aqui, a hora está no formato de carimbo de data / hora Unix. |
| 6 | Chave PEXPIRE milissegundos Defina a expiração da chave em milissegundos. |
| 7 | Carimbo de data e hora da chave PEXPIREAT em milissegundos Define a expiração da chave no carimbo de data / hora Unix especificado como milissegundos. |
| 8 | Padrão KEYS Encontra todas as chaves que correspondem ao padrão especificado. |
| 9 | MOVE key db Move uma chave para outro banco de dados. |
| 10 | Chave PERSIST Remove a expiração da chave. |
| 11 | Chave PTTL Obtém o tempo restante na expiração das chaves em milissegundos. |
| 12 | Chave TTL Obtém o tempo restante na expiração das chaves. |
| 13 | RANDOMKEY Retorna uma chave aleatória do Redis. |
| 14 | RENOMEAR chave newkey Altera o nome da chave. |
| 15 | RENAMENX key newkey Renomeia a chave, se uma nova chave não existir. |
| 16 | Chave TYPE Retorna o tipo de dados do valor armazenado na chave. |
Os comandos de strings do Redis são usados para gerenciar valores de strings no Redis. A seguir está a sintaxe para usar comandos de string do Redis.
Sintaxe
redis 127.0.0.1:6379> COMMAND KEY_NAMEExemplo
redis 127.0.0.1:6379> SET tutorialspoint redis
OK
redis 127.0.0.1:6379> GET tutorialspoint
"redis"No exemplo acima, SET e GET são os comandos, enquanto tutorialspoint É a chave.
Comandos Redis Strings
A tabela a seguir lista alguns comandos básicos para gerenciar strings no Redis.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | Definir valor-chave Este comando define o valor na chave especificada. |
| 2 | GET chave Obtém o valor de uma chave. |
| 3 | GETRANGE chave início fim Obtém uma substring da string armazenada em uma chave. |
| 4 | Valor-chave GETSET Define o valor da string de uma chave e retorna seu valor antigo. |
| 5 | GETBIT key offset Retorna o valor do bit no deslocamento no valor da string armazenado na chave. |
| 6 | MGET key1 [key2 ..] Obtém os valores de todas as chaves fornecidas |
| 7 | Valor de deslocamento da chave SETBIT Define ou limpa o bit no deslocamento no valor da string armazenado na chave |
| 8 | Valor de segundos chave SETEX Define o valor com a expiração de uma chave |
| 9 | Valor da chave SETNX Define o valor de uma chave, apenas se a chave não existir |
| 10 | Valor de deslocamento da chave SETRANGE Sobrescreve a parte de uma string na chave, começando no deslocamento especificado |
| 11 | Tecla STRLEN Obtém o comprimento do valor armazenado em uma chave |
| 12 | Valor-chave MSET [valor-chave ...] Define várias chaves para vários valores |
| 13 | Valor-chave MSETNX [valor-chave ...] Define várias chaves para vários valores, apenas se nenhuma das chaves existir |
| 14 | Valor em milissegundos da chave PSETEX Define o valor e a expiração em milissegundos de uma chave |
| 15 | Chave INCR Incrementa o valor inteiro de uma chave em um |
| 16 | Incremento da chave INCRBY Incrementa o valor inteiro de uma chave em um determinado valor |
| 17 | Incremento da chave INCRBYFLOAT Incrementa o valor flutuante de uma chave em um determinado valor |
| 18 | Chave DECR Diminui o valor inteiro de uma chave em um |
| 19 | Diminuição da tecla DECRBY Diminui o valor inteiro de uma chave pelo número fornecido |
| 20 | APPEND valor-chave Acrescenta um valor a uma chave |
Redis Hashes são mapas entre os campos de string e os valores de string. Portanto, eles são o tipo de dados perfeito para representar objetos.
No Redis, cada hash pode armazenar até mais de 4 bilhões de pares de valor de campo.
Exemplo
redis 127.0.0.1:6379> HMSET tutorialspoint name "redis tutorial"
description "redis basic commands for caching" likes 20 visitors 23000
OK
redis 127.0.0.1:6379> HGETALL tutorialspoint
1) "name"
2) "redis tutorial"
3) "description"
4) "redis basic commands for caching"
5) "likes"
6) "20"
7) "visitors"
8) "23000"No exemplo acima, definimos os detalhes dos tutoriais do Redis (nome, descrição, curtidas, visitantes) no hash chamado 'tutorialspoint'.
Comandos Hash do Redis
A tabela a seguir lista alguns comandos básicos relacionados ao hash.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | HDEL key field2 [field2] Exclui um ou mais campos hash. |
| 2 | Campo chave HEXISTS Determina se um campo hash existe ou não. |
| 3 | Campo-chave HGET Obtém o valor de um campo hash armazenado na chave especificada. |
| 4 | Tecla HGETALL Obtém todos os campos e valores armazenados em um hash na chave especificada |
| 5 | Incremento do campo chave HINCRBY Incrementa o valor inteiro de um campo hash pelo número fornecido |
| 6 | Incremento do campo da chave HINCRBYFLOAT Incrementa o valor flutuante de um campo hash em um determinado valor |
| 7 | Chave HKEYS Obtém todos os campos em um hash |
| 8 | Chave HLEN Obtém o número de campos em um hash |
| 9 | HMGET key field1 [field2] Obtém os valores de todos os campos de hash fornecidos |
| 10 | HMSET chave campo1 valor1 [campo2 valor2] Define vários campos de hash para vários valores |
| 11 | Valor do campo-chave HSET Define o valor da string de um campo hash |
| 12 | Valor do campo-chave HSETNX Define o valor de um campo hash, apenas se o campo não existir |
| 13 | Chave HVALS Obtém todos os valores em um hash |
| 14 | Cursor da tecla HSCAN [MATCH pattern] [COUNT count] Repete incrementalmente os campos hash e os valores associados |
Listas Redis são simplesmente listas de strings, classificadas por ordem de inserção. Você pode adicionar elementos nas listas do Redis no início ou no final da lista.
O comprimento máximo de uma lista é de 2 32 - 1 elementos (4294967295, mais de 4 bilhões de elementos por lista).
Exemplo
redis 127.0.0.1:6379> LPUSH tutorials redis
(integer) 1
redis 127.0.0.1:6379> LPUSH tutorials mongodb
(integer) 2
redis 127.0.0.1:6379> LPUSH tutorials mysql
(integer) 3
redis 127.0.0.1:6379> LRANGE tutorials 0 10
1) "mysql"
2) "mongodb"
3) "redis"No exemplo acima, três valores são inseridos na lista Redis denominados 'tutoriais' pelo comando LPUSH.
Redis lista comandos
A tabela a seguir lista alguns comandos básicos relacionados a listas.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | Tempo limite da tecla BLPOP 1 [tecla 2] Remove e obtém o primeiro elemento de uma lista ou bloqueia até que um esteja disponível |
| 2 | Tempo limite da tecla BRPOP 1 [tecla 2] Remove e obtém o último elemento de uma lista ou bloqueia até que um esteja disponível |
| 3 | Tempo limite de destino de origem BRPOPLPUSH Retorna um valor de uma lista, empurra-o para outra lista e o retorna; ou blocos até que um esteja disponível |
| 4 | Índice de chave LINDEX Obtém um elemento de uma lista por seu índice |
| 5 | Chave LINSERT ANTES | DEPOIS do valor de pivô Insere um elemento antes ou depois de outro elemento em uma lista |
| 6 | Chave LLEN Obtém o comprimento de uma lista |
| 7 | Chave LPOP Remove e obtém o primeiro elemento de uma lista |
| 8 | LPUSH key value1 [value2] Adiciona um ou vários valores a uma lista |
| 9 | Valor-chave LPUSHX Anexa um valor a uma lista, apenas se a lista existir |
| 10 | LRANGE chave start stop Obtém uma série de elementos de uma lista |
| 11 | Valor de contagem de chave LREM Remove elementos de uma lista |
| 12 | Valor de índice da chave LSET Define o valor de um elemento em uma lista por seu índice |
| 13 | LTRIM chave start stop Corta uma lista para o intervalo especificado |
| 14 | Chave RPOP Remove e obtém o último elemento de uma lista |
| 15 | Destino de origem RPOPLPUSH Remove o último elemento de uma lista, acrescenta-o a outra lista e o retorna |
| 16 | Valor1 da chave RPUSH [valor2] Acrescenta um ou vários valores a uma lista |
| 17 | Valor da chave RPUSHX Acrescenta um valor a uma lista, apenas se a lista existir |
Conjuntos Redis são uma coleção não ordenada de strings exclusivas. Conjuntos de meios únicos não permitem a repetição de dados em uma chave.
No conjunto Redis, adicione, remova e teste a existência de membros em O (1) (tempo constante independentemente do número de elementos contidos no conjunto). O comprimento máximo de uma lista é de 2 32 - 1 elementos (4294967295, mais de 4 bilhões de elementos por conjunto).
Exemplo
redis 127.0.0.1:6379> SADD tutorials redis
(integer) 1
redis 127.0.0.1:6379> SADD tutorials mongodb
(integer) 1
redis 127.0.0.1:6379> SADD tutorials mysql
(integer) 1
redis 127.0.0.1:6379> SADD tutorials mysql
(integer) 0
redis 127.0.0.1:6379> SMEMBERS tutorials
1) "mysql"
2) "mongodb"
3) "redis"No exemplo acima, três valores são inseridos no conjunto Redis denominado 'tutoriais' pelo comando SADD.
Redis define comandos
A tabela a seguir lista alguns comandos básicos relacionados a conjuntos.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | SADD key member1 [member2] Adiciona um ou mais membros a um conjunto |
| 2 | Chave SCARD Obtém o número de membros em um conjunto |
| 3 | SDIFF key1 [key2] Subtrai vários conjuntos |
| 4 | SDIFFSTORE chave 1 de destino [chave 2] Subtrai vários conjuntos e armazena o conjunto resultante em uma chave |
| 5 | SINTER chave1 [chave2] Cruza vários conjuntos |
| 6 | SINTERSTORE chave1 de destino [chave2] Cruza vários conjuntos e armazena o conjunto resultante em uma chave |
| 7 | Membro chave SISMEMBER Determina se um determinado valor é membro de um conjunto |
| 8 | Chave SMEMBERS Obtém todos os membros em um conjunto |
| 9 | Membro de destino de origem SMOVE Move um membro de um conjunto para outro |
| 10 | Chave SPOP Remove e retorna um membro aleatório de um conjunto |
| 11 | SRANDMEMBER chave [contagem] Obtém um ou vários membros aleatórios de um conjunto |
| 12 | SREM key member1 [member2] Remove um ou mais membros de um conjunto |
| 13 | SUNION key1 [key2] Adiciona vários conjuntos |
| 14 | SUNIONSTORE destino key1 [key2] Adiciona vários conjuntos e armazena o conjunto resultante em uma chave |
| 15 | Cursor da tecla SSCAN [padrão de correspondência] [contagem de COUNT] Repete incrementalmente os elementos do conjunto |
Os conjuntos classificados do Redis são semelhantes aos conjuntos do Redis com o recurso exclusivo de valores armazenados em um conjunto. A diferença é que cada membro de um conjunto classificado está associado a uma pontuação, que é usada para obter o conjunto classificado ordenado, da menor para a maior pontuação.
No conjunto classificado do Redis, adicione, remova e teste a existência de membros em O (1) (tempo constante, independentemente do número de elementos contidos no conjunto). O comprimento máximo de uma lista é de 2 32 - 1 elementos (4294967295, mais de 4 bilhões de elementos por conjunto).
Exemplo
redis 127.0.0.1:6379> ZADD tutorials 1 redis
(integer) 1
redis 127.0.0.1:6379> ZADD tutorials 2 mongodb
(integer) 1
redis 127.0.0.1:6379> ZADD tutorials 3 mysql
(integer) 1
redis 127.0.0.1:6379> ZADD tutorials 3 mysql
(integer) 0
redis 127.0.0.1:6379> ZADD tutorials 4 mysql
(integer) 0
redis 127.0.0.1:6379> ZRANGE tutorials 0 10 WITHSCORES
1) "redis"
2) "1"
3) "mongodb"
4) "2"
5) "mysql"
6) "4"No exemplo acima, três valores são inseridos com sua pontuação no conjunto classificado do Redis denominado 'tutoriais' pelo comando ZADD.
Comandos de conjuntos classificados do Redis
A tabela a seguir lista alguns comandos básicos relacionados a conjuntos classificados.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | Chave ZADD score1 member1 [score2 member2] Adiciona um ou mais membros a um conjunto classificado ou atualiza sua pontuação, se já existir |
| 2 | Chave ZCARD Obtém o número de membros em um conjunto classificado |
| 3 | ZCOUNT chave mín. Máx. Conta os membros em um conjunto classificado com pontuações dentro dos valores dados |
| 4 | Membro de incremento de chave ZINCRBY Aumenta a pontuação de um membro em um conjunto classificado |
| 5 | ZINTERSTORE destino numkeys tecla [tecla ...] Faz a interseção de vários conjuntos classificados e armazena o conjunto classificado resultante em uma nova chave |
| 6 | ZLEXCOUNT chave mín. Máx. Conta o número de membros em um conjunto classificado entre um determinado intervalo lexicográfico |
| 7 | ZRANGE key start stop [WITHSCORES] Retorna um intervalo de membros em um conjunto classificado, por índice |
| 8 | ZRANGEBYLEX chave min max [LIMIT offset count] Retorna um intervalo de membros em um conjunto classificado, por intervalo lexicográfico |
| 9 | ZRANGEBYSCORE chave min máx [WITHSCORES] [LIMIT] Retorna um intervalo de membros em um conjunto classificado, por pontuação |
| 10 | Membro chave do ZRANK Determina o índice de um membro em um conjunto classificado |
| 11 | Membro-chave da ZREM [membro ...] Remove um ou mais membros de um conjunto classificado |
| 12 | ZREMRANGEBYLEX chave mín. Máx. Remove todos os membros em um conjunto classificado entre o intervalo lexicográfico fornecido |
| 13 | ZREMRANGEBYRANK iniciar parada chave Remove todos os membros em um conjunto classificado dentro dos índices fornecidos |
| 14 | ZREMRANGEBYSCORE chave mín. Máx. Remove todos os membros em um conjunto classificado dentro das pontuações fornecidas |
| 15 | ZREVRANGE chave start stop [WITHSCORES] Retorna um intervalo de membros em um conjunto classificado, por índice, com pontuações ordenadas de alto a baixo |
| 16 | ZREVRANGEBYSCORE máximo mínimo da chave [WITHSCORES] Retorna um intervalo de membros em um conjunto classificado, por pontuação, com pontuações ordenadas de alto a baixo |
| 17 | Membro-chave ZREVRANK Determina o índice de um membro em um conjunto classificado, com pontuações ordenadas de alto a baixo |
| 18 | Membro-chave ZSCORE Obtém a pontuação associada a um determinado membro em um conjunto classificado |
| 19 | ZUNIONSTORE destino numkeys tecla [tecla ...] Adiciona vários conjuntos classificados e armazena o conjunto classificado resultante em uma nova chave |
| 20 | Cursor da tecla ZSCAN [MATCH pattern] [COUNT count] Incrementarmente itera elementos de conjuntos classificados e pontuações associadas |
Redis HyperLogLog é um algoritmo que usa randomização para fornecer uma aproximação do número de elementos únicos em um conjunto usando apenas uma constante e uma pequena quantidade de memória.
O HyperLogLog fornece uma boa aproximação da cardinalidade de um conjunto, mesmo usando uma quantidade muito pequena de memória em torno de 12 kbytes por chave com um erro padrão de 0,81%. Não há limite para o número de itens que você pode contar, a menos que você se aproxime de 2 64 itens.
Exemplo
O exemplo a seguir explica como o Redis HyperLogLog funciona.
redis 127.0.0.1:6379> PFADD tutorials "redis"
1) (integer) 1
redis 127.0.0.1:6379> PFADD tutorials "mongodb"
1) (integer) 1
redis 127.0.0.1:6379> PFADD tutorials "mysql"
1) (integer) 1
redis 127.0.0.1:6379> PFCOUNT tutorials
(integer) 3Comandos do Redis HyperLogLog
A tabela a seguir lista alguns comandos básicos relacionados ao Redis HyperLogLog.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | Elemento-chave PFADD [elemento ...] Adiciona os elementos especificados ao HyperLogLog especificado. |
| 2 | PFCOUNT chave [chave ...] Retorna a cardinalidade aproximada do (s) conjunto (s) observado (s) pelo HyperLogLog na (s) chave (s). |
| 3 | PFMERGE destkey sourcekey [sourcekey ...] Mescla N HyperLogLogs diferentes em um único. |
O Redis Pub / Sub implementa o sistema de mensagens em que os remetentes (na terminologia do Redis, chamados de editores) enviam as mensagens, enquanto os destinatários (assinantes) as recebem. O link pelo qual as mensagens são transferidas é chamadochannel.
No Redis, um cliente pode se inscrever em qualquer número de canais.
Exemplo
O exemplo a seguir explica como funciona o conceito de assinante de publicação. No exemplo a seguir, um cliente se inscreveu em um canal chamado 'redisChat'.
redis 127.0.0.1:6379> SUBSCRIBE redisChat
Reading messages... (press Ctrl-C to quit)
1) "subscribe"
2) "redisChat"
3) (integer) 1Agora, dois clientes estão publicando as mensagens no mesmo canal chamado 'redisChat' e o cliente inscrito acima está recebendo mensagens.
redis 127.0.0.1:6379> PUBLISH redisChat "Redis is a great caching technique"
(integer) 1
redis 127.0.0.1:6379> PUBLISH redisChat "Learn redis by tutorials point"
(integer) 1
1) "message"
2) "redisChat"
3) "Redis is a great caching technique"
1) "message"
2) "redisChat"
3) "Learn redis by tutorials point"Comandos Redis PubSub
A tabela a seguir lista alguns comandos básicos relacionados ao Redis Pub / Sub.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | Padrão PSUBSCRIBE [padrão ...] Inscreve-se em canais que correspondem aos padrões fornecidos. |
| 2 | Subcomando PUBSUB [argumento [argumento ...]] Informa o estado do sistema Pub / Sub. Por exemplo, quais clientes estão ativos no servidor. |
| 3 | PUBLICAR mensagem do canal Publica uma mensagem em um canal. |
| 4 | PUNSUBSCRIBE [padrão [padrão ...]] Pára de ouvir mensagens postadas em canais que correspondem aos padrões fornecidos. |
| 5 | ASSINAR canal [canal ...] Escuta as mensagens publicadas nos canais fornecidos. |
| 6 | CANCELAR ASSINATURA [canal [canal ...]] Pára de ouvir as mensagens postadas nos canais fornecidos. |
As transações do Redis permitem a execução de um grupo de comandos em uma única etapa. A seguir estão as duas propriedades de transações.
Todos os comandos em uma transação são executados sequencialmente como uma única operação isolada. Não é possível que uma solicitação emitida por outro cliente seja atendida no meio da execução de uma transação do Redis.
A transação do Redis também é atômica. Atômico significa que todos os comandos ou nenhum foi processado.
Amostra
A transação do Redis é iniciada por comando MULTI e então você precisa passar uma lista de comandos que devem ser executados na transação, após a qual toda a transação é executada por EXEC comando.
redis 127.0.0.1:6379> MULTI
OK
List of commands here
redis 127.0.0.1:6379> EXECExemplo
O exemplo a seguir explica como a transação do Redis pode ser iniciada e executada.
redis 127.0.0.1:6379> MULTI
OK
redis 127.0.0.1:6379> SET tutorial redis
QUEUED
redis 127.0.0.1:6379> GET tutorial
QUEUED
redis 127.0.0.1:6379> INCR visitors
QUEUED
redis 127.0.0.1:6379> EXEC
1) OK
2) "redis"
3) (integer) 1Comandos de transação Redis
A tabela a seguir mostra alguns comandos básicos relacionados às transações do Redis.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | DESCARTAR Descarta todos os comandos emitidos após MULTI |
| 2 | EXEC Executa todos os comandos emitidos após MULTI |
| 3 | MULTI Marca o início de um bloco de transação |
| 4 | UNWATCH Esquece todas as chaves vigiadas |
| 5 | WATCH key [key ...] Observa as chaves fornecidas para determinar a execução do bloco MULTI / EXEC |
O script Redis é usado para avaliar scripts usando o interpretador Lua. Ele é integrado ao Redis a partir da versão 2.6.0. O comando usado para o script éEVAL comando.
Sintaxe
A seguir está a sintaxe básica de EVAL comando.
redis 127.0.0.1:6379> EVAL script numkeys key [key ...] arg [arg ...]Exemplo
O exemplo a seguir explica como funciona o script do Redis.
redis 127.0.0.1:6379> EVAL "return {KEYS[1],KEYS[2],ARGV[1],ARGV[2]}" 2 key1
key2 first second
1) "key1"
2) "key2"
3) "first"
4) "second"Comandos de script do Redis
A tabela a seguir lista alguns comandos básicos relacionados ao Redis Scripting.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | EVAL script numkeys key [key ...] arg [arg ...] Executa um script Lua. |
| 2 | EVALSHA sha1 numkeys key [key ...] arg [arg ...] Executa um script Lua. |
| 3 | Script SCRIPT EXISTS [script ...] Verifica a existência de scripts no cache de scripts. |
| 4 | SCRIPT FLUSH Remove todos os scripts do cache de script. |
| 5 | SCRIPT KILL Mata o script atualmente em execução. |
| 6 | Script SCRIPT LOAD Carrega o script Lua especificado no cache de script. |
Os comandos de conexão do Redis são usados basicamente para gerenciar conexões de clientes com o servidor Redis.
Exemplo
O exemplo a seguir explica como um cliente se autentica no servidor Redis e verifica se o servidor está funcionando ou não.
redis 127.0.0.1:6379> AUTH "password"
OK
redis 127.0.0.1:6379> PING
PONGComandos de conexão do Redis
A tabela a seguir lista alguns comandos básicos relacionados às conexões do Redis.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | Senha AUTH Autentica no servidor com a senha fornecida |
| 2 | Mensagem ECHO Imprime a string dada |
| 3 | PING Verifica se o servidor está funcionando ou não |
| 4 | SAIR Fecha a conexão atual |
| 5 | Índice SELECT Muda o banco de dados selecionado para a conexão atual |
Os comandos do servidor Redis são basicamente usados para gerenciar o servidor Redis.
Exemplo
O exemplo a seguir explica como podemos obter todas as estatísticas e informações sobre o servidor.
redis 127.0.0.1:6379> INFO
# Server
redis_version:2.8.13
redis_git_sha1:00000000
redis_git_dirty:0
redis_build_id:c2238b38b1edb0e2
redis_mode:standalone
os:Linux 3.5.0-48-generic x86_64
arch_bits:64
multiplexing_api:epoll
gcc_version:4.7.2
process_id:3856
run_id:0e61abd297771de3fe812a3c21027732ac9f41fe
tcp_port:6379
uptime_in_seconds:11554
uptime_in_days:0 hz:10
lru_clock:16651447
config_file:
# Clients
connected_clients:1
client_longest_output_list:0
client_biggest_input_buf:0
blocked_clients:0
# Memory
used_memory:589016
used_memory_human:575.21K
used_memory_rss:2461696
used_memory_peak:667312
used_memory_peak_human:651.67K
used_memory_lua:33792
mem_fragmentation_ratio:4.18
mem_allocator:jemalloc-3.6.0
# Persistence
loading:0
rdb_changes_since_last_save:3
rdb_bgsave_in_progress:0
rdb_last_save_time:1409158561
rdb_last_bgsave_status:ok
rdb_last_bgsave_time_sec:0
rdb_current_bgsave_time_sec:-1
aof_enabled:0
aof_rewrite_in_progress:0
aof_rewrite_scheduled:0
aof_last_rewrite_time_sec:-1
aof_current_rewrite_time_sec:-1
aof_last_bgrewrite_status:ok
aof_last_write_status:ok
# Stats
total_connections_received:24
total_commands_processed:294
instantaneous_ops_per_sec:0
rejected_connections:0
sync_full:0
sync_partial_ok:0
sync_partial_err:0
expired_keys:0
evicted_keys:0
keyspace_hits:41
keyspace_misses:82
pubsub_channels:0
pubsub_patterns:0
latest_fork_usec:264
# Replication
role:master
connected_slaves:0
master_repl_offset:0
repl_backlog_active:0
repl_backlog_size:1048576
repl_backlog_first_byte_offset:0
repl_backlog_histlen:0
# CPU
used_cpu_sys:10.49
used_cpu_user:4.96
used_cpu_sys_children:0.00
used_cpu_user_children:0.01
# Keyspace
db0:keys = 94,expires = 1,avg_ttl = 41638810
db1:keys = 1,expires = 0,avg_ttl = 0
db3:keys = 1,expires = 0,avg_ttl = 0Comandos do servidor Redis
A tabela a seguir lista alguns comandos básicos relacionados ao servidor Redis.
| Sr. Não | Comando e Descrição |
|---|---|
| 1 | BGREWRITEAOF Reescreve de maneira assíncrona o arquivo somente para anexos |
| 2 | BGSAVE Salva de maneira assíncrona o conjunto de dados no disco |
| 3 | CLIENT KILL [ip: port] [ID client-id] Mata a conexão de um cliente |
| 4 | LISTA DE CLIENTES Obtém a lista de conexões do cliente com o servidor |
| 5 | CLIENTE GETNAME Obtém o nome da conexão atual |
| 6 | Tempo limite de PAUSA DO CLIENTE Para o processamento de comandos dos clientes por um tempo especificado |
| 7 | CLIENTE SETNAME nome-da-conexão Define o nome da conexão atual |
| 8 | SLOTS DE CLUSTER Obtém uma matriz de slots de cluster para mapeamentos de nós |
| 9 | COMANDO Obtém uma série de detalhes do comando Redis |
| 10 | COMANDO COUNT Obtém o número total de comandos Redis |
| 11 | COMANDO GETKEYS Extrai as chaves fornecidas com um comando Redis completo |
| 12 | BGSAVE Salva de maneira assíncrona o conjunto de dados no disco |
| 13 | COMMAND INFO command-name [command-name ...] Obtém uma matriz de detalhes específicos do comando Redis |
| 14 | Parâmetro CONFIG GET Obtém o valor de um parâmetro de configuração |
| 15 | CONFIG REWRITE Reescreve o arquivo de configuração com a configuração na memória |
| 16 | Valor do parâmetro CONFIG SET Define um parâmetro de configuração para o valor dado |
| 17 | CONFIG RESETSTAT Reinicia as estatísticas retornadas por INFO |
| 18 | DBSIZE Retorna o número de chaves no banco de dados selecionado |
| 19 | Chave DEBUG OBJECT Obtém informações de depuração sobre uma chave |
| 20 | DEBUG SEGFAULT Faz o servidor travar |
| 21 | FLUSHALL Remove todas as chaves de todos os bancos de dados |
| 22 | FLUSHDB Remove todas as chaves do banco de dados atual |
| 23 | INFO [seção] Obtém informações e estatísticas sobre o servidor |
| 24 | LASTSAVE Obtém a data e hora do UNIX da última gravação bem-sucedida no disco |
| 25 | MONITOR Escuta todas as solicitações recebidas pelo servidor em tempo real |
| 26 | FUNÇÃO Retorna a função da instância no contexto de replicação |
| 27 | SALVE Salva de maneira síncrona o conjunto de dados no disco |
| 28 | SHUTDOWN [NOSAVE] [SAVE] Salva de forma síncrona o conjunto de dados no disco e, em seguida, desliga o servidor |
| 29 | Porta de host SLAVEOF Torna o servidor um escravo de outra instância ou o promove como mestre |
| 30 | Subcomando SLOWLOG [argumento] Gerencia o registro de consultas lentas do Redis |
| 31 | SINCRONIZAR Comando usado para replicação |
| 32 | TEMPO Retorna a hora atual do servidor |
Redis SAVE comando é usado para criar um backup do banco de dados Redis atual.
Sintaxe
A seguir está a sintaxe básica do redis SAVE comando.
127.0.0.1:6379> SAVEExemplo
O exemplo a seguir cria um backup do banco de dados atual.
127.0.0.1:6379> SAVE
OKEste comando irá criar um dump.rdb arquivo em seu diretório Redis.
Restaurar dados Redis
Para restaurar os dados do Redis, mova o arquivo de backup do Redis (dump.rdb) para o diretório do Redis e inicie o servidor. Para obter seu diretório Redis, useCONFIG comando do Redis conforme mostrado abaixo.
127.0.0.1:6379> CONFIG get dir
1) "dir"
2) "/user/tutorialspoint/redis-2.8.13/src"Na saída do comando acima /user/tutorialspoint/redis-2.8.13/src é o diretório onde o servidor Redis está instalado.
Bgsave
Para criar o backup do Redis, um comando alternativo BGSAVEtambém está disponível. Este comando iniciará o processo de backup e o executará em segundo plano.
Exemplo
127.0.0.1:6379> BGSAVE
Background saving startedO banco de dados Redis pode ser protegido, de forma que qualquer cliente que fizer uma conexão precise se autenticar antes de executar um comando. Para proteger o Redis, você precisa definir a senha no arquivo de configuração.
Exemplo
O exemplo a seguir mostra as etapas para proteger sua instância do Redis.
127.0.0.1:6379> CONFIG get requirepass
1) "requirepass"
2) ""Por padrão, esta propriedade está em branco, o que significa que nenhuma senha está definida para esta instância. Você pode alterar esta propriedade executando o seguinte comando.
127.0.0.1:6379> CONFIG set requirepass "tutorialspoint"
OK
127.0.0.1:6379> CONFIG get requirepass
1) "requirepass"
2) "tutorialspoint"Depois de definir a senha, se algum cliente executar o comando sem autenticação, então (error) NOAUTH Authentication required. o erro retornará. Portanto, o cliente precisa usarAUTH comando para se autenticar.
Sintaxe
A seguir está a sintaxe básica de AUTH comando.
127.0.0.1:6379> AUTH passwordExemplo
127.0.0.1:6379> AUTH "tutorialspoint"
OK
127.0.0.1:6379> SET mykey "Test value"
OK
127.0.0.1:6379> GET mykey
"Test value"O benchmark do Redis é o utilitário para verificar o desempenho do Redis executando n comandos simultaneamente.
Sintaxe
A seguir está a sintaxe básica do benchmark Redis.
redis-benchmark [option] [option value]Exemplo
O exemplo a seguir verifica o Redis chamando 100.000 comandos.
redis-benchmark -n 100000
PING_INLINE: 141043.72 requests per second
PING_BULK: 142857.14 requests per second
SET: 141442.72 requests per second
GET: 145348.83 requests per second
INCR: 137362.64 requests per second
LPUSH: 145348.83 requests per second
LPOP: 146198.83 requests per second
SADD: 146198.83 requests per second
SPOP: 149253.73 requests per second
LPUSH (needed to benchmark LRANGE): 148588.42 requests per second
LRANGE_100 (first 100 elements): 58411.21 requests per second
LRANGE_300 (first 300 elements): 21195.42 requests per second
LRANGE_500 (first 450 elements): 14539.11 requests per second
LRANGE_600 (first 600 elements): 10504.20 requests per second
MSET (10 keys): 93283.58 requests per secondA seguir está uma lista de opções disponíveis no benchmark Redis.
| Sr. Não | Opção | Descrição | Valor padrão |
|---|---|---|---|
| 1 | -h | Especifica o nome do host do servidor | 127.0.0.1 |
| 2 | -p | Especifica a porta do servidor | 6379 |
| 3 | -s | Especifica o soquete do servidor | |
| 4 | -c | Especifica o número de conexões paralelas | 50 |
| 5 | -n | Especifica o número total de solicitações | 10.000 |
| 6 | -d | Especifica o tamanho dos dados do valor SET / GET em bytes | 2 |
| 7 | -k | 1 = manter vivo, 0 = reconectar | 1 |
| 8 | -r | Use chaves aleatórias para SET / GET / INCR, valores aleatórios para SADD | |
| 9 | -p | Solicitações de <numreq> do pipeline | 1 |
| 10 | -h | Especifica o nome do host do servidor | |
| 11 | -q | Força o silêncio para Redis. Mostra apenas os valores de consulta / s | |
| 12 | --csv | Saída em formato CSV | |
| 13 | -l | Gera loop, executa os testes para sempre | |
| 14 | -t | Só executa a lista de testes separados por vírgulas | |
| 15 | -I | Modo inativo. Basta abrir N conexões ociosas e esperar |
Exemplo
O exemplo a seguir mostra as várias opções de uso no utilitário de benchmark Redis.
redis-benchmark -h 127.0.0.1 -p 6379 -t set,lpush -n 100000 -q
SET: 146198.83 requests per second
LPUSH: 145560.41 requests per secondO Redis aceita conexões de clientes na porta TCP de escuta configurada e no soquete Unix, se habilitado. Quando uma nova conexão de cliente é aceita, as seguintes operações são realizadas -
O soquete do cliente é colocado em um estado sem bloqueio, pois o Redis usa multiplexação e E / S sem bloqueio.
A opção TCP_NODELAY é definida para garantir que não haja atrasos em nossa conexão.
Um evento de arquivo legível é criado para que o Redis possa coletar as consultas do cliente assim que novos dados estiverem disponíveis para serem lidos no soquete.
Número Máximo de Clientes
Na configuração do Redis (redis.conf), existe uma propriedade chamada maxclients, que descreve o número máximo de clientes que podem se conectar ao Redis.
A seguir está a sintaxe básica do comando.
config get maxclients
1) "maxclients"
2) "10000"Por padrão, esta propriedade é definida como 10000 (dependendo do número máximo de limite de descritores de arquivo do SO), embora você possa alterar esta propriedade.
Exemplo
No exemplo a seguir, definimos o número máximo de clientes para 100.000, ao iniciar o servidor.
redis-server --maxclients 100000Comandos do cliente
| Sr. Não | Comando | Descrição |
|---|---|---|
| 1 | CLIENT LIST | Retorna a lista de clientes conectados ao servidor Redis |
| 2 | CLIENT SETNAME | Atribui um nome à conexão atual |
| 3 | CLIENT GETNAME | Retorna o nome da conexão atual conforme definido por CLIENT SETNAME |
| 4 | CLIENT PAUSE | Este é um comando de controle de conexões capaz de suspender todos os clientes Redis pelo período de tempo especificado (em milissegundos) |
| 5 | CLIENT KILL | Este comando fecha uma determinada conexão do cliente. |
Redis é um servidor TCP e oferece suporte ao protocolo de solicitação / resposta. No Redis, uma solicitação é realizada com as seguintes etapas -
O cliente envia uma consulta ao servidor e lê a partir do soquete, geralmente de forma bloqueadora, a resposta do servidor.
O servidor processa o comando e envia a resposta de volta ao cliente.
Significado de Pipelining
O significado básico de pipelining é que o cliente pode enviar várias solicitações ao servidor sem esperar pelas respostas e, finalmente, lê as respostas em uma única etapa.
Exemplo
Para verificar o pipelining do Redis, basta iniciar a instância do Redis e digitar o seguinte comando no terminal.
$(echo -en "PING\r\n SET tutorial redis\r\nGET tutorial\r\nINCR
visitor\r\nINCR visitor\r\nINCR visitor\r\n"; sleep 10) | nc localhost 6379
+PONG
+OK
redis
:1
:2
:3No exemplo acima, vamos verificar a conexão do Redis usando PINGcomando. Nós definimos uma string chamadatutorial com valor redis. Mais tarde, obtemos o valor das chaves e incrementamos o número do visitante três vezes. No resultado, podemos ver que todos os comandos são enviados ao Redis uma vez e o Redis fornece a saída de todos os comandos em uma única etapa.
Benefícios do Pipelining
O benefício dessa técnica é um desempenho de protocolo drasticamente aprimorado. A aceleração obtida pelo pipelining varia de um fator de cinco para conexões ao host local até um fator de pelo menos cem em conexões de Internet mais lentas.
O particionamento é o processo de dividir seus dados em várias instâncias do Redis, de modo que cada instância contenha apenas um subconjunto de suas chaves.
Benefícios do particionamento
Ele permite bancos de dados muito maiores, usando a soma da memória de muitos computadores. Sem o particionamento, você fica limitado à quantidade de memória que um único computador pode suportar.
Ele permite dimensionar o poder computacional para vários núcleos e vários computadores, e a largura de banda da rede para vários computadores e adaptadores de rede.
Desvantagens do particionamento
Normalmente, não há suporte para operações envolvendo várias chaves. Por exemplo, você não pode realizar a interseção entre dois conjuntos se eles estiverem armazenados nas chaves mapeadas para diferentes instâncias do Redis.
As transações do Redis envolvendo várias chaves não podem ser usadas.
O detalhamento do particionamento é a chave, portanto, não é possível fragmentar um conjunto de dados com uma única chave enorme, como um conjunto classificado muito grande.
Quando o particionamento é usado, o tratamento de dados é mais complexo. Por exemplo, você precisa lidar com vários arquivos RDB / AOF e, para obter um backup de seus dados, precisa agregar os arquivos de persistência de várias instâncias e hosts.
Adicionar e remover a capacidade pode ser complexo. Por exemplo, o Redis Cluster oferece suporte a rebalanceamento de dados principalmente transparente com a capacidade de adicionar e remover nós em tempo de execução. No entanto, outros sistemas, como o particionamento do lado do cliente e proxies, não oferecem suporte a esse recurso. Uma técnica chamadaPresharding ajuda nesse sentido.
Tipos de particionamento
Existem dois tipos de particionamento disponíveis no Redis. Suponha que temos quatro instâncias do Redis, R0, R1, R2, R3 e muitas chaves que representam usuários, como usuário: 1, usuário: 2, ... e assim por diante.
Particionamento de intervalo
O particionamento de intervalo é realizado mapeando intervalos de objetos em instâncias específicas do Redis. Suponha que em nosso exemplo, os usuários de ID 0 a ID 10000 irão para a instância R0, enquanto os usuários de ID 10001 a ID 20000 irão para a instância R1 e assim por diante.
Particionamento Hash
Nesse tipo de particionamento, uma função hash (por exemplo, função de módulo) é usada para converter a chave em um número e, em seguida, os dados são armazenados em instâncias diferentes do Redis.
Antes de começar a usar o Redis em seus programas Java, você precisa se certificar de que possui o driver Redis Java e o Java configurado na máquina. Você pode verificar nosso tutorial Java para instalação do Java em sua máquina.
Instalação
Agora, vamos ver como configurar o driver Redis Java.
Você precisa baixar o jar do caminho Download jedis.jar. Certifique-se de baixar a versão mais recente dele.
Você precisa incluir o jedis.jar em seu classpath.
Conecte-se ao servidor Redis
import redis.clients.jedis.Jedis;
public class RedisJava {
public static void main(String[] args) {
//Connecting to Redis server on localhost
Jedis jedis = new Jedis("localhost");
System.out.println("Connection to server sucessfully");
//check whether server is running or not
System.out.println("Server is running: "+jedis.ping());
}
}Agora, vamos compilar e executar o programa acima para testar a conexão com o servidor Redis. Você pode alterar seu caminho de acordo com sua necessidade. Estamos assumindo a versão atual dojedis.jar está disponível no caminho atual.
$javac RedisJava.java
$java RedisJava
Connection to server sucessfully
Server is running: PONGExemplo de string Redis Java
import redis.clients.jedis.Jedis;
public class RedisStringJava {
public static void main(String[] args) {
//Connecting to Redis server on localhost
Jedis jedis = new Jedis("localhost");
System.out.println("Connection to server sucessfully");
//set the data in redis string
jedis.set("tutorial-name", "Redis tutorial");
// Get the stored data and print it
System.out.println("Stored string in redis:: "+ jedis.get("tutorialname"));
}
}Agora, vamos compilar e executar o programa acima.
$javac RedisStringJava.java
$java RedisStringJava
Connection to server sucessfully
Stored string in redis:: Redis tutorialExemplo de lista Redis Java
import redis.clients.jedis.Jedis;
public class RedisListJava {
public static void main(String[] args) {
//Connecting to Redis server on localhost
Jedis jedis = new Jedis("localhost");
System.out.println("Connection to server sucessfully");
//store data in redis list
jedis.lpush("tutorial-list", "Redis");
jedis.lpush("tutorial-list", "Mongodb");
jedis.lpush("tutorial-list", "Mysql");
// Get the stored data and print it
List<String> list = jedis.lrange("tutorial-list", 0 ,5);
for(int i = 0; i<list.size(); i++) {
System.out.println("Stored string in redis:: "+list.get(i));
}
}
}Agora, vamos compilar e executar o programa acima.
$javac RedisListJava.java
$java RedisListJava
Connection to server sucessfully
Stored string in redis:: Redis
Stored string in redis:: Mongodb
Stored string in redis:: MysqlExemplo de chaves Java Redis
import redis.clients.jedis.Jedis;
public class RedisKeyJava {
public static void main(String[] args) {
//Connecting to Redis server on localhost
Jedis jedis = new Jedis("localhost");
System.out.println("Connection to server sucessfully");
//store data in redis list
// Get the stored data and print it
List<String> list = jedis.keys("*");
for(int i = 0; i<list.size(); i++) {
System.out.println("List of stored keys:: "+list.get(i));
}
}
}Agora, vamos compilar e executar o programa acima.
$javac RedisKeyJava.java
$java RedisKeyJava
Connection to server sucessfully
List of stored keys:: tutorial-name
List of stored keys:: tutorial-listAntes de começar a usar o Redis em seus programas PHP, você precisa se certificar de que possui o driver Redis PHP e o PHP configurados na máquina. Você pode verificar o tutorial de PHP para instalação do PHP em sua máquina.
Instalação
Agora, vamos verificar como configurar o driver Redis PHP.
Você precisa baixar o phpredis do repositório github https://github.com/nicolasff/phpredis. Depois de baixá-lo, extraia os arquivos para o diretório phpredis. No Ubuntu, instale a seguinte extensão.
cd phpredis
sudo phpize
sudo ./configure
sudo make
sudo make installAgora, copie e cole o conteúdo da pasta “modules” para o diretório de extensão PHP e adicione as seguintes linhas em php.ini.
extension = redis.soAgora, sua instalação do Redis PHP está completa
Conecte-se ao servidor Redis
<?php
//Connecting to Redis server on localhost
$redis = new Redis();
$redis->connect('127.0.0.1', 6379); echo "Connection to server sucessfully"; //check whether server is running or not echo "Server is running: ".$redis->ping();
?>Quando o programa for executado, ele produzirá o seguinte resultado.
Connection to server sucessfully
Server is running: PONGExemplo de string Redis PHP
<?php
//Connecting to Redis server on localhost
$redis = new Redis(); $redis->connect('127.0.0.1', 6379);
echo "Connection to server sucessfully";
//set the data in redis string
$redis->set("tutorial-name", "Redis tutorial"); // Get the stored data and print it echo "Stored string in redis:: " .$redis→get("tutorial-name");
?>Quando o programa acima for executado, ele produzirá o seguinte resultado.
Connection to server sucessfully
Stored string in redis:: Redis tutorialExemplo de lista de php do Redis
<?php
//Connecting to Redis server on localhost
$redis = new Redis(); $redis->connect('127.0.0.1', 6379);
echo "Connection to server sucessfully";
//store data in redis list
$redis->lpush("tutorial-list", "Redis"); $redis->lpush("tutorial-list", "Mongodb");
$redis->lpush("tutorial-list", "Mysql"); // Get the stored data and print it $arList = $redis->lrange("tutorial-list", 0 ,5); echo "Stored string in redis:: "; print_r($arList);
?>Quando o programa acima for executado, ele produzirá o seguinte resultado.
Connection to server sucessfully
Stored string in redis::
Redis
Mongodb
MysqlExemplo de chaves Redis PHP
<?php
//Connecting to Redis server on localhost
$redis = new Redis(); $redis->connect('127.0.0.1', 6379);
echo "Connection to server sucessfully";
// Get the stored keys and print it
$arList = $redis->keys("*");
echo "Stored keys in redis:: "
print_r($arList);
?>Quando o programa for executado, ele produzirá o seguinte resultado.
Connection to server sucessfully
Stored string in redis::
tutorial-name
tutorial-list