Redis - Guida rapida

Redis è un archivio chiave-valore avanzato e open source e una soluzione apt per la creazione di applicazioni web scalabili e ad alte prestazioni.

Redis ha tre principali peculiarità che lo contraddistinguono.

  • Redis mantiene il suo database interamente nella memoria, utilizzando il disco solo per la persistenza.

  • Redis ha una serie relativamente ricca di tipi di dati rispetto a molti archivi dati di valori-chiave.

  • Redis può replicare i dati su qualsiasi numero di slave.

Vantaggi di Redis

Di seguito sono riportati alcuni vantaggi di Redis.

  • Exceptionally fast - Redis è molto veloce e può eseguire circa 110000 SET al secondo, circa 81000 GET al secondo.

  • Supports rich data types- Redis supporta nativamente la maggior parte dei tipi di dati che gli sviluppatori già conoscono come elenco, insieme, insieme ordinato e hash. Ciò semplifica la risoluzione di una serie di problemi poiché sappiamo quale problema può essere gestito meglio con quale tipo di dati.

  • Operations are atomic - Tutte le operazioni Redis sono atomiche, il che garantisce che se due client accedono contemporaneamente, il server Redis riceverà il valore aggiornato.

  • Multi-utility tool - Redis è uno strumento multiutility e può essere utilizzato in una serie di casi d'uso come memorizzazione nella cache, code di messaggistica (Redis supporta nativamente la pubblicazione / sottoscrizione), qualsiasi dato di breve durata nell'applicazione, come sessioni di applicazioni web, web numero di visite alle pagine, ecc.

Redis e altri archivi di valori-chiave

  • Redis è un percorso di evoluzione diverso nei DB di valori-chiave, dove i valori possono contenere tipi di dati più complessi, con operazioni atomiche definite su tali tipi di dati.

  • Redis è un database in memoria ma persistente sul database del disco, quindi rappresenta un compromesso diverso in cui si ottiene una velocità di lettura e scrittura molto elevata con la limitazione dei set di dati che non possono essere più grandi della memoria.

  • Un altro vantaggio dei database in memoria è che la rappresentazione in memoria di strutture di dati complesse è molto più semplice da manipolare rispetto alla stessa struttura di dati su disco. Pertanto, Redis può fare molto con poca complessità interna.

In questo capitolo apprenderete la configurazione ambientale per Redis.

Installa Redis su Ubuntu

Per installare Redis su Ubuntu, vai al terminale e digita i seguenti comandi:

$sudo apt-get update $sudo apt-get install redis-server

Questo installerà Redis sulla tua macchina.

Avvia Redis

$redis-server

Controlla se Redis funziona

$redis-cli

Questo aprirà un prompt di redis.

redis 127.0.0.1:6379>

Nel prompt sopra, 127.0.0.1 è l'indirizzo IP della macchina e 6379è la porta su cui è in esecuzione il server Redis. Ora digita quanto seguePING comando.

redis 127.0.0.1:6379> ping 
PONG

Questo mostra che Redis è stato installato correttamente sul tuo computer.

Installa Redis Desktop Manager su Ubuntu

Per installare il gestore desktop Redis su Ubuntu, scarica il pacchetto da https://redisdesktop.com/download

Apri il pacchetto scaricato e installalo.

Redis desktop manager ti fornirà l'interfaccia utente per gestire le tue chiavi e dati Redis.

In Redis, è disponibile un file di configurazione (redis.conf) nella directory principale di Redis. Sebbene tu possa ottenere e impostare tutte le configurazioni Redis da RedisCONFIG comando.

Sintassi

Di seguito è riportata la sintassi di base di Redis CONFIG comando.

redis 127.0.0.1:6379> CONFIG GET CONFIG_SETTING_NAME

Esempio

redis 127.0.0.1:6379> CONFIG GET loglevel  
1) "loglevel" 
2) "notice"

Per ottenere tutte le impostazioni di configurazione, utilizza * al posto di CONFIG_SETTING_NAME

Esempio

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

Modifica configurazione

Per aggiornare la configurazione, puoi modificare redis.conf direttamente o puoi aggiornare le configurazioni tramite CONFIG set comando.

Sintassi

Di seguito è riportata la sintassi di base di CONFIG SET comando.

redis 127.0.0.1:6379> CONFIG SET CONFIG_SETTING_NAME NEW_CONFIG_VALUE

Esempio

redis 127.0.0.1:6379> CONFIG SET loglevel "notice" 
OK 
redis 127.0.0.1:6379> CONFIG GET loglevel  
1) "loglevel" 
2) "notice"

Redis supporta 5 tipi di tipi di dati.

stringhe

La stringa Redis è una sequenza di byte. Le stringhe in Redis sono binarie sicure, il che significa che hanno una lunghezza nota non determinata da alcun carattere di terminazione speciale. Pertanto, puoi memorizzare qualsiasi cosa fino a 512 megabyte in una stringa.

Esempio

redis 127.0.0.1:6379> SET name "tutorialspoint" 
OK 
redis 127.0.0.1:6379> GET name 
"tutorialspoint"

Nell'esempio sopra, SET e GET sono i comandi di Redis, name è la chiave utilizzata in Redis e tutorialspoint è il valore stringa archiviato in Redis.

Note - Un valore stringa può avere una lunghezza massima di 512 megabyte.

Hash

Un hash Redis è una raccolta di coppie di valori chiave. Gli hash Redis sono mappe tra campi stringa e valori stringa. Quindi, sono usati per rappresentare oggetti.

Esempio

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"

