Come usare Redis con Python

Non è semplicemente facile da usare; è una gioia. Se un'API è UX per i programmatori, Redis dovrebbe essere nel Museum of Modern Art insieme al Mac Cube.

…

E quando si tratta di velocità, Redis è difficile da battere. Le letture sono veloci e le scritture sono ancora più veloci, gestendo fino a 100.000 SET operazioni al secondo da alcuni benchmark. (Fonte)

Incuriosito? Questo tutorial è stato creato per il programmatore Python che potrebbe avere da zero a poca esperienza Redis. Affronteremo due strumenti contemporaneamente e presenteremo sia Redis stesso che una delle sue librerie client Python, redis-py .

redis-py (che importi solo come redis ) è uno dei tanti client Python per Redis, ma ha la particolarità di essere classificato come "attualmente la strada da percorrere per Python" dagli stessi sviluppatori Redis. Ti consente di chiamare i comandi Redis da Python e di recuperare in cambio oggetti Python familiari.

In questo tutorial tratterai :

• Installazione di Redis dal sorgente e comprensione dello scopo dei binari risultanti
• Imparare una piccola fetta di Redis stesso, inclusi la sua sintassi, protocollo e design
• Padronanza di redis-py mentre vede anche scorci di come implementa il protocollo di Redis
• Configurazione e comunicazione con un'istanza del server Amazon ElastiCache Redis

Download gratuito: Ottieni un capitolo di esempio da Python Tricks:The Book che mostra le migliori pratiche di Python con semplici esempi che puoi applicare immediatamente per scrivere codice Pythonic più bello.

Installazione di Redis dall'origine

Come diceva il mio trisnonno, niente crea grinta come l'installazione dal sorgente. Questa sezione ti guiderà attraverso il download, la creazione e l'installazione di Redis. Ti prometto che questo non farà male!

Nota :Questa sezione è orientata all'installazione su Mac OS X o Linux. Se stai usando Windows, c'è un fork Microsoft di Redis che può essere installato come servizio Windows. Basti dire che Redis come programma vive più comodamente su una macchina Linux e che la configurazione e l'uso su Windows possono essere schizzinosi.

Innanzitutto, scarica il codice sorgente di Redis come tarball:

$ redisurl="http://download.redis.io/redis-stable.tar.gz"
$ curl -s -o redis-stable.tar.gz $redisurl

Quindi, passa a root ed estrai il codice sorgente dell'archivio in /usr/local/lib/ :

$ sudo su root
$ mkdir -p /usr/local/lib/
$ chmod a+w /usr/local/lib/
$ tar -C /usr/local/lib/ -xzf redis-stable.tar.gz

Facoltativamente, ora puoi rimuovere l'archivio stesso:

$ rm redis-stable.tar.gz

Questo ti lascerà con un repository di codice sorgente in /usr/local/lib/redis-stable/ . Redis è scritto in C, quindi dovrai compilare, collegare e installare con il make utilità:

$ cd /usr/local/lib/redis-stable/
$ make && make install

Usando make install fa due azioni:

1. Il primo make comando compila e collega il codice sorgente.

2. Il make install part prende i binari e li copia in /usr/local/bin/ in modo da poterli eseguire da qualsiasi luogo (supponendo che /usr/local/bin/ è in PATH ).

Ecco tutti i passaggi fino ad ora:

$ redisurl="http://download.redis.io/redis-stable.tar.gz"
$ curl -s -o redis-stable.tar.gz $redisurl
$ sudo su root
$ mkdir -p /usr/local/lib/
$ chmod a+w /usr/local/lib/
$ tar -C /usr/local/lib/ -xzf redis-stable.tar.gz
$ rm redis-stable.tar.gz
$ cd /usr/local/lib/redis-stable/
$ make && make install

A questo punto, prenditi un momento per confermare che Redis è nel tuo PATH e controlla la sua versione:

$ redis-cli --version
redis-cli 5.0.3

Se la tua shell non riesce a trovare redis-cli , verifica che /usr/local/bin/ è sul tuo PATH variabile di ambiente e in caso contrario aggiungerla.

Oltre a redis-cli , make install in realtà porta a una manciata di diversi file eseguibili (e un collegamento simbolico) posizionati in /usr/local/bin/ :

$ # A snapshot of executables that come bundled with Redis
$ ls -hFG /usr/local/bin/redis-* | sort
/usr/local/bin/redis-benchmark*
/usr/local/bin/redis-check-aof*
/usr/local/bin/redis-check-rdb*
/usr/local/bin/redis-cli*
/usr/local/bin/redis-sentinel@
/usr/local/bin/redis-server*

Sebbene tutti questi abbiano un uso previsto, i due che probabilmente ti interessano di più sono redis-cli e redis-server , che illustreremo tra breve. Ma prima di arrivare a questo, è necessario impostare una configurazione di base.

Configurazione di Redis

Redis è altamente configurabile. Anche se funziona senza problemi, prendiamoci un minuto per impostare alcune semplici opzioni di configurazione relative alla persistenza del database e alla sicurezza di base:

$ sudo su root
$ mkdir -p /etc/redis/
$ touch /etc/redis/6379.conf

Ora, scrivi quanto segue su /etc/redis/6379.conf . Tratteremo gradualmente cosa significano la maggior parte di questi durante il tutorial:

# /etc/redis/6379.conf

port              6379
daemonize         yes
save              60 1
bind              127.0.0.1
tcp-keepalive     300
dbfilename        dump.rdb
dir               ./
rdbcompression    yes

La configurazione di Redis è autodocumentante, con l'esempio redis.conf file situato nella fonte Redis per il tuo piacere di lettura. Se stai utilizzando Redis in un sistema di produzione, vale la pena bloccare tutte le distrazioni e dedicare del tempo alla lettura completa di questo file di esempio per familiarizzare con i dettagli di Redis e perfezionare la configurazione.

Alcuni tutorial, incluse parti della documentazione di Redis, possono anche suggerire di eseguire lo script Shell install_server.sh che si trova in redis/utils/install_server.sh . Sei assolutamente libero di eseguirlo come un'alternativa più completa a quanto sopra, ma prendi nota di alcuni punti più fini su install_server.sh :

• Non funzionerà su Mac OS X, solo Debian e Ubuntu Linux.
• Inietterà un set più completo di opzioni di configurazione in /etc/redis/6379.conf .
• Scriverà un init di System V script su /etc/init.d/redis_6379 che ti permetterà di fare sudo service redis_6379 start .

La guida di avvio rapido di Redis contiene anche una sezione su una configurazione Redis più corretta, ma le opzioni di configurazione di cui sopra dovrebbero essere del tutto sufficienti per questo tutorial e per iniziare.

Nota di sicurezza: Alcuni anni fa, l'autore di Redis ha evidenziato le vulnerabilità di sicurezza nelle versioni precedenti di Redis se non era stata impostata alcuna configurazione. Redis 3.2 (l'attuale versione 5.0.3 a marzo 2019) ha adottato misure per prevenire questa intrusione, impostando la protected-mode opzione per yes per impostazione predefinita.

Impostiamo esplicitamente bind 127.0.0.1 per consentire a Redis di ascoltare le connessioni solo dall'interfaccia localhost, sebbene sia necessario espandere questa whitelist in un vero server di produzione. Il punto di protected-mode è come una salvaguardia che imiterà questo comportamento di binding a localhost se non specifichi altrimenti nulla in bind opzione.

Detto questo, ora possiamo approfondire l'utilizzo di Redis stesso.

Dieci minuti circa a Redis

Questa sezione ti fornirà una conoscenza sufficiente di Redis per essere pericoloso, delineandone il design e l'utilizzo di base.

Per iniziare

Redis ha un'architettura client-server e utilizza un modello di richiesta-risposta . Ciò significa che tu (il client) ti connetti a un server Redis tramite una connessione TCP, sulla porta 6379 per impostazione predefinita. Richiedi qualche azione (come una forma di lettura, scrittura, ricezione, impostazione o aggiornamento) e il server serve sostieni una risposta.

