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-serverQuesto installerà Redis sulla tua macchina.
Avvia Redis
$redis-serverControlla se Redis funziona
$redis-cliQuesto 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
PONGQuesto 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_NAMEEsempio
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_VALUEEsempio
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-cliEsempio
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
PONGNell'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 passwordEsempio
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
PONGI 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_NAMEEsempio
redis 127.0.0.1:6379> SET tutorialspoint redis
OK
redis 127.0.0.1:6379> DEL tutorialspoint
(integer) 1Nell'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_NAMEEsempio
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) 3Comandi 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) 1Ora, 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> EXECEsempio
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) 1Comandi 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
PONGComandi 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 = 0Comandi 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> SAVEEsempio
L'esempio seguente crea un backup del database corrente.
127.0.0.1:6379> SAVE
OKQuesto 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 startedIl 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 passwordEsempio
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 secondDi 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 secondRedis 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 100000Comandi 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
:3Nell'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: PONGRedis 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 tutorialRedis 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:: MysqlRedis 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-listPrima 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 installOra, copia e incolla il contenuto della cartella "moduli" nella directory dell'estensione PHP e aggiungi le seguenti righe php.ini.
extension = redis.soOra, 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: PONGEsempio 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 tutorialEsempio 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
MysqlEsempio 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