Nell'esempio precedente, il tipo di dati hash viene utilizzato per memorizzare l'oggetto dell'utente che contiene le informazioni di base dell'utente. QuiHMSET, HGETALL sono comandi per Redis, mentre user − 1 è la chiave.

Ogni hash può memorizzare fino a 2 32-1 coppie di valori di campo (più di 4 miliardi).

Liste

Gli elenchi Redis sono semplicemente elenchi di stringhe, ordinati in base all'ordine di inserimento. Puoi aggiungere elementi a un elenco Redis sulla testa o sulla coda.

Esempio

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"

La lunghezza massima di una lista è di 2 32 - 1 elementi (4294967295, più di 4 miliardi di elementi per lista).

Imposta

I set Redis sono una raccolta di stringhe non ordinata. In Redis è possibile aggiungere, rimuovere e verificare l'esistenza di membri nella complessità temporale O (1).

Esempio

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 - Nell'esempio sopra, rabitmq viene aggiunto due volte, tuttavia a causa della proprietà unica del set, viene aggiunto solo una volta.

Il numero massimo di membri in un set è 2 32 - 1 (4294967295, più di 4 miliardi di membri per set).

Set ordinati

I set ordinati Redis sono simili ai set Redis, raccolte di stringhe non ripetitive. La differenza è che ogni membro di un set ordinato è associato a un punteggio, che viene utilizzato per prendere il set ordinato ordinato, dal punteggio più piccolo a quello più grande. Sebbene i membri siano unici, i punteggi possono essere ripetuti.

Esempio

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"

I comandi Redis vengono utilizzati per eseguire alcune operazioni sul server Redis.

Per eseguire comandi sul server Redis, è necessario un client Redis. Il client Redis è disponibile nel pacchetto Redis, che abbiamo installato in precedenza.

Sintassi

Di seguito è riportata la sintassi di base del client Redis.

$redis-cli

Esempio

L'esempio seguente spiega come avviare il client Redis.

Per avviare il client Redis, apri il terminale e digita il comando redis-cli. Questo si connetterà al tuo server locale e ora puoi eseguire qualsiasi comando.

$redis-cli 
redis 127.0.0.1:6379> 
redis 127.0.0.1:6379> PING  
PONG

Nell'esempio precedente, ci colleghiamo al server Redis in esecuzione sulla macchina locale ed eseguiamo un comando PING, che controlla se il server è in esecuzione o meno.

Esegui comandi sul server remoto

Per eseguire comandi sul server remoto Redis, è necessario connettersi al server dallo stesso client redis-cli

Sintassi

$ redis-cli -h host -p port -a password

Esempio

L'esempio seguente mostra come connettersi al server remoto Redis, in esecuzione sull'host 127.0.0.1, porta 6379 e con password 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

I comandi dei tasti Redis vengono utilizzati per la gestione delle chiavi in ​​Redis. Di seguito è riportata la sintassi per l'utilizzo dei comandi dei tasti redis.

Sintassi

redis 127.0.0.1:6379> COMMAND KEY_NAME

Esempio

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

Nell'esempio sopra, DEL è il comando, mentre tutorialspointè la chiave. Se la chiave viene eliminata, l'output del comando sarà (intero) 1, altrimenti sarà (intero) 0.

Redis Keys Commands

La tabella seguente elenca alcuni comandi di base relativi ai tasti.

Suor n Comando e descrizione
1 Tasto DEL

Questo comando elimina la chiave, se esiste.

2 Tasto DUMP

Questo comando restituisce una versione serializzata del valore archiviato nella chiave specificata.

3 Tasto ESISTE

Questo comando controlla se la chiave esiste o meno.

4 EXPIRE secondi chiave

Imposta la scadenza della chiave dopo il tempo specificato.

5 Timestamp chiave EXPIREAT

Imposta la scadenza della chiave dopo il tempo specificato. Qui l'ora è in formato timestamp Unix.

6 PEXPIRE chiave millisecondi

Imposta la scadenza della chiave in millisecondi.

7 Chiave PEXPIREAT millisecondi-timestamp

Imposta la scadenza della chiave nel timestamp Unix specificato in millisecondi.

8 Schema CHIAVI

Trova tutte le chiavi che corrispondono al modello specificato.

9 Tasto MOVE db

Sposta una chiave in un altro database.

10 Tasto PERSIST

Rimuove la scadenza dalla chiave.

11 Tasto PTTL

Ottiene il tempo rimanente nella scadenza delle chiavi in ​​millisecondi.

12 Chiave TTL

Ottiene il tempo rimanente nella scadenza delle chiavi.

13 RANDOMKEY

Restituisce una chiave casuale da Redis.

14 RENAME key newkey

Modifica il nome della chiave.

15 Nuova chiave RENAMENX

Rinomina la chiave, se non esiste una nuova chiave.

16 Tasto TYPE

Restituisce il tipo di dati del valore archiviato nella chiave.

I comandi delle stringhe Redis vengono utilizzati per gestire i valori delle stringhe in Redis. Di seguito è riportata la sintassi per l'utilizzo dei comandi stringa Redis.

Sintassi

redis 127.0.0.1:6379> COMMAND KEY_NAME

Esempio

redis 127.0.0.1:6379> SET tutorialspoint redis 
OK 
redis 127.0.0.1:6379> GET tutorialspoint 
"redis"

Nell'esempio sopra, SET e GET sono i comandi, mentre tutorialspoint è la chiave.

Comandi di stringhe Redis

La tabella seguente elenca alcuni comandi di base per gestire le stringhe in Redis.

Suor n Comando e descrizione
1 Valore della chiave SET

Questo comando imposta il valore nella chiave specificata.

2 Tasto GET

Ottiene il valore di una chiave.