Possono esserci molti client che parlano allo stesso server, che è davvero ciò che riguarda Redis o qualsiasi applicazione client-server. Ogni client esegue una lettura (in genere bloccante) su un socket in attesa della risposta del server.

Il cli in redis-cli sta per interfaccia a riga di comando e il server in redis-server è per, beh, l'esecuzione di un server. Nello stesso modo in cui eseguiresti python dalla riga di comando, puoi eseguire redis-cli per passare a un REPL interattivo (Read Eval Print Loop) in cui puoi eseguire i comandi del client direttamente dalla shell.

Per prima cosa, tuttavia, dovrai avviare redis-server in modo da avere un server Redis in esecuzione con cui parlare. Un modo comune per farlo durante lo sviluppo è avviare un server su localhost (indirizzo IPv4 127.0.0.1 ), che è l'impostazione predefinita a meno che tu non dica diversamente a Redis. Puoi anche passare redis-server il nome del tuo file di configurazione, che è simile a specificare tutte le sue coppie chiave-valore come argomenti della riga di comando:

$ redis-server /etc/redis/6379.conf
31829:C 07 Mar 2019 08:45:04.030 # oO0OoO0OoO0Oo Redis is starting oO0OoO0OoO0Oo
31829:C 07 Mar 2019 08:45:04.030 # Redis version=5.0.3, bits=64, commit=00000000, modified=0, pid=31829, just started
31829:C 07 Mar 2019 08:45:04.030 # Configuration loaded

Impostiamo il daemonize opzione di configurazione su yes , quindi il server viene eseguito in background. (Altrimenti, usa --daemonize yes come opzione per redis-server .)

Ora sei pronto per lanciare Redis REPL. Inserisci redis-cli sulla tua riga di comando. Vedrai host:port del server coppia seguita da un > richiesta:

127.0.0.1:6379>

Ecco uno dei comandi Redis più semplici, PING , che verifica semplicemente la connettività al server e restituisce "PONG" se le cose vanno bene:

127.0.0.1:6379> PING
PONG

I comandi Redis non fanno distinzione tra maiuscole e minuscole, sebbene le loro controparti Python non lo siano assolutamente.

Nota: Come altro controllo di integrità, puoi cercare l'ID del processo del server Redis con pgrep :

$ pgrep redis-server
26983

Per terminare il server, usa pkill redis-server dalla riga di comando. Su Mac OS X, puoi anche utilizzare redis-cli shutdown .

Successivamente, utilizzeremo alcuni dei comandi Redis comuni e li confronteremo con l'aspetto che avrebbero in Python puro.

Redis come dizionario Python

Redis sta per Servizio dizionario remoto .

"Vuoi dire, come un dizionario Python?" potresti chiedere.

Sì. In generale, ci sono molti parallelismi che puoi tracciare tra un dizionario Python (o una tabella hash generica) e ciò che Redis è e fa:

• Un database Redis contiene chiave:valore accoppia e supporta comandi come GET , SET e DEL , oltre a diverse centinaia di comandi aggiuntivi.

• Redis chiavi sono sempre stringhe.

• Redis valori possono essere diversi tipi di dati. Tratteremo alcuni dei tipi di dati di valore più essenziali in questo tutorial:string , list , hashes e sets . Alcuni tipi avanzati includono elementi geospaziali e il nuovo tipo di flusso.

• Molti comandi Redis operano in un tempo O(1) costante, proprio come recuperare un valore da un dict Python o qualsiasi tabella hash.

Il creatore di Redis Salvatore Sanfilippo probabilmente non apprezzerebbe il confronto di un database Redis con un semplice Python dict . Definisce il progetto un "server della struttura dei dati" (piuttosto che un archivio di valori-chiave, come memcached) perché, a suo merito, Redis supporta l'archiviazione di tipi aggiuntivi di chiave:valore tipi di dati oltre a string:string . Ma per i nostri scopi qui, è un confronto utile se hai familiarità con l'oggetto dizionario di Python.

Entriamo e impariamo con l'esempio. Il nostro primo database di giocattoli (con ID 0) sarà una mappatura di paese:capitale , dove utilizziamo SET per impostare coppie chiave-valore:

127.0.0.1:6379> SET Bahamas Nassau
OK
127.0.0.1:6379> SET Croatia Zagreb
OK
127.0.0.1:6379> GET Croatia
"Zagreb"
127.0.0.1:6379> GET Japan
(nil)

La sequenza di istruzioni corrispondente in Python puro sarebbe simile a questa:

>>> capitals = {}
>>> capitals["Bahamas"] = "Nassau"
>>> capitals["Croatia"] = "Zagreb"
>>> capitals.get("Croatia")
'Zagreb'
>>> capitals.get("Japan")  # None

Usiamo capitals.get("Japan") anziché capitals["Japan"] perché Redis restituirà nil piuttosto che un errore quando non viene trovata una chiave, che è analogo a None di Python .

Redis consente inoltre di impostare e ottenere più coppie chiave-valore in un comando, MSET e MGET , rispettivamente:

127.0.0.1:6379> MSET Lebanon Beirut Norway Oslo France Paris
OK
127.0.0.1:6379> MGET Lebanon Norway Bahamas
1) "Beirut"
2) "Oslo"
3) "Nassau"

La cosa più vicina in Python è con dict.update() :

>>> capitals.update({
...     "Lebanon": "Beirut",
...     "Norway": "Oslo",
...     "France": "Paris",
... })
>>> [capitals.get(k) for k in ("Lebanon", "Norway", "Bahamas")]
['Beirut', 'Oslo', 'Nassau']

Usiamo .get() anziché .__getitem__() per imitare il comportamento di Redis di restituire un valore di tipo null quando non viene trovata alcuna chiave.

Come terzo esempio, EXISTS comando fa quello che sembra, ovvero controllare se esiste una chiave:

127.0.0.1:6379> EXISTS Norway
(integer) 1
127.0.0.1:6379> EXISTS Sweden
(integer) 0

Python ha il in parola chiave per testare la stessa cosa, che indirizza a dict.__contains__(key) :

>>> "Norway" in capitals
True
>>> "Sweden" in capitals
False

Questi pochi esempi hanno lo scopo di mostrare, usando Python nativo, cosa sta succedendo ad alto livello con alcuni comandi Redis comuni. Non ci sono componenti client-server qui per gli esempi Python e redis-py non è ancora entrato in scena. Questo ha solo lo scopo di mostrare la funzionalità Redis tramite un esempio.

Ecco un riepilogo dei pochi comandi Redis che hai visto e dei loro equivalenti Python funzionali:

capitals["Bahamas"] = "Nassau"

capitals.get("Croatia")

capitals.update(
    {
        "Lebanon": "Beirut",
        "Norway": "Oslo",
        "France": "Paris",
    }
)

[capitals[k] for k in ("Lebanon", "Norway", "Bahamas")]

"Norway" in capitals

La libreria client Python Redis, redis-py , di cui ti immergerai a breve in questo articolo, fa le cose in modo diverso. Incapsula un'effettiva connessione TCP a un server Redis e invia comandi grezzi, come byte serializzati utilizzando il REdis Serialization Protocol (RESP), al server. Quindi prende la risposta grezza e la analizza di nuovo in un oggetto Python come bytes , int o anche datetime.datetime .

Nota :Finora hai parlato con il server Redis tramite il redis-cli interattivo REPL. Puoi anche impartire comandi direttamente, nello stesso modo in cui passeresti il ​​nome di uno script a python eseguibile, come python myscript.py .

Finora, hai visto alcuni dei tipi di dati fondamentali di Redis, che è una mappatura di string:string . Sebbene questa coppia chiave-valore sia comune nella maggior parte dei negozi chiave-valore, Redis offre una serie di altri possibili tipi di valore, che vedrai in seguito.

