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-server

Isso instalará o Redis em sua máquina.

Iniciar Redis

$redis-server

Verifique se o Redis está funcionando

$redis-cli

Isso 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 
PONG

Isso 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_NAME

Exemplo

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_VALUE

Exemplo

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-cli

Exemplo

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  
PONG

No 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 password

Exemplo

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  
PONG

Os 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_NAME

Exemplo

redis 127.0.0.1:6379> SET tutorialspoint redis 
OK 
redis 127.0.0.1:6379> DEL tutorialspoint 
(integer) 1

No 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_NAME

Exemplo

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) 3

Comandos 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) 1

Agora, 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> EXEC

Exemplo

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) 1

Comandos 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 
PONG

Comandos 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 = 0

Comandos 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> SAVE

Exemplo

O exemplo a seguir cria um backup do banco de dados atual.

127.0.0.1:6379> SAVE  
OK

Este 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 started

O 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 password

Exemplo

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 second

A 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 second

O 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 100000

Comandos 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 
:3

No 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: PONG

Exemplo 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 tutorial

Exemplo 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:: Mysql

Exemplo 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-list

Antes 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 install

Agora, 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.so

Agora, 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: PONG

Exemplo 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 tutorial

Exemplo 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 
Mysql

Exemplo 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