3 GETRANGE chiave inizio fine

Ottiene una sottostringa della stringa archiviata in una chiave.

4 Valore chiave GETSET

Imposta il valore stringa di una chiave e restituisce il suo vecchio valore.

5 GETBIT offset chiave

Restituisce il valore del bit all'offset nel valore della stringa memorizzato nella chiave.

6 MGET key1 [key2 ..]

Ottiene i valori di tutte le chiavi fornite

7 Valore di offset della chiave SETBIT

Imposta o cancella il bit all'offset nel valore di stringa memorizzato nella chiave

8 Valore dei secondi chiave SETEX

Imposta il valore con la scadenza di una chiave

9 Valore della chiave SETNX

Imposta il valore di una chiave, solo se la chiave non esiste

10 Valore di offset della chiave SETRANGE

Sovrascrive la parte di una stringa in corrispondenza della chiave a partire dall'offset specificato

11 Tasto STRLEN

Ottiene la lunghezza del valore archiviato in una chiave

12 Valore chiave MSET [valore chiave ...]

Imposta più chiavi su più valori

13 Valore chiave MSETNX [valore chiave ...]

Imposta più chiavi su più valori, solo se nessuna delle chiavi esiste

14 Valore in millisecondi della chiave PSETEX

Imposta il valore e la scadenza in millisecondi di una chiave

15 Tasto INCR

Incrementa il valore intero di una chiave di uno

16 Incremento chiave INCRBY

Incrementa il valore intero di una chiave della quantità specificata

17 Incremento chiave INCRBYFLOAT

Incrementa il valore float di una chiave della quantità specificata

18 Tasto DECR

Decrementa il valore intero di una chiave di uno

19 Decremento del tasto DECRBY

Decrementa il valore intero di una chiave del numero specificato

20 Valore chiave APPEND

Aggiunge un valore a una chiave

Gli hash Redis sono mappe tra i campi stringa e i valori stringa. Quindi, sono il tipo di dati perfetto per rappresentare gli oggetti.

In Redis, ogni hash può memorizzare fino a più di 4 miliardi di coppie di valori di campo.

Esempio

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"

Nell'esempio precedente, abbiamo impostato i dettagli dei tutorial di Redis (nome, descrizione, Mi piace, visitatori) in un hash denominato "tutorialspoint".

Comandi hash Redis

La tabella seguente elenca alcuni comandi di base relativi all'hash.

Suor n Comando e descrizione
1 Chiave HDEL field2 [field2]

Elimina uno o più campi hash.

2 Campo chiave ESISTI

Determina se un campo hash esiste o meno.

3 Campo chiave HGET

Ottiene il valore di un campo hash archiviato nella chiave specificata.

4 Tasto HGETALL

Ottiene tutti i campi e i valori archiviati in un hash nella chiave specificata

5 Incremento del campo chiave HINCRBY

Incrementa il valore intero di un campo hash del numero specificato

6 Incremento del campo chiave HINCRBYFLOAT

Incrementa il valore float di un campo hash dell'importo specificato

7 Chiave HKEYS

Ottiene tutti i campi in un hash

8 Tasto HLEN

Ottiene il numero di campi in un hash

9 Chiave HMGET campo1 [campo2]

Ottiene i valori di tutti i campi hash dati

10 Chiave HMSET valore1 campo1 [valore2 campo2]

Imposta più campi hash su più valori

11 Valore del campo chiave HSET

Imposta il valore stringa di un campo hash

12 Valore del campo chiave HSETNX

Imposta il valore di un campo hash, solo se il campo non esiste

13 Tasto HVALS

Ottiene tutti i valori in un hash

14 Cursore tasto HSCAN [schema MATCH] [COUNT conteggio]

Esegue l'iterazione incrementale dei campi hash e dei valori associati

Gli elenchi Redis sono semplicemente elenchi di stringhe, ordinati in base all'ordine di inserimento. Puoi aggiungere elementi negli elenchi Redis all'inizio o alla fine dell'elenco.

La lunghezza massima di una lista è 2 32 - 1 elementi (4294967295, più di 4 miliardi di elementi per lista).

Esempio

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"

Nell'esempio precedente, tre valori vengono inseriti nell'elenco Redis denominati "tutorial" dal comando LPUSH.

Redis elenca i comandi

La tabella seguente elenca alcuni comandi di base relativi agli elenchi.

Suor n Comando e descrizione
1 BLPOP key1 [key2] timeout

Rimuove e ottiene il primo elemento in un elenco o si blocca finché non è disponibile

2 BRPOP key1 [key2] timeout

Rimuove e ottiene l'ultimo elemento in un elenco o si blocca finché uno non è disponibile

3 Timeout destinazione origine BRPOPLPUSH

Estrae un valore da un elenco, lo inserisce in un altro elenco e lo restituisce; o si blocca finché non è disponibile

4 Indice chiave LINDEX

Ottiene un elemento da un elenco in base al relativo indice

5 Tasto LINSERT PRIMA | DOPO il valore pivot

Inserisce un elemento prima o dopo un altro elemento in un elenco

6 Tasto LLEN

Ottiene la lunghezza di un elenco

7 Chiave LPOP

Rimuove e ottiene il primo elemento in un elenco

8 Chiave LPUSH valore1 [valore2]

Antepone uno o più valori a un elenco

9 Valore chiave LPUSHX

Antepone un valore a un elenco, solo se l'elenco esiste

10 Tasto LRANGE start stop

Ottiene un intervallo di elementi da un elenco

11 Valore di conteggio chiavi LREM

Rimuove gli elementi da un elenco

12 Valore dell'indice della chiave LSET