Più tipi di dati in Python rispetto a Redis

Prima di avviare il redis-py client Python, aiuta anche ad avere una conoscenza di base su alcuni tipi di dati Redis in più. Per essere chiari, tutte le chiavi Redis sono stringhe. È il valore che può assumere tipi di dati (o strutture) oltre ai valori di stringa utilizzati negli esempi finora.

Un hash è una mappatura di string:string , chiamato valore di campo coppie, che si trova sotto una chiave di primo livello:

127.0.0.1:6379> HSET realpython url "https://realpython.com/"
(integer) 1
127.0.0.1:6379> HSET realpython github realpython
(integer) 1
127.0.0.1:6379> HSET realpython fullname "Real Python"
(integer) 1

Questo imposta tre coppie campo-valore per una chiave , "realpython" . Se sei abituato alla terminologia e agli oggetti di Python, questo può creare confusione. Un hash Redis è più o meno analogo a un dict di Python che è nidificato a un livello di profondità:

data = {
    "realpython": {
        "url": "https://realpython.com/",
        "github": "realpython",
        "fullname": "Real Python",
    }
}

I campi di Redis sono simili alle chiavi Python di ciascuna coppia chiave-valore nidificata nel dizionario interno sopra. Redis si riserva il termine chiave per la chiave del database di primo livello che contiene la struttura hash stessa.

Proprio come c'è MSET per stringa:string di base coppie chiave-valore, c'è anche HMSET per gli hash per impostare più coppie all'interno l'oggetto valore hash:

127.0.0.1:6379> HMSET pypa url "https://www.pypa.io/" github pypa fullname "Python Packaging Authority"
OK
127.0.0.1:6379> HGETALL pypa
1) "url"
2) "https://www.pypa.io/"
3) "github"
4) "pypa"
5) "fullname"
6) "Python Packaging Authority"

Usando HMSET è probabilmente un parallelo più stretto per il modo in cui abbiamo assegnato i date su un dizionario nidificato sopra, invece di impostare ogni coppia nidificata come si fa con HSET .

Due tipi di valore aggiuntivi sono elenchi e set , che può sostituire un hash o una stringa come valore Redis. Sono in gran parte come suonano, quindi non ti dedicherò tempo con ulteriori esempi. Gli hash, le liste e gli insiemi hanno ciascuno dei comandi specifici per quel dato tipo di dati, che in alcuni casi sono indicati dalla loro lettera iniziale:

• Hash: I comandi per operare sugli hash iniziano con un H , come HSET , HGET o HMSET .

• Set: I comandi per operare sui set iniziano con una S , come SCARD , che ottiene il numero di elementi al valore impostato corrispondente a una determinata chiave.

• Elenchi: I comandi per operare sugli elenchi iniziano con una L o R . Gli esempi includono LPOP e RPUSH . La L o R si riferisce a quale lato dell'elenco viene operato. Alcuni comandi di elenco sono anche preceduti da una B , che significa blocco . Un'operazione di blocco non consente ad altre operazioni di interromperla mentre è in esecuzione. Ad esempio, BLPOP esegue un pop sinistro di blocco su una struttura di elenco.

Nota: Una caratteristica degna di nota del tipo di elenco di Redis è che si tratta di un elenco collegato anziché di un array. Ciò significa che l'aggiunta è O(1) mentre l'indicizzazione a un numero di indice arbitrario è O(N).

Ecco un rapido elenco di comandi specifici per i tipi di dati string, hash, list e set in Redis:

Questa tabella non è un quadro completo dei comandi e dei tipi Redis. C'è un buffet di tipi di dati più avanzati, come elementi geospaziali, set ordinati e HyperLogLog. Nella pagina dei comandi Redis, puoi filtrare per gruppo di struttura dati. C'è anche il riepilogo dei tipi di dati e l'introduzione ai tipi di dati Redis.

Dato che passeremo a fare cose in Python, ora puoi cancellare il tuo database di giocattoli con FLUSHDB ed esci da redis-cli REPLICA:

127.0.0.1:6379> FLUSHDB
OK
127.0.0.1:6379> QUIT

Questo ti riporterà al prompt della shell. Puoi lasciare redis-server in esecuzione in background, poiché ti servirà anche per il resto del tutorial.

Utilizzo di redis-py :Redis in Python

Ora che hai imparato alcune nozioni di base di Redis, è ora di passare a redis-py , il client Python che ti consente di parlare con Redis da un'API Python di facile utilizzo.

Primi passi

redis-py è una consolidata libreria client Python che ti consente di parlare con un server Redis direttamente tramite chiamate Python:

$ python -m pip install redis

Quindi, assicurati che il tuo server Redis sia ancora attivo e funzionante in background. Puoi controllare con pgrep redis-server , e se arrivi a mani vuote, riavvia un server locale con redis-server /etc/redis/6379.conf .

Ora, entriamo nella parte incentrata su Python delle cose. Ecco il "hello world" di redis-py :

 1>>> import redis
 2>>> r = redis.Redis()
 3>>> r.mset({"Croatia": "Zagreb", "Bahamas": "Nassau"})
 4True
 5>>> r.get("Bahamas")
 6b'Nassau'

Redis , utilizzato nella riga 2, è la classe centrale del pacchetto e il cavallo di battaglia con cui esegui (quasi) qualsiasi comando Redis. La connessione e il riutilizzo del socket TCP vengono eseguiti per te dietro le quinte e chiami i comandi Redis usando i metodi sull'istanza della classe r .

Si noti inoltre che il tipo dell'oggetto restituito, b'Nassau' nella riga 6, sono i bytes di Python digita, non str . Sono bytes anziché str questo è il tipo di ritorno più comune in redis-py , quindi potrebbe essere necessario chiamare r.get("Bahamas").decode("utf-8") a seconda di cosa vuoi effettivamente fare con la stringa di byte restituita.

Il codice sopra ti sembra familiare? I metodi in quasi tutti i casi corrispondono al nome del comando Redis che fa la stessa cosa. Qui hai chiamato r.mset() e r.get() , che corrispondono a MSET e GET nell'API Redis nativa.

Ciò significa anche che HGETALL diventa r.hgetall() , PING diventa r.ping() , e così via. Ci sono alcune eccezioni, ma la regola vale per la maggior parte dei comandi.

Sebbene gli argomenti del comando Redis di solito si traducano in una firma del metodo dall'aspetto simile, accettano oggetti Python. Ad esempio, la chiamata a r.mset() nell'esempio sopra usa un Python dict come primo argomento, piuttosto che una sequenza di stringhe di byte.

Abbiamo creato il Redis istanza r senza argomenti, ma viene fornito in bundle con una serie di parametri se ne hai bisogno:

# From redis/client.py
class Redis(object):
    def __init__(self, host='localhost', port=6379,
                 db=0, password=None, socket_timeout=None,
                 # ...

Puoi vedere che il nome host:porta predefinito la coppia è localhost:6379 , che è esattamente ciò di cui abbiamo bisogno nel caso del nostro redis-server conservato localmente esempio.

Il db parametro è il numero del database. Puoi gestire più database in Redis contemporaneamente e ognuno è identificato da un numero intero. Il numero massimo di database è 16 per impostazione predefinita.

Quando esegui solo redis-cli dalla riga di comando, questo ti avvia al database 0. Usa il -n flag per avviare un nuovo database, come in redis-cli -n 5 .

Tipi di chiavi consentiti

Una cosa che vale la pena sapere è che redis-py richiede che tu gli passi chiavi che sono bytes , str , int o float . (Convertirà gli ultimi 3 di questi tipi in bytes prima di inviarli al server.)

Considera un caso in cui desideri utilizzare le date del calendario come chiavi:

>>> import datetime
>>> today = datetime.date.today()
>>> visitors = {"dan", "jon", "alex"}
>>> r.sadd(today, *visitors)
Traceback (most recent call last):
# ...
redis.exceptions.DataError: Invalid input of type: 'date'.
Convert to a byte, string or number first.

Dovrai convertire in modo esplicito la date di Python oggetto a str , che puoi fare con .isoformat() :

>>> stoday = today.isoformat()  # Python 3.7+, or use str(today)
>>> stoday
'2019-03-10'
>>> r.sadd(stoday, *visitors)  # sadd: set-add
3
>>> r.smembers(stoday)
{b'dan', b'alex', b'jon'}
>>> r.scard(today.isoformat())
3

Per ricapitolare, Redis stesso consente solo stringhe come chiavi. redis-py è un po' più liberale nei tipi di Python che accetterà, anche se alla fine converte tutto in byte prima di inviarli a un server Redis.

Esempio:PyHats.com

È tempo di fare un esempio più completo. Facciamo finta di aver deciso di avviare un sito web redditizio, PyHats.com, che vende cappelli a prezzi esagerati a chiunque li compri e ti ha assunto per costruire il sito.

Utilizzerai Redis per gestire parte del catalogo prodotti, l'inventario e il rilevamento del traffico dei bot per PyHats.com.

È il primo giorno per il sito e venderemo tre cappelli in edizione limitata. Ogni cappello viene tenuto in un hash Redis di coppie campo-valore e l'hash ha una chiave che è un numero intero casuale prefissato, come hat:56854717 . Usando il hat: il prefisso è la convenzione Redis per la creazione di una sorta di spazio dei nomi all'interno di un database Redis:

import random

random.seed(444)
hats = {f"hat:{random.getrandbits(32)}": i for i in (
    {
        "color": "black",
        "price": 49.99,
        "style": "fitted",
        "quantity": 1000,
        "npurchased": 0,
    },
    {
        "color": "maroon",
        "price": 59.99,
        "style": "hipster",
        "quantity": 500,
        "npurchased": 0,
    },
    {
        "color": "green",
        "price": 99.99,
        "style": "baseball",
        "quantity": 200,
        "npurchased": 0,
    })
}

Iniziamo con il database 1 poiché abbiamo usato il database 0 in un esempio precedente:

>>> r = redis.Redis(db=1)

Per eseguire una scrittura iniziale di questi dati in Redis, possiamo usare .hmset() (hash multi-set), chiamandolo per ogni dizionario. Il "multi" è un riferimento all'impostazione di più coppie campo-valore, dove "campo" in questo caso corrisponde a una chiave di qualsiasi dizionario nidificato in hats :

 1>>> with r.pipeline() as pipe:
 2...    for h_id, hat in hats.items():
 3...        pipe.hmset(h_id, hat)
 4...    pipe.execute()
 5Pipeline<ConnectionPool<Connection<host=localhost,port=6379,db=1>>>
 6Pipeline<ConnectionPool<Connection<host=localhost,port=6379,db=1>>>
 7Pipeline<ConnectionPool<Connection<host=localhost,port=6379,db=1>>>
 8[True, True, True]
 9
10>>> r.bgsave()
11True

Il blocco di codice sopra introduce anche il concetto di pipelining Redis , che è un modo per ridurre il numero di transazioni di andata e ritorno necessarie per scrivere o leggere i dati dal server Redis. Se avessi appena chiamato r.hmset() tre volte, ciò richiederebbe un'operazione di andata e ritorno di andata e ritorno per ogni riga scritta.

Con una pipeline, tutti i comandi vengono memorizzati nel buffer lato client e quindi inviati in una volta, in un colpo solo, utilizzando pipe.hmset() nella riga 3. Ecco perché i tre True le risposte vengono restituite tutte in una volta, quando chiami pipe.execute() nella riga 4. A breve vedrai un caso d'uso più avanzato per una pipeline.

Nota :I documenti Redis forniscono un esempio di come fare la stessa cosa con redis-cli , dove puoi reindirizzare il contenuto di un file locale per eseguire l'inserimento di massa.

Facciamo un rapido controllo che tutto sia presente nel nostro database Redis:

>>> pprint(r.hgetall("hat:56854717"))
{b'color': b'green',
 b'npurchased': b'0',
 b'price': b'99.99',
 b'quantity': b'200',
 b'style': b'baseball'}

>>> r.keys()  # Careful on a big DB. keys() is O(N)
[b'56854717', b'1236154736', b'1326692461']

La prima cosa che vogliamo simulare è cosa succede quando un utente fa clic su Acquista . Se l'articolo è disponibile, aumenta il numero di npurchased di 1 e diminuirne la quantity (inventario) di 1. Puoi usare .hincrby() per fare questo:

>>> r.hincrby("hat:56854717", "quantity", -1)
199
>>> r.hget("hat:56854717", "quantity")
b'199'
>>> r.hincrby("hat:56854717", "npurchased", 1)
1

Nota :HINCRBY opera ancora su un valore hash che è una stringa, ma tenta di interpretare la stringa come un intero con segno a 64 bit in base 10 per eseguire l'operazione.

Questo vale per altri comandi relativi all'incremento e al decremento di altre strutture dati, vale a dire INCR , INCRBY , INCRBYFLOAT , ZINCRBY e HINCRBYFLOAT . Riceverai un errore se la stringa al valore non può essere rappresentata come un intero.

Non è proprio così semplice, però. Modifica della quantity e npurchased in due righe di codice si nasconde la realtà che un clic, un acquisto e un pagamento comportano più di questo. We need to do a few more checks to make sure we don’t leave someone with a lighter wallet and no hat:

• Step 1: Check if the item is in stock, or otherwise raise an exception on the backend.
• Step 2: If it is in stock, then execute the transaction, decrease the quantity field, and increase the npurchased campo.
• Step 3: Be alert for any changes that alter the inventory in between the first two steps (a race condition).

Step 1 is relatively straightforward:it consists of an .hget() to check the available quantity.

Step 2 is a little bit more involved. The pair of increase and decrease operations need to be executed atomically :either both should be completed successfully, or neither should be (in the case that at least one fails).

With client-server frameworks, it’s always crucial to pay attention to atomicity and look out for what could go wrong in instances where multiple clients are trying to talk to the server at once. The answer to this in Redis is to use a transaction block, meaning that either both or neither of the commands get through.

In redis-py , Pipeline is a transactional pipeline class by default. This means that, even though the class is actually named for something else (pipelining), it can be used to create a transaction block also.

In Redis, a transaction starts with MULTI and ends with EXEC :

 1127.0.0.1:6379> MULTI
 2127.0.0.1:6379> HINCRBY 56854717 quantity -1
 3127.0.0.1:6379> HINCRBY 56854717 npurchased 1
 4127.0.0.1:6379> EXEC

MULTI (Line 1) marks the start of the transaction, and EXEC (Line 4) marks the end. Everything in between is executed as one all-or-nothing buffered sequence of commands. This means that it will be impossible to decrement quantity (Line 2) but then have the balancing npurchased increment operation fail (Line 3).

Let’s circle back to Step 3:we need to be aware of any changes that alter the inventory in between the first two steps.

Step 3 is the trickiest. Let’s say that there is one lone hat remaining in our inventory. In between the time that User A checks the quantity of hats remaining and actually processes their transaction, User B also checks the inventory and finds likewise that there is one hat listed in stock. Both users will be allowed to purchase the hat, but we have 1 hat to sell, not 2, so we’re on the hook and one user is out of their money. Not good.

Redis has a clever answer for the dilemma in Step 3:it’s called optimistic locking , and is different than how typical locking works in an RDBMS such as PostgreSQL. Optimistic locking, in a nutshell, means that the calling function (client) does not acquire a lock, but rather monitors for changes in the data it is writing to during the time it would have held a lock . If there’s a conflict during that time, the calling function simply tries the whole process again.

You can effect optimistic locking by using the WATCH command (.watch() in redis-py ), which provides a check-and-set behavior.

Let’s introduce a big chunk of code and walk through it afterwards step by step. You can picture buyitem() as being called any time a user clicks on a Buy Now or Purchase pulsante. Its purpose is to confirm the item is in stock and take an action based on that result, all in a safe manner that looks out for race conditions and retries if one is detected:

 1import logging
 2import redis
 3
 4logging.basicConfig()
 5
 6class OutOfStockError(Exception):
 7    """Raised when PyHats.com is all out of today's hottest hat"""
 8
 9def buyitem(r: redis.Redis, itemid: int) -> None:
10    with r.pipeline() as pipe:
11        error_count = 0
12        while True:
13            try:
14                # Get available inventory, watching for changes
15                # related to this itemid before the transaction
16                pipe.watch(itemid)
17                nleft: bytes = r.hget(itemid, "quantity")
18                if nleft > b"0":
19                    pipe.multi()
20                    pipe.hincrby(itemid, "quantity", -1)
21                    pipe.hincrby(itemid, "npurchased", 1)
22                    pipe.execute()
23                    break
24                else:
25                    # Stop watching the itemid and raise to break out
26                    pipe.unwatch()
27                    raise OutOfStockError(
28                        f"Sorry, {itemid} is out of stock!"
29                    )
30            except redis.WatchError:
31                # Log total num. of errors by this user to buy this item,
32                # then try the same process again of WATCH/HGET/MULTI/EXEC
33                error_count += 1
34                logging.warning(
35                    "WatchError #%d: %s; retrying",
36                    error_count, itemid
37                )
38    return None

The critical line occurs at Line 16 with pipe.watch(itemid) , which tells Redis to monitor the given itemid for any changes to its value. The program checks the inventory through the call to r.hget(itemid, "quantity") , in Line 17:

16pipe.watch(itemid)
17nleft: bytes = r.hget(itemid, "quantity")
18if nleft > b"0":
19    # Item in stock. Proceed with transaction.

If the inventory gets touched during this short window between when the user checks the item stock and tries to purchase it, then Redis will return an error, and redis-py will raise a WatchError (Line 30). That is, if any of the hash pointed to by itemid changes after the .hget() call but before the subsequent .hincrby() calls in Lines 20 and 21, then we’ll re-run the whole process in another iteration of the while True loop as a result.

This is the “optimistic” part of the locking:rather than letting the client have a time-consuming total lock on the database through the getting and setting operations, we leave it up to Redis to notify the client and user only in the case that calls for a retry of the inventory check.

One key here is in understanding the difference between client-side and server-side operations:

nleft = r.hget(itemid, "quantity")

This Python assignment brings the result of r.hget() client-side. Conversely, methods that you call on pipe effectively buffer all of the commands into one, and then send them to the server in a single request:

16pipe.multi()
17pipe.hincrby(itemid, "quantity", -1)
18pipe.hincrby(itemid, "npurchased", 1)
19pipe.execute()

No data comes back to the client side in the middle of the transactional pipeline. You need to call .execute() (Line 19) to get the sequence of results back all at once.

Even though this block contains two commands, it consists of exactly one round-trip operation from client to server and back.

This means that the client can’t immediately use the result of pipe.hincrby(itemid, "quantity", -1) , from Line 20, because methods on a Pipeline return just the pipe instance itself. We haven’t asked anything from the server at this point. While normally .hincrby() returns the resulting value, you can’t immediately reference it on the client side until the entire transaction is completed.

There’s a catch-22:this is also why you can’t put the call to .hget() into the transaction block. If you did this, then you’d be unable to know if you want to increment the npurchased field yet, since you can’t get real-time results from commands that are inserted into a transactional pipeline.

Finally, if the inventory sits at zero, then we UNWATCH the item ID and raise an OutOfStockError (Line 27), ultimately displaying that coveted Sold Out page that will make our hat buyers desperately want to buy even more of our hats at ever more outlandish prices:

24else:
25    # Stop watching the itemid and raise to break out
26    pipe.unwatch()
27    raise OutOfStockError(
28        f"Sorry, {itemid} is out of stock!"
29    )

Here’s an illustration. Keep in mind that our starting quantity is 199 for hat 56854717 since we called .hincrby() sopra. Let’s mimic 3 purchases, which should modify the quantity and npurchased campi:

>>> buyitem(r, "hat:56854717")
>>> buyitem(r, "hat:56854717")
>>> buyitem(r, "hat:56854717")
>>> r.hmget("hat:56854717", "quantity", "npurchased")  # Hash multi-get
[b'196', b'4']

Now, we can fast-forward through more purchases, mimicking a stream of purchases until the stock depletes to zero. Again, picture these coming from a whole bunch of different clients rather than just one Redis instance:

>>> # Buy remaining 196 hats for item 56854717 and deplete stock to 0
>>> for _ in range(196):
...     buyitem(r, "hat:56854717")
>>> r.hmget("hat:56854717", "quantity", "npurchased")
[b'0', b'200']

Now, when some poor user is late to the game, they should be met with an OutOfStockError that tells our application to render an error message page on the frontend:

>>> buyitem(r, "hat:56854717")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 20, in buyitem
__main__.OutOfStockError: Sorry, hat:56854717 is out of stock!

Looks like it’s time to restock.

Using Key Expiry

Let’s introduce key expiry , which is another distinguishing feature in Redis. When you expire a key, that key and its corresponding value will be automatically deleted from the database after a certain number of seconds or at a certain timestamp.

In redis-py , one way that you can accomplish this is through .setex() , which lets you set a basic string:string key-value pair with an expiration:

 1>>> from datetime import timedelta
 2
 3>>> # setex: "SET" with expiration
 4>>> r.setex(
 5...     "runner",
 6...     timedelta(minutes=1),
 7...     value="now you see me, now you don't"
 8... )
 9True

You can specify the second argument as a number in seconds or a timedelta object, as in Line 6 above. I like the latter because it seems less ambiguous and more deliberate.

There are also methods (and corresponding Redis commands, of course) to get the remaining lifetime (time-to-live ) of a key that you’ve set to expire:

>>> r.ttl("runner")  # "Time To Live", in seconds
58
>>> r.pttl("runner")  # Like ttl, but milliseconds
54368

Below, you can accelerate the window until expiration, and then watch the key expire, after which r.get() will return None and .exists() will return 0 :

>>> r.get("runner")  # Not expired yet
b"now you see me, now you don't"

>>> r.expire("runner", timedelta(seconds=3))  # Set new expire window
True
>>> # Pause for a few seconds
>>> r.get("runner")
>>> r.exists("runner")  # Key & value are both gone (expired)
0

The table below summarizes commands related to key-value expiration, including the ones covered above. The explanations are taken directly from redis-py method docstrings:

PyHats.com, Part 2

A few days after its debut, PyHats.com has attracted so much hype that some enterprising users are creating bots to buy hundreds of items within seconds, which you’ve decided isn’t good for the long-term health of your hat business.

Now that you’ve seen how to expire keys, let’s put it to use on the backend of PyHats.com.

We’re going to create a new Redis client that acts as a consumer (or watcher) and processes a stream of incoming IP addresses, which in turn may come from multiple HTTPS connections to the website’s server.

The watcher’s goal is to monitor a stream of IP addresses from multiple sources, keeping an eye out for a flood of requests from a single address within a suspiciously short amount of time.

Some middleware on the website server pushes all incoming IP addresses into a Redis list with .lpush() . Here’s a crude way of mimicking some incoming IPs, using a fresh Redis database:

>>> r = redis.Redis(db=5)
>>> r.lpush("ips", "51.218.112.236")
1
>>> r.lpush("ips", "90.213.45.98")
2
>>> r.lpush("ips", "115.215.230.176")
3
>>> r.lpush("ips", "51.218.112.236")
4

As you can see, .lpush() returns the length of the list after the push operation succeeds. Each call of .lpush() puts the IP at the beginning of the Redis list that is keyed by the string "ips" .

In this simplified simulation, the requests are all technically from the same client, but you can think of them as potentially coming from many different clients and all being pushed to the same database on the same Redis server.

Now, open up a new shell tab or window and launch a new Python REPL. In this shell, you’ll create a new client that serves a very different purpose than the rest, which sits in an endless while True loop and does a blocking left-pop BLPOP call on the ips list, processing each address:

 1# New shell window or tab
 2
 3import datetime
 4import ipaddress
 5
 6import redis
 7
 8# Where we put all the bad egg IP addresses
 9blacklist = set()
10MAXVISITS = 15
11
12ipwatcher = redis.Redis(db=5)
13
14while True:
15    _, addr = ipwatcher.blpop("ips")
16    addr = ipaddress.ip_address(addr.decode("utf-8"))
17    now = datetime.datetime.utcnow()
18    addrts = f"{addr}:{now.minute}"
19    n = ipwatcher.incrby(addrts, 1)
20    if n >= MAXVISITS:
21        print(f"Hat bot detected!:  {addr}")
22        blacklist.add(addr)
23    else:
24        print(f"{now}:  saw {addr}")
25    _ = ipwatcher.expire(addrts, 60)

Let’s walk through a few important concepts.

The ipwatcher acts like a consumer, sitting around and waiting for new IPs to be pushed on the "ips" Redis list. It receives them as bytes , such as b”51.218.112.236”, and makes them into a more proper address object with the ipaddress module:

15_, addr = ipwatcher.blpop("ips")
16addr = ipaddress.ip_address(addr.decode("utf-8"))

Then you form a Redis string key using the address and minute of the hour at which the ipwatcher saw the address, incrementing the corresponding count by 1 and getting the new count in the process:

17now = datetime.datetime.utcnow()
18addrts = f"{addr}:{now.minute}"
19n = ipwatcher.incrby(addrts, 1)

If the address has been seen more than MAXVISITS , then it looks as if we have a PyHats.com web scraper on our hands trying to create the next tulip bubble. Alas, we have no choice but to give this user back something like a dreaded 403 status code.

We use ipwatcher.expire(addrts, 60) to expire the (address minute) combination 60 seconds from when it was last seen. This is to prevent our database from becoming clogged up with stale one-time page viewers.

If you execute this code block in a new shell, you should immediately see this output:

2019-03-11 15:10:41.489214:  saw 51.218.112.236
2019-03-11 15:10:41.490298:  saw 115.215.230.176
2019-03-11 15:10:41.490839:  saw 90.213.45.98
2019-03-11 15:10:41.491387:  saw 51.218.112.236

The output appears right away because those four IPs were sitting in the queue-like list keyed by "ips" , waiting to be pulled out by our ipwatcher . Using .blpop() (or the BLPOP command) will block until an item is available in the list, then pops it off. It behaves like Python’s Queue.get() , which also blocks until an item is available.

Besides just spitting out IP addresses, our ipwatcher has a second job. For a given minute of an hour (minute 1 through minute 60), ipwatcher will classify an IP address as a hat-bot if it sends 15 or more GET requests in that minute.

Switch back to your first shell and mimic a page scraper that blasts the site with 20 requests in a few milliseconds:

for _ in range(20):
    r.lpush("ips", "104.174.118.18")

Finally, toggle back to the second shell holding ipwatcher , and you should see an output like this:

2019-03-11 15:15:43.041363:  saw 104.174.118.18
2019-03-11 15:15:43.042027:  saw 104.174.118.18
2019-03-11 15:15:43.042598:  saw 104.174.118.18
2019-03-11 15:15:43.043143:  saw 104.174.118.18
2019-03-11 15:15:43.043725:  saw 104.174.118.18
2019-03-11 15:15:43.044244:  saw 104.174.118.18
2019-03-11 15:15:43.044760:  saw 104.174.118.18
2019-03-11 15:15:43.045288:  saw 104.174.118.18
2019-03-11 15:15:43.045806:  saw 104.174.118.18
2019-03-11 15:15:43.046318:  saw 104.174.118.18
2019-03-11 15:15:43.046829:  saw 104.174.118.18
2019-03-11 15:15:43.047392:  saw 104.174.118.18
2019-03-11 15:15:43.047966:  saw 104.174.118.18
2019-03-11 15:15:43.048479:  saw 104.174.118.18
Hat bot detected!:  104.174.118.18
Hat bot detected!:  104.174.118.18
Hat bot detected!:  104.174.118.18
Hat bot detected!:  104.174.118.18
Hat bot detected!:  104.174.118.18
Hat bot detected!:  104.174.118.18

Now, Ctrl +C out of the while True loop and you’ll see that the offending IP has been added to your blacklist:

>>> blacklist
{IPv4Address('104.174.118.18')}

Can you find the defect in this detection system? The filter checks the minute as .minute rather than the last 60 seconds (a rolling minute). Implementing a rolling check to monitor how many times a user has been seen in the last 60 seconds would be trickier. There’s a crafty solution using using Redis’ sorted sets at ClassDojo. Josiah Carlson’s Redis in Action also presents a more elaborate and general-purpose example of this section using an IP-to-location cache table.

Persistence and Snapshotting

One of the reasons that Redis is so fast in both read and write operations is that the database is held in memory (RAM) on the server. However, a Redis database can also be stored (persisted) to disk in a process called snapshotting. The point behind this is to keep a physical backup in binary format so that data can be reconstructed and put back into memory when needed, such as at server startup.

You already enabled snapshotting without knowing it when you set up basic configuration at the beginning of this tutorial with the save option:

# /etc/redis/6379.conf

port              6379
daemonize         yes
save              60 1
bind              127.0.0.1
tcp-keepalive     300
dbfilename        dump.rdb
dir               ./
rdbcompression    yes

The format is save <seconds> <changes> . This tells Redis to save the database to disk if both the given number of seconds and number of write operations against the database occurred. In this case, we’re telling Redis to save the database to disk every 60 seconds if at least one modifying write operation occurred in that 60-second timespan. This is a fairly aggressive setting versus the sample Redis config file, which uses these three save directives:

# Default redis/redis.conf
save 900 1
save 300 10
save 60 10000

An RDB snapshot is a full (rather than incremental) point-in-time capture of the database. (RDB refers to a Redis Database File.) We also specified the directory and file name of the resulting data file that gets written:

# /etc/redis/6379.conf

port              6379
daemonize         yes
save              60 1
bind              127.0.0.1
tcp-keepalive     300
dbfilename        dump.rdb
dir               ./
rdbcompression    yes

This instructs Redis to save to a binary data file called dump.rdb in the current working directory of wherever redis-server was executed from:

$ file -b dump.rdb
data

You can also manually invoke a save with the Redis command BGSAVE :

127.0.0.1:6379> BGSAVE
Background saving started

The “BG” in BGSAVE indicates that the save occurs in the background. This option is available in a redis-py method as well:

>>> r.lastsave()  # Redis command: LASTSAVE
datetime.datetime(2019, 3, 10, 21, 56, 50)
>>> r.bgsave()
True
>>> r.lastsave()
datetime.datetime(2019, 3, 10, 22, 4, 2)

This example introduces another new command and method, .lastsave() . In Redis, it returns the Unix timestamp of the last DB save, which Python gives back to you as a datetime oggetto. Above, you can see that the r.lastsave() result changes as a result of r.bgsave() .

r.lastsave() will also change if you enable automatic snapshotting with the save configuration option.

To rephrase all of this, there are two ways to enable snapshotting:

1. Explicitly, through the Redis command BGSAVE or redis-py method .bgsave()
2. Implicitly, through the save configuration option (which you can also set with .config_set() in redis-py )

RDB snapshotting is fast because the parent process uses the fork() system call to pass off the time-intensive write to disk to a child process, so that the parent process can continue on its way. This is what the background in BGSAVE refers to.

There’s also SAVE (.save() in redis-py ), but this does a synchronous (blocking) save rather than using fork() , so you shouldn’t use it without a specific reason.

Even though .bgsave() occurs in the background, it’s not without its costs. The time for fork() itself to occur can actually be substantial if the Redis database is large enough in the first place.

If this is a concern, or if you can’t afford to miss even a tiny slice of data lost due to the periodic nature of RDB snapshotting, then you should look into the append-only file (AOF) strategy that is an alternative to snapshotting. AOF copies Redis commands to disk in real time, allowing you to do a literal command-based reconstruction by replaying these commands.

Serialization Workarounds

Let’s get back to talking about Redis data structures. With its hash data structure, Redis in effect supports nesting one level deep:

127.0.0.1:6379> hset mykey field1 value1

The Python client equivalent would look like this:

r.hset("mykey", "field1", "value1")

Here, you can think of "field1": "value1" as being the key-value pair of a Python dict, {"field1": "value1"} , while mykey is the top-level key:

But what if you want the value of this dictionary (the Redis hash) to contain something other than a string, such as a list or nested dictionary with strings as values?

Here’s an example using some JSON-like data to make the distinction clearer:

restaurant_484272 = {
    "name": "Ravagh",
    "type": "Persian",
    "address": {
        "street": {
            "line1": "11 E 30th St",
            "line2": "APT 1",
        },
        "city": "New York",
        "state": "NY",
        "zip": 10016,
    }
}

Say that we want to set a Redis hash with the key 484272 and field-value pairs corresponding to the key-value pairs from restaurant_484272 . Redis does not support this directly, because restaurant_484272 is nested:

>>> r.hmset(484272, restaurant_484272)
Traceback (most recent call last):
# ...
redis.exceptions.DataError: Invalid input of type: 'dict'.
Convert to a byte, string or number first.

You can in fact make this work with Redis. There are two different ways to mimic nested data in redis-py and Redis:

1. Serialize the values into a string with something like json.dumps()
2. Use a delimiter in the key strings to mimic nesting in the values

Let’s take a look at an example of each.

Option 1:Serialize the Values Into a String

You can use json.dumps() to serialize the dict into a JSON-formatted string:

>>> import json
>>> r.set(484272, json.dumps(restaurant_484272))
True

If you call .get() , the value you get back will be a bytes object, so don’t forget to deserialize it to get back the original object. json.dumps() and json.loads() are inverses of each other, for serializing and deserializing data, respectively:

>>> from pprint import pprint
>>> pprint(json.loads(r.get(484272)))
{'address': {'city': 'New York',
             'state': 'NY',
             'street': '11 E 30th St',
             'zip': 10016},
 'name': 'Ravagh',
 'type': 'Persian'}

This applies to any serialization protocol, with another common choice being yaml :

>>> import yaml  # python -m pip install PyYAML
>>> yaml.dump(restaurant_484272)
'address: {city: New York, state: NY, street: 11 E 30th St, zip: 10016}\nname: Ravagh\ntype: Persian\n'

No matter what serialization protocol you choose to go with, the concept is the same:you’re taking an object that is unique to Python and converting it to a bytestring that is recognized and exchangeable across multiple languages.

Option 2:Use a Delimiter in Key Strings

There’s a second option that involves mimicking “nestedness” by concatenating multiple levels of keys in a Python dict . This consists of flattening the nested dictionary through recursion, so that each key is a concatenated string of keys, and the values are the deepest-nested values from the original dictionary. Consider our dictionary object restaurant_484272 :

restaurant_484272 = {
    "name": "Ravagh",
    "type": "Persian",
    "address": {
        "street": {
            "line1": "11 E 30th St",
            "line2": "APT 1",
        },
        "city": "New York",
        "state": "NY",
        "zip": 10016,
    }
}

We want to get it into this form:

{
    "484272:name":                     "Ravagh",
    "484272:type":                     "Persian",
    "484272:address:street:line1":     "11 E 30th St",
    "484272:address:street:line2":     "APT 1",
    "484272:address:city":             "New York",
    "484272:address:state":            "NY",
    "484272:address:zip":              "10016",
}

That’s what setflat_skeys() below does, with the added feature that it does inplace .set() operations on the Redis instance itself rather than returning a copy of the input dictionary:

 1from collections.abc import MutableMapping
 2
 3def setflat_skeys(
 4    r: redis.Redis,
 5    obj: dict,
 6    prefix: str,
 7    delim: str = ":",
 8    *,
 9    _autopfix=""
10) -> None:
11    """Flatten `obj` and set resulting field-value pairs into `r`.
12
13    Calls `.set()` to write to Redis instance inplace and returns None.
14
15    `prefix` is an optional str that prefixes all keys.
16    `delim` is the delimiter that separates the joined, flattened keys.
17    `_autopfix` is used in recursive calls to created de-nested keys.
18
19    The deepest-nested keys must be str, bytes, float, or int.
20    Otherwise a TypeError is raised.
21    """
22    allowed_vtypes = (str, bytes, float, int)
23    for key, value in obj.items():
24        key = _autopfix + key
25        if isinstance(value, allowed_vtypes):
26            r.set(f"{prefix}{delim}{key}", value)
27        elif isinstance(value, MutableMapping):
28            setflat_skeys(
29                r, value, prefix, delim, _autopfix=f"{key}{delim}"
30            )
31        else:
32            raise TypeError(f"Unsupported value type: {type(value)}")

The function iterates over the key-value pairs of obj , first checking the type of the value (Line 25) to see if it looks like it should stop recursing further and set that key-value pair. Otherwise, if the value looks like a dict (Line 27), then it recurses into that mapping, adding the previously seen keys as a key prefix (Line 28).

Let’s see it at work:

>>> r.flushdb()  # Flush database: clear old entries
>>> setflat_skeys(r, restaurant_484272, 484272)

>>> for key in sorted(r.keys("484272*")):  # Filter to this pattern
...     print(f"{repr(key):35}{repr(r.get(key)):15}")
...
b'484272:address:city'             b'New York'
b'484272:address:state'            b'NY'
b'484272:address:street:line1'     b'11 E 30th St'
b'484272:address:street:line2'     b'APT 1'
b'484272:address:zip'              b'10016'
b'484272:name'                     b'Ravagh'
b'484272:type'                     b'Persian'

>>> r.get("484272:address:street:line1")
b'11 E 30th St'

The final loop above uses r.keys("484272*") , where "484272*" is interpreted as a pattern and matches all keys in the database that begin with "484272" .

Notice also how setflat_skeys() calls just .set() rather than .hset() , because we’re working with plain string:string field-value pairs, and the 484272 ID key is prepended to each field string.

Encryption

Another trick to help you sleep well at night is to add symmetric encryption before sending anything to a Redis server. Consider this as an add-on to the security that you should make sure is in place by setting proper values in your Redis configuration. The example below uses the cryptography package:

$ python -m pip install cryptography

To illustrate, pretend that you have some sensitive cardholder data (CD) that you never want to have sitting around in plaintext on any server, no matter what. Before caching it in Redis, you can serialize the data and then encrypt the serialized string using Fernet:

>>> import json
>>> from cryptography.fernet import Fernet

>>> cipher = Fernet(Fernet.generate_key())
>>> info = {
...     "cardnum": 2211849528391929,
...     "exp": [2020, 9],
...     "cv2": 842,
... }

>>> r.set(
...     "user:1000",
...     cipher.encrypt(json.dumps(info).encode("utf-8"))
... )

>>> r.get("user:1000")
b'gAAAAABcg8-LfQw9TeFZ1eXbi'  # ... [truncated]

>>> cipher.decrypt(r.get("user:1000"))
b'{"cardnum": 2211849528391929, "exp": [2020, 9], "cv2": 842}'

>>> json.loads(cipher.decrypt(r.get("user:1000")))
{'cardnum': 2211849528391929, 'exp': [2020, 9], 'cv2': 842}

Because info contains a value that is a list , you’ll need to serialize this into a string that’s acceptable by Redis. (You could use json , yaml , or any other serialization for this.) Next, you encrypt and decrypt that string using the cipher oggetto. You need to deserialize the decrypted bytes using json.loads() so that you can get the result back into the type of your initial input, a dict .

Note :Fernet uses AES 128 encryption in CBC mode. See the cryptography docs for an example of using AES 256. Whatever you choose to do, use cryptography , not pycrypto (imported as Crypto ), which is no longer actively maintained.

If security is paramount, encrypting strings before they make their way across a network connection is never a bad idea.

Compression

One last quick optimization is compression. If bandwidth is a concern or you’re cost-conscious, you can implement a lossless compression and decompression scheme when you send and receive data from Redis. Here’s an example using the bzip2 compression algorithm, which in this extreme case cuts down on the number of bytes sent across the connection by a factor of over 2,000:

 1>>> import bz2
 2
 3>>> blob = "i have a lot to talk about" * 10000
 4>>> len(blob.encode("utf-8"))
 5260000
 6
 7>>> # Set the compressed string as value
 8>>> r.set("msg:500", bz2.compress(blob.encode("utf-8")))
 9>>> r.get("msg:500")
10b'BZh91AY&SY\xdaM\x1eu\x01\x11o\x91\x80@\x002l\x87\'  # ... [truncated]
11>>> len(r.get("msg:500"))
12122
13>>> 260_000 / 122  # Magnitude of savings
142131.1475409836066
15
16>>> # Get and decompress the value, then confirm it's equal to the original
17>>> rblob = bz2.decompress(r.get("msg:500")).decode("utf-8")
18>>> rblob == blob
19True

The way that serialization, encryption, and compression are related here is that they all occur client-side. You do some operation on the original object on the client-side that ends up making more efficient use of Redis once you send the string over to the server. The inverse operation then happens again on the client side when you request whatever it was that you sent to the server in the first place.

Using Hiredis

It’s common for a client library such as redis-py to follow a protocol in how it is built. In this case, redis-py implements the REdis Serialization Protocol, or RESP.

Part of fulfilling this protocol consists of converting some Python object in a raw bytestring, sending it to the Redis server, and parsing the response back into an intelligible Python object.

For example, the string response “OK” would come back as "+OK\r\n" , while the integer response 1000 would come back as ":1000\r\n" . This can get more complex with other data types such as RESP arrays.

A parser is a tool in the request-response cycle that interprets this raw response and crafts it into something recognizable to the client. redis-py ships with its own parser class, PythonParser , which does the parsing in pure Python. (See .read_response() if you’re curious.)

However, there’s also a C library, Hiredis, that contains a fast parser that can offer significant speedups for some Redis commands such as LRANGE . You can think of Hiredis as an optional accelerator that it doesn’t hurt to have around in niche cases.

All that you have to do to enable redis-py to use the Hiredis parser is to install its Python bindings in the same environment as redis-py :

$ python -m pip install hiredis

What you’re actually installing here is hiredis-py , which is a Python wrapper for a portion of the hiredis C library.

The nice thing is that you don’t really need to call hiredis te stesso. Just pip install it, and this will let redis-py see that it’s available and use its HiredisParser instead of PythonParser .

Internally, redis-py will attempt to import hiredis , and use a HiredisParser class to match it, but will fall back to its PythonParser instead, which may be slower in some cases:

# redis/utils.py
try:
    import hiredis
    HIREDIS_AVAILABLE = True
except ImportError:
    HIREDIS_AVAILABLE = False


# redis/connection.py
if HIREDIS_AVAILABLE:
    DefaultParser = HiredisParser
else:
    DefaultParser = PythonParser

Using Enterprise Redis Applications

While Redis itself is open-source and free, several managed services have sprung up that offer a data store with Redis as the core and some additional features built on top of the open-source Redis server:

• Amazon ElastiCache for Redis : This is a web service that lets you host a Redis server in the cloud, which you can connect to from an Amazon EC2 instance. For full setup instructions, you can walk through Amazon’s ElastiCache for Redis launch page.

• Microsoft’s Azure Cache for Redis : This is another capable enterprise-grade service that lets you set up a customizable, secure Redis instance in the cloud.

The designs of the two have some commonalities. You typically specify a custom name for your cache, which is embedded as part of a DNS name, such as demo.abcdef.xz.0009.use1.cache.amazonaws.com (AWS) or demo.redis.cache.windows.net (Azure).

Once you’re set up, here are a few quick tips on how to connect.

From the command line, it’s largely the same as in our earlier examples, but you’ll need to specify a host with the h flag rather than using the default localhost. For Amazon AWS , execute the following from your instance shell:

$ export REDIS_ENDPOINT="demo.abcdef.xz.0009.use1.cache.amazonaws.com"
$ redis-cli -h $REDIS_ENDPOINT

For Microsoft Azure , you can use a similar call. Azure Cache for Redis uses SSL (port 6380) by default rather than port 6379, allowing for encrypted communication to and from Redis, which can’t be said of TCP. All that you’ll need to supply in addition is a non-default port and access key:

$ export REDIS_ENDPOINT="demo.redis.cache.windows.net"
$ redis-cli -h $REDIS_ENDPOINT -p 6380 -a <primary-access-key>

The -h flag specifies a host, which as you’ve seen is 127.0.0.1 (localhost) by default.

When you’re using redis-py in Python, it’s always a good idea to keep sensitive variables out of Python scripts themselves, and to be careful about what read and write permissions you afford those files. The Python version would look like this:

>>> import os
>>> import redis

>>> # Specify a DNS endpoint instead of the default localhost
>>> os.environ["REDIS_ENDPOINT"]
'demo.abcdef.xz.0009.use1.cache.amazonaws.com'
>>> r = redis.Redis(host=os.environ["REDIS_ENDPOINT"])

Questo è tutto ciò che c'è da fare. Besides specifying a different host , you can now call command-related methods such as r.get() as normal.

Note :If you want to use solely the combination of redis-py and an AWS or Azure Redis instance, then you don’t really need to install and make Redis itself locally on your machine, since you don’t need either redis-cli or redis-server .

If you’re deploying a medium- to large-scale production application where Redis plays a key role, then going with AWS or Azure’s service solutions can be a scalable, cost-effective, and security-conscious way to operate.

Wrapping Up

That concludes our whirlwind tour of accessing Redis through Python, including installing and using the Redis REPL connected to a Redis server and using redis-py in real-life examples. Here’s some of what you learned:

• redis-py lets you do (almost) everything that you can do with the Redis CLI through an intuitive Python API.
• Mastering topics such as persistence, serialization, encryption, and compression lets you use Redis to its full potential.
• Redis transactions and pipelines are essential parts of the library in more complex situations.
• Enterprise-level Redis services can help you smoothly use Redis in production.

Redis has an extensive set of features, some of which we didn’t really get to cover here, including server-side Lua scripting, sharding, and master-slave replication. If you think that Redis is up your alley, then make sure to follow developments as it implements an updated protocol, RESP3.

Further Reading

Here are some resources that you can check out to learn more.

Books:

• Josiah Carlson: Redis in Action
• Karl Seguin: The Little Redis Book
• Luc Perkins et. al.: Seven Databases in Seven Weeks

Redis in use:

• Twitter: Real-Time Delivery Architecture at Twitter
• Spool: Redis bitmaps – Fast, easy, realtime metrics
• 3scale: Having fun with Redis Replication between Amazon and Rackspace
• Instagram: Storing hundreds of millions of simple key-value pairs in Redis
• Craigslist: Redis Sharding at Craigslist
• Disqus: Redis at Disqus

Other:

• Digital Ocean: How To Secure Your Redis Installation
• AWS: ElastiCache for Redis User Guide
• Microsoft: Azure Cache for Redis
• Cheatography: Redis Cheat Sheet
• ClassDojo: Better Rate Limiting With Redis Sorted Sets
• antirez (Salvatore Sanfilippo): Redis persistence demystified
• Martin Kleppmann: How to do distributed locking
• HighScalability: 11 Common Web Use Cases Solved in Redis