Imposta il valore di un elemento in un elenco in base al suo indice

13 Tasto LTRIM start stop

Taglia un elenco all'intervallo specificato

14 Tasto RPOP

Rimuove e ottiene l'ultimo elemento in un elenco

15 Destinazione di origine RPOPLPUSH

Rimuove l'ultimo elemento in un elenco, lo aggiunge a un altro elenco e lo restituisce

16 Valore chiave RPUSH1 [valore2]

Aggiunge uno o più valori a un elenco

17 Valore chiave RPUSHX

Aggiunge un valore a un elenco, solo se l'elenco esiste

I set Redis sono una raccolta non ordinata di stringhe uniche. Unico significa che i set non consentono la ripetizione dei dati in una chiave.

In Redis set aggiungi, rimuovi e verifica l'esistenza di membri in O (1) (tempo costante indipendentemente dal numero di elementi contenuti all'interno del set). La lunghezza massima di un elenco è di 2 32 - 1 elementi (4294967295, più di 4 miliardi di elementi per set).

Esempio

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"

Nell'esempio sopra, tre valori vengono inseriti nel set Redis denominato "tutorial" dal comando SADD.

Redis imposta i comandi

La tabella seguente elenca alcuni comandi di base relativi ai set.

Suor n Comando e descrizione
1 SADD key member1 [member2]

Aggiunge uno o più membri a un set

2 Chiave SCARD

Ottiene il numero di membri in un set

3 Chiave 1 SDIFF [chiave2]

Sottrae più insiemi

4 SDIFFSTORE destinazione chiave1 [chiave2]

Sottrae più set e memorizza il set risultante in una chiave

5 SINTER key1 [key2]

Interseca più insiemi

6 SINTERSTORE destinazione key1 [key2]

Interseca più set e memorizza il set risultante in una chiave

7 Membro chiave di SISMEMBER

Determina se un dato valore è un membro di un insieme

8 Tasto SMEMBERS

Ottiene tutti i membri in un set

9 Membro di destinazione di origine SMOVE

Sposta un membro da un set a un altro

10 Tasto SPOP

Rimuove e restituisce un membro casuale da un set

11 Chiave SRANDMEMBER [conteggio]

Ottiene uno o più membri casuali da un set

12 SREM key member1 [member2]

Rimuove uno o più membri da un insieme

13 SUNION key1 [key2]

Aggiunge più set

14 SUNIONSTORE destinazione key1 [key2]

Aggiunge più set e memorizza il set risultante in una chiave

15 Cursore tasto SSCAN [schema MATCH] [COUNT conteggio]

Esegue l'iterazione incrementale degli elementi dell'insieme

I set ordinati Redis sono simili ai set Redis con la caratteristica unica dei valori memorizzati in un set. La differenza è che ogni membro di un set ordinato è associato a un punteggio, che viene utilizzato per prendere il set ordinato ordinato, dal punteggio più piccolo a quello più grande.

In Redis set ordinato, aggiungi, rimuovi e verifica l'esistenza di membri in O (1) (tempo costante indipendentemente dal numero di elementi contenuti nel set). La lunghezza massima di un elenco è 2 32 - 1 elementi (4294967295, più di 4 miliardi di elementi per set).

Esempio

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"

Nell'esempio precedente, tre valori vengono inseriti con il relativo punteggio nel set ordinato di Redis denominato "tutorial" dal comando ZADD.

Comandi di insiemi ordinati Redis

La tabella seguente elenca alcuni comandi di base relativi agli insiemi ordinati.

Suor n Comando e descrizione
1 Punteggio chiave ZADD1 membro1 [punteggio2 membro2]

Aggiunge uno o più membri a un insieme ordinato o ne aggiorna il punteggio, se già esistente

2 Tasto ZCARD

Ottiene il numero di membri in un set ordinato

3 ZCOUNT chiave min max

Conta i membri in un insieme ordinato con punteggi entro i valori dati

4 Membro di incremento chiave ZINCRBY

Incrementa il punteggio di un membro in un insieme ordinato

5 Tasto numerico destinazione ZINTERSTORE [tasto ...]

Interseca più set ordinati e memorizza il set ordinato risultante in una nuova chiave

6 ZLEXCOUNT chiave min max

Conta il numero di membri in un insieme ordinato tra un determinato intervallo lessicografico

7 Arresto avvio chiave ZRANGE [WITHSCORES]

Restituisce un intervallo di membri in un insieme ordinato, per indice

8 Chiave ZRANGEBYLEX min max [LIMIT offset count]

Restituisce un intervallo di membri in un insieme ordinato, per intervallo lessicografico

9 Chiave ZRANGEBYSCORE min max [WITHSCORES] [LIMIT]

Restituisce un intervallo di membri in un insieme ordinato, in base al punteggio

10 Membro chiave di ZRANK

Determina l'indice di un membro in un insieme ordinato

11 Membro chiave ZREM [membro ...]

Rimuove uno o più membri da un insieme ordinato

12 ZREMRANGEBYLEX chiave min max

Rimuove tutti i membri in un insieme ordinato compreso nell'intervallo lessicografico specificato

13 ZREMRANGEBYRANK chiave start stop

Rimuove tutti i membri in un insieme ordinato all'interno degli indici specificati

14 ZREMRANGEBYSCORE chiave min max

Rimuove tutti i membri in un insieme ordinato all'interno dei punteggi dati

15 ZREVRANGE key start stop [WITHSCORES]

Restituisce un intervallo di membri in un insieme ordinato, per indice, con punteggi ordinati dal più alto al più basso

16 Chiave ZREVRANGEBYSCORE max min [WITHSCORES]

Restituisce un intervallo di membri in un insieme ordinato, in base al punteggio, con i punteggi ordinati dal più alto al più basso

17 Membro chiave di ZREVRANK

Determina l'indice di un membro in un insieme ordinato, con punteggi ordinati dal più alto al più basso

18 Membro chiave ZSCORE

Ottiene il punteggio associato al membro specificato in un set ordinato

19 ZUNIONSTORE destinazione numkeys key [key ...]

Aggiunge più set ordinati e memorizza il set ordinato risultante in una nuova chiave

20 Cursore tasto ZSCAN [schema MATCH] [COUNT conteggio]

Esegue l'iterazione incrementale degli elementi dei set ordinati e dei punteggi associati

Redis HyperLogLog è un algoritmo che utilizza la randomizzazione per fornire un'approssimazione del numero di elementi univoci in un set utilizzando solo una costante e una piccola quantità di memoria.

HyperLogLog fornisce un'ottima approssimazione della cardinalità di un set anche utilizzando una quantità di memoria molto piccola intorno ai 12 kbyte per chiave con un errore standard dello 0,81%. Non c'è limite al numero di elementi che puoi contare, a meno che non ti avvicini a 2 64 elementi.

Esempio

L'esempio seguente spiega come funziona Redis HyperLogLog.

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

Comandi di Redis HyperLogLog

La tabella seguente elenca alcuni comandi di base relativi a Redis HyperLogLog.

Suor n Comando e descrizione
1 Elemento chiave PFADD [elemento ...]

Aggiunge gli elementi specificati all'HyperLogLog specificato.

2 PFCOUNT chiave [chiave ...]

Restituisce la cardinalità approssimativa degli insiemi osservati da HyperLogLog in corrispondenza delle chiavi.

3 PFMERGE destkey sourcekey [sourcekey ...]

Unisce N diversi HyperLogLog in uno unico.

Redis Pub / Sub implementa il sistema di messaggistica in cui i mittenti (nella terminologia redis chiamati editori) inviano i messaggi mentre i destinatari (abbonati) li ricevono. Viene chiamato il collegamento tramite il quale vengono trasferiti i messaggichannel.

In Redis, un cliente può iscriversi a qualsiasi numero di canali.

Esempio

L'esempio seguente spiega come funziona il concetto di abbonato di pubblicazione. Nell'esempio seguente, un client sottoscrive un canale denominato "redisChat".

redis 127.0.0.1:6379> SUBSCRIBE redisChat  
Reading messages... (press Ctrl-C to quit) 
1) "subscribe" 
2) "redisChat" 
3) (integer) 1

Ora, due client stanno pubblicando i messaggi sullo stesso canale denominato "redisChat" e il client abbonato sopra sta ricevendo messaggi.

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"

Comandi Redis PubSub

La tabella seguente elenca alcuni comandi di base relativi a Redis Pub / Sub.

Suor n Comando e descrizione
1 PSUBSCRIBE pattern [pattern ...]

Si iscrive ai canali che corrispondono ai pattern forniti.

2 Sottocomando PUBSUB [argomento [argomento ...]]

Indica lo stato del sistema Pub / Sub. Ad esempio, quali client sono attivi sul server.

3 PUBBLICARE il messaggio del canale

Pubblica un messaggio su un canale.

4 PUNSUBSCRIBE [pattern [pattern ...]]

Interrompe l'ascolto dei messaggi pubblicati sui canali che corrispondono ai modelli dati.

5 SUBSCRIBE canale [canale ...]

Ascolta i messaggi pubblicati sui canali specificati.

6 UNSUBSCRIBE [canale [canale ...]]

Interrompe l'ascolto dei messaggi pubblicati sui canali specificati.

Le transazioni Redis consentono l'esecuzione di un gruppo di comandi in un unico passaggio. Di seguito sono riportate le due proprietà delle transazioni.

  • Tutti i comandi in una transazione vengono eseguiti in sequenza come un'unica operazione isolata. Non è possibile che una richiesta emessa da un altro client venga servita durante l'esecuzione di una transazione Redis.

  • Anche la transazione Redis è atomica. Atomico significa che tutti i comandi o nessuno vengono elaborati.

Campione

La transazione Redis viene avviata tramite comando MULTI e quindi è necessario passare un elenco di comandi che dovrebbero essere eseguiti nella transazione, dopo di che l'intera transazione viene eseguita da EXEC comando.

redis 127.0.0.1:6379> MULTI 
OK 
List of commands here 
redis 127.0.0.1:6379> EXEC

Esempio

L'esempio seguente spiega come avviare ed eseguire la transazione Redis.

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

Comandi di transazione Redis

La tabella seguente mostra alcuni comandi di base relativi alle transazioni Redis.

Suor n Comando e descrizione
1 SCARTARE

Elimina tutti i comandi emessi dopo MULTI

2 EXEC

Esegue tutti i comandi emessi dopo MULTI

3 MULTI

Contrassegna l'inizio di un blocco di transazioni

4 UNWATCH

Dimentica tutte le chiavi guardate

5 Tasto WATCH [tasto ...]

Controlla le chiavi fornite per determinare l'esecuzione del blocco MULTI / EXEC

Lo scripting Redis viene utilizzato per valutare gli script utilizzando l'interprete Lua. È integrato in Redis a partire dalla versione 2.6.0. Il comando utilizzato per lo scripting èEVAL comando.

Sintassi

Di seguito è riportata la sintassi di base di EVAL comando.

redis 127.0.0.1:6379> EVAL script numkeys key [key ...] arg [arg ...]

Esempio

L'esempio seguente spiega come funziona lo scripting 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"

Comandi di scripting Redis

La tabella seguente elenca alcuni comandi di base relativi a Redis Scripting.

Suor n Comando e descrizione
1 EVAL script numkeys key [key ...] arg [arg ...]

Esegue uno script Lua.

2 EVALSHA sha1 numkeys key [key ...] arg [arg ...]

Esegue uno script Lua.

3 SCRIPT EXISTS script [script ...]

Verifica l'esistenza di script nella cache degli script.

4 SCRIPT FLUSH

Rimuove tutti gli script dalla cache degli script.

5 SCRIPT KILL

Elimina lo script attualmente in esecuzione.

6 SCRIPT LOAD script

Carica lo script Lua specificato nella cache degli script.

I comandi di connessione Redis vengono utilizzati fondamentalmente per gestire le connessioni client con il server Redis.

Esempio

L'esempio seguente spiega come un client si autentica sul server Redis e controlla se il server è in esecuzione o meno.

redis 127.0.0.1:6379> AUTH "password" 
OK 
redis 127.0.0.1:6379> PING 
PONG

Comandi di connessione Redis

La tabella seguente elenca alcuni comandi di base relativi alle connessioni Redis.

Suor n Comando e descrizione
1 Password AUTH

Autentica al server con la password fornita

2 Messaggio ECHO

Stampa la stringa data

3 PING

Controlla se il server è in esecuzione o meno

4 SMETTERE

Chiude la connessione corrente

5 SELEZIONA indice

Modifica il database selezionato per la connessione corrente

I comandi del server Redis sono fondamentalmente utilizzati per gestire il server Redis.

Esempio

L'esempio seguente spiega come possiamo ottenere tutte le statistiche e le informazioni sul server.

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

Comandi del server Redis

La tabella seguente elenca alcuni comandi di base relativi al server Redis.

Suor n Comando e descrizione
1 BGREWRITEAOF

Riscrive in modo asincrono il file di sola aggiunta

2 BGSAVE

Salva in modo asincrono il set di dati sul disco

3 CLIENT KILL [ip: port] [ID client-id]

Uccide la connessione di un client

4 LISTA CLIENTI

Ottiene l'elenco delle connessioni client al server

5 GETNAME CLIENTE

Ottiene il nome della connessione corrente

6 Timeout PAUSA CLIENTE

Interrompe l'elaborazione dei comandi dai client per un periodo di tempo specificato

7 Nome-connessione SETNAME CLIENT

Imposta il nome della connessione corrente

8 SLOT DEL CLUSTER

Ottiene una matrice di mapping tra slot del cluster e nodi

9 COMANDO

Ottiene una matrice di dettagli del comando Redis

10 CONTO COMANDI

Ottiene il numero totale di comandi Redis

11 GETKEY DI COMANDO

Estrae le chiavi con un comando Redis completo

12 BGSAVE

Salva in modo asincrono il set di dati sul disco

13 INFORMAZIONI SUI COMANDI nome-comando [nome-comando ...]

Ottiene una matrice di dettagli del comando Redis specifici

14 Parametro CONFIG GET

Ottiene il valore di un parametro di configurazione

15 CONFIG REWRITE

Riscrive il file di configurazione con la configurazione in memoria

16 CONFIG SET valore del parametro

Imposta un parametro di configurazione sul valore dato

17 CONFIG RESETSTAT

Reimposta le statistiche restituite da INFO

18 DBSIZE

Restituisce il numero di chiavi nel database selezionato

19 Tasto DEBUG OBJECT

Ottiene informazioni di debug su una chiave

20 DEBUG SEGFAULT

Rende il server in crash

21 FLUSHALL

Rimuove tutte le chiavi da tutti i database

22 FLUSHDB

Rimuove tutte le chiavi dal database corrente

23 INFO [sezione]

Ottiene informazioni e statistiche sul server

24 LASTSAVE

Ottiene il timestamp UNIX dell'ultimo salvataggio riuscito su disco

25 TENERE SOTTO CONTROLLO

Ascolta tutte le richieste ricevute dal server in tempo reale

26 RUOLO

Restituisce il ruolo dell'istanza nel contesto della replica

27 SALVA

Salva in modo sincrono il set di dati sul disco

28 SHUTDOWN [NOSAVE] [SAVE]

Salva in modo sincrono il set di dati sul disco e quindi arresta il server

29 Porta host SLAVEOF

Rende il server uno schiavo di un'altra istanza o lo promuove come master

30 Sottocomando SLOWLOG [argomento]

Gestisce il registro delle query lente di Redis

31 SYNC

Comando utilizzato per la replica

32 TEMPO

Restituisce l'ora del server corrente

Redis SAVE viene utilizzato per creare un backup del database Redis corrente.

Sintassi

Di seguito è riportata la sintassi di base di redis SAVE comando.

127.0.0.1:6379> SAVE

Esempio

L'esempio seguente crea un backup del database corrente.

127.0.0.1:6379> SAVE  
OK

Questo comando creerà un file dump.rdb file nella directory Redis.

Ripristina dati Redis

Per ripristinare i dati Redis, spostare il file di backup Redis (dump.rdb) nella directory Redis e avviare il server. Per ottenere la tua directory Redis, usaCONFIG comando di Redis come mostrato di seguito.

127.0.0.1:6379> CONFIG get dir  
1) "dir" 
2) "/user/tutorialspoint/redis-2.8.13/src"

Nell'output del comando precedente /user/tutorialspoint/redis-2.8.13/src è la directory in cui è installato il server Redis.

Bgsave

Per creare il backup di Redis, un comando alternativo BGSAVEè anche disponibile. Questo comando avvierà il processo di backup e lo eseguirà in background.

Esempio

127.0.0.1:6379> BGSAVE  
Background saving started

Il database Redis può essere protetto, in modo tale che qualsiasi client che effettua una connessione debba autenticarsi prima di eseguire un comando. Per proteggere Redis, è necessario impostare la password nel file di configurazione.

Esempio

L'esempio seguente mostra i passaggi per proteggere la tua istanza Redis.

127.0.0.1:6379> CONFIG get requirepass 
1) "requirepass" 
2) ""

Per impostazione predefinita, questa proprietà è vuota, il che significa che nessuna password è impostata per questa istanza. È possibile modificare questa proprietà eseguendo il seguente comando.

127.0.0.1:6379> CONFIG set requirepass "tutorialspoint" 
OK 
127.0.0.1:6379> CONFIG get requirepass 
1) "requirepass" 
2) "tutorialspoint"

Dopo aver impostato la password, se un client esegue il comando senza autenticazione, allora (error) NOAUTH Authentication required. l'errore tornerà. Quindi, il client deve usareAUTH comando di autenticarsi.

Sintassi

Di seguito è riportata la sintassi di base di AUTH comando.

127.0.0.1:6379> AUTH password

Esempio

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"

Redis benchmark è l'utilità per controllare le prestazioni di Redis eseguendo n comandi contemporaneamente.

Sintassi

Di seguito è riportata la sintassi di base del benchmark Redis.

redis-benchmark [option] [option value]

Esempio

L'esempio seguente controlla Redis chiamando 100000 comandi.

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

Di seguito è riportato un elenco delle opzioni disponibili nel benchmark Redis.

Suor n Opzione Descrizione Valore predefinito
1 -h Specifica il nome host del server 127.0.0.1
2 -p Specifica la porta del server 6379
3 -s Specifica il socket del server
4 -c Specifica il numero di connessioni parallele 50
5 -n Specifica il numero totale di richieste 10000
6 -d Specifica la dimensione dei dati del valore SET / GET in byte 2
7 -k 1 = mantieni vivo, 0 = riconnetti 1
8 -r Usa tasti casuali per SET / GET / INCR, valori casuali per SADD
9 -p Richieste di pipeline <numreq> 1
10 -h Specifica il nome host del server
11 -q Forza la calma a Redis. Mostra solo i valori query / sec
12 --csv Uscita in formato CSV
13 -l Genera loop, esegui i test per sempre
14 -t Esegue solo l'elenco di test separati da virgole
15 -I Modalità stand-by. Apre solo N connessioni inattive e aspetta

Esempio

L'esempio seguente mostra le molteplici opzioni di utilizzo nell'utilità di 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

Redis accetta le connessioni dei client sulla porta TCP in ascolto configurata e sul socket Unix, se abilitato. Quando viene accettata una nuova connessione client, vengono eseguite le seguenti operazioni:

  • Il socket client viene messo in stato di non blocco poiché Redis utilizza I / O multiplexing e non bloccante.

  • L'opzione TCP_NODELAY è impostata per garantire che non abbiamo ritardi nella nostra connessione.

  • Viene creato un evento file leggibile in modo che Redis sia in grado di raccogliere le query del client non appena sono disponibili nuovi dati da leggere sul socket.

Numero massimo di client

In Redis config (redis.conf), c'è una proprietà chiamata maxclients, che descrive il numero massimo di client che possono connettersi a Redis.

Di seguito è riportata la sintassi di base del comando.

config get maxclients  

1) "maxclients" 
2) "10000"

Per impostazione predefinita, questa proprietà è impostata su 10000 (a seconda del numero massimo di descrittori di file limite del sistema operativo), sebbene sia possibile modificare questa proprietà.

Esempio

Nell'esempio seguente, abbiamo impostato il numero massimo di client a 100000, durante l'avvio del server.

redis-server --maxclients 100000

Comandi client

Suor n Comando Descrizione
1 CLIENT LIST Restituisce l'elenco dei client connessi al server Redis
2 CLIENT SETNAME Assigns a name to the current connection
3 CLIENT GETNAME Returns the name of the current connection as set by CLIENT SETNAME
4 CLIENT PAUSE This is a connections control command able to suspend all the Redis clients for the specified amount of time (in milliseconds)
5 CLIENT KILL This command closes a given client connection.

Redis is a TCP server and supports request/response protocol. In Redis, a request is accomplished with the following steps −

  • The client sends a query to the server, and reads from the socket, usually in a blocking way, for the server response.

  • The server processes the command and sends the response back to the client.

Meaning of Pipelining

The basic meaning of pipelining is, the client can send multiple requests to the server without waiting for the replies at all, and finally reads the replies in a single step.

Esempio

Per controllare il pipelining Redis, basta avviare l'istanza Redis e digitare il seguente comando nel terminale.

$(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

Nell'esempio sopra, controlleremo la connessione Redis utilizzando PINGcomando. Abbiamo impostato una stringa denominatatutorial con valore redis. Successivamente, otteniamo il valore delle chiavi e incrementiamo il numero del visitatore tre volte. Nel risultato, possiamo vedere che tutti i comandi vengono inviati a Redis una volta e Redis fornisce l'output di tutti i comandi in un unico passaggio.

Vantaggi del pipelining

Il vantaggio di questa tecnica è una prestazione del protocollo drasticamente migliorata. La velocità ottenuta dal pipelining varia da un fattore cinque per le connessioni a localhost fino a un fattore di almeno cento rispetto alle connessioni Internet più lente.

Il partizionamento è il processo di suddivisione dei dati in più istanze Redis, in modo che ogni istanza conterrà solo un sottoinsieme delle tue chiavi.

Vantaggi del partizionamento

  • Consente database molto più grandi, utilizzando la somma della memoria di molti computer. Senza il partizionamento sei limitato alla quantità di memoria che un singolo computer può supportare.

  • Consente di scalare la potenza di calcolo su più core e più computer e la larghezza di banda di rete su più computer e adattatori di rete.

Svantaggi del partizionamento

  • Le operazioni che coinvolgono più chiavi in ​​genere non sono supportate. Ad esempio, non è possibile eseguire l'intersezione tra due set se sono archiviati nelle chiavi che sono mappate a diverse istanze di Redis.

  • Non è possibile utilizzare transazioni Redis che coinvolgono più chiavi.

  • Il granulato di partizionamento è la chiave, quindi non è possibile partizionare un set di dati con una singola chiave enorme come un set ordinato molto grande.

  • Quando si utilizza il partizionamento, la gestione dei dati è più complessa. Ad esempio, devi gestire più file RDB / AOF e per ottenere un backup dei tuoi dati devi aggregare i file di persistenza da più istanze e host.

  • Aggiungere e rimuovere la capacità può essere complesso. Ad esempio, Redis Cluster supporta il ribilanciamento dei dati per lo più trasparente con la possibilità di aggiungere e rimuovere nodi in fase di esecuzione. Tuttavia, altri sistemi come il partizionamento lato client e i proxy non supportano questa funzionalità. Una tecnica chiamataPresharding aiuta in questo senso.

Tipi di partizionamento

Esistono due tipi di partizionamento disponibili in Redis. Supponiamo di avere quattro istanze Redis, R0, R1, R2, R3 e molte chiavi che rappresentano utenti come user: 1, user: 2, ... e così via.

Partizionamento dell'intervallo

Il partizionamento degli intervalli viene eseguito mappando gli intervalli di oggetti in istanze Redis specifiche. Supponiamo che nel nostro esempio gli utenti dall'ID 0 all'ID 10000 entrino nell'istanza R0, mentre gli utenti dall'ID 10001 all'ID 20000 entrino nell'istanza R1 e così via.

Partizionamento hash

In questo tipo di partizionamento, una funzione hash (ad esempio la funzione modulo) viene utilizzata per convertire la chiave in un numero e quindi i dati vengono memorizzati in istanze di Redis differenti.

Prima di iniziare a utilizzare Redis nei programmi Java, è necessario assicurarsi di avere il driver Java Redis e Java configurato sulla macchina. Puoi controllare il nostro tutorial Java per l'installazione di Java sulla tua macchina.

Installazione

Vediamo ora come impostare il driver Java Redis.

  • Devi scaricare il vaso dal percorso Download jedis.jar. Assicurati di scaricare l'ultima versione di esso.

  • Devi includere il file jedis.jar nel tuo percorso di classe.

Connettiti a Redis Server

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

Ora, compiliamo ed eseguiamo il programma sopra per testare la connessione al server Redis. Puoi cambiare il tuo percorso secondo le tue esigenze. Stiamo assumendo la versione corrente dijedis.jar è disponibile nel percorso corrente.

$javac RedisJava.java 
$java RedisJava 
Connection to server sucessfully 
Server is running: PONG

Redis Java String Esempio

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

Ora compiliamo ed eseguiamo il programma sopra.

$javac RedisStringJava.java 
$java RedisStringJava 
Connection to server sucessfully 
Stored string in redis:: Redis tutorial

Redis Java List Example

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

Ora compiliamo ed eseguiamo il programma sopra.

$javac RedisListJava.java 
$java RedisListJava 
Connection to server sucessfully 
Stored string in redis:: Redis 
Stored string in redis:: Mongodb 
Stored string in redis:: Mysql

Redis Java Keys Esempio

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

Ora compiliamo ed eseguiamo il programma sopra.

$javac RedisKeyJava.java 
$java RedisKeyJava 
Connection to server sucessfully 
List of stored keys:: tutorial-name 
List of stored keys:: tutorial-list

Prima di iniziare a utilizzare Redis nei programmi PHP, è necessario assicurarsi di avere il driver PHP Redis e PHP configurati sulla macchina. Puoi controllare il tutorial PHP per l'installazione di PHP sul tuo computer.

Installazione

Ora, controlliamo come configurare il driver PHP Redis.

Devi scaricare phpredis dal repository GitHub https://github.com/nicolasff/phpredis. Dopo averlo scaricato, estrai i file nella directory phpredis. Su Ubuntu, installa la seguente estensione.

cd phpredis 
sudo phpize 
sudo ./configure 
sudo make 
sudo make install

Ora, copia e incolla il contenuto della cartella "moduli" nella directory dell'estensione PHP e aggiungi le seguenti righe php.ini.

extension = redis.so

Ora, l'installazione di Redis PHP è completa

Connettiti a Redis Server

<?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 il programma viene eseguito, produrrà il seguente risultato.

Connection to server sucessfully 
Server is running: PONG

Esempio di stringa PHP Redis

<?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 il programma precedente viene eseguito, produrrà il seguente risultato.

Connection to server sucessfully 
Stored string in redis:: Redis tutorial

Esempio di elenco php 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 il programma precedente viene eseguito, produrrà il seguente risultato.

Connection to server sucessfully 
Stored string in redis:: 
Redis 
Mongodb 
Mysql

Esempio di chiavi PHP Redis

<?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 il programma viene eseguito, produrrà il seguente risultato.

Connection to server sucessfully 
Stored string in redis:: 
tutorial-name 
tutorial-list