Comment utiliser Redis avec Python

Dans ce didacticiel, vous apprendrez à utiliser Python avec Redis (prononcé RED-iss, ou peut-être REE-diss ou Red-DEES, selon la personne à qui vous demandez), qui est un magasin de valeur clé en mémoire ultra-rapide qui peut être utilisé pour n'importe quoi de A à Z. Voici ce que Sept bases de données en sept semaines , un livre populaire sur les bases de données, a à dire sur Redis :

Ce n'est pas simplement facile à utiliser; c'est un bonheur. Si une API est UX pour les programmeurs, alors Redis devrait être au Musée d'Art Moderne aux côtés du Mac Cube.

…

Et en matière de vitesse, Redis est difficile à battre. Les lectures sont rapides et les écritures sont encore plus rapides, gérant jusqu'à 100 000 SET opérations par seconde par certains repères. (Source)

Intrigué ? Ce didacticiel est conçu pour le programmeur Python qui peut avoir peu ou pas d'expérience Redis. Nous aborderons deux outils à la fois et présenterons Redis lui-même ainsi que l'une de ses bibliothèques clientes Python, redis-py .

redis-py (que vous importez en tant que redis ) est l'un des nombreux clients Python pour Redis, mais il a la particularité d'être présenté comme "actuellement la voie à suivre pour Python" par les développeurs Redis eux-mêmes. Il vous permet d'appeler des commandes Redis à partir de Python et de récupérer des objets Python familiers en retour.

Dans ce didacticiel, vous couvrirez :

• Installer Redis à partir de la source et comprendre l'objectif des binaires résultants
• Apprendre une petite tranche de Redis lui-même, y compris sa syntaxe, son protocole et sa conception
• Maîtriser redis-py tout en voyant un aperçu de la façon dont il implémente le protocole de Redis
• Configuration et communication avec une instance de serveur Amazon ElastiCache Redis

Téléchargement gratuit : Obtenez un exemple de chapitre de Python Tricks :le livre qui vous montre les meilleures pratiques de Python avec des exemples simples que vous pouvez appliquer instantanément pour écrire du code + Pythonic plus beau.

Installer Redis à partir de la source

Comme l'a dit mon arrière-arrière-grand-père, rien ne fait mieux que l'installation à partir de la source. Cette section vous guidera à travers le téléchargement, la création et l'installation de Redis. Je promets que cela ne fera pas de mal !

Remarque :Cette section est orientée vers l'installation sur Mac OS X ou Linux. Si vous utilisez Windows, il existe un fork Microsoft de Redis qui peut être installé en tant que service Windows. Qu'il suffise de dire que Redis en tant que programme vit plus confortablement sur une machine Linux et que la configuration et l'utilisation sous Windows peuvent être délicates.

Tout d'abord, téléchargez le code source Redis sous forme d'archive :

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

Ensuite, passez à root et extrayez le code source de l'archive dans /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

En option, vous pouvez maintenant supprimer l'archive elle-même :

$ rm redis-stable.tar.gz

Cela vous laissera avec un référentiel de code source à /usr/local/lib/redis-stable/ . Redis est écrit en C, vous devrez donc compiler, lier et installer avec le make utilitaire :

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

Utilisation de make install fait deux actions :

1. Le premier make La commande compile et lie le code source.

2. Le make install part prend les binaires et les copie dans /usr/local/bin/ afin que vous puissiez les exécuter de n'importe où (en supposant que /usr/local/bin/ est dans PATH ).

Voici toutes les étapes jusqu'à présent :

$ 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

À ce stade, prenez un moment pour confirmer que Redis est dans votre PATH et vérifiez sa version :

$ redis-cli --version
redis-cli 5.0.3

Si votre shell ne trouve pas redis-cli , vérifiez que /usr/local/bin/ est sur votre PATH variable d'environnement, et ajoutez-la si ce n'est pas le cas.

En plus de redis-cli , make install conduit en fait à placer une poignée de fichiers exécutables différents (et un lien symbolique) dans /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*

Bien que tous ces éléments aient une utilisation prévue, les deux qui vous intéresseront probablement le plus sont redis-cli et redis-server , que nous détaillerons sous peu. Mais avant d'en arriver là, il convient de configurer une configuration de base.

Configurer Redis

Redis est hautement configurable. Bien qu'il fonctionne correctement, prenons une minute pour définir quelques options de configuration simples liées à la persistance de la base de données et à la sécurité de base :

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

Maintenant, écrivez ce qui suit dans /etc/redis/6379.conf . Nous aborderons la signification de la plupart de ces éléments au fur et à mesure du didacticiel :

# /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 configuration de Redis est auto-documentée, avec l'exemple redis.conf fichier situé dans la source Redis pour votre plaisir de lecture. Si vous utilisez Redis dans un système de production, il est avantageux de bloquer toutes les distractions et de prendre le temps de lire cet exemple de fichier dans son intégralité pour vous familiariser avec les tenants et les aboutissants de Redis et affiner votre configuration.

Certains tutoriels, y compris des parties de la documentation de Redis, peuvent également suggérer d'exécuter le script Shell install_server.sh situé dans redis/utils/install_server.sh . Vous êtes certainement le bienvenu pour exécuter ceci comme une alternative plus complète à ce qui précède, mais prenez note de quelques points plus fins sur install_server.sh :

• Cela ne fonctionnera pas sur Mac OS X, uniquement sur Debian et Ubuntu Linux.
• Il injectera un ensemble plus complet d'options de configuration dans /etc/redis/6379.conf .
• Il écrira un init System V script vers /etc/init.d/redis_6379 cela vous permettra de faire sudo service redis_6379 start .

Le guide de démarrage rapide Redis contient également une section sur une configuration Redis plus appropriée, mais les options de configuration ci-dessus devraient être tout à fait suffisantes pour ce didacticiel et pour commencer.

Note de sécurité : Il y a quelques années, l'auteur de Redis a souligné des failles de sécurité dans les versions antérieures de Redis si aucune configuration n'était définie. Redis 3.2 (la version actuelle 5.0.3 en mars 2019) a pris des mesures pour empêcher cette intrusion, en définissant le protected-mode option sur yes par défaut.

Nous définissons explicitement bind 127.0.0.1 pour laisser Redis écouter les connexions uniquement à partir de l'interface localhost, bien que vous deviez étendre cette liste blanche dans un véritable serveur de production. Le point du protected-mode est une protection qui imitera ce comportement de liaison à l'hôte local si vous ne spécifiez rien d'autre sous le bind option.

Avec cela au carré, nous pouvons maintenant creuser dans l'utilisation de Redis lui-même.

Dix minutes environ avant Redis

Cette section vous fournira juste assez de connaissances sur Redis pour être dangereux, décrivant sa conception et son utilisation de base.

Mise en route

Redis a une architecture client-serveur et utilise un modèle demande-réponse . Cela signifie que vous (le client) vous connectez à un serveur Redis via une connexion TCP, sur le port 6379 par défaut. Vous demandez une action (comme une forme de lecture, d'écriture, d'obtention, de définition ou de mise à jour), et le serveur sert vous soutenez une réponse.

Il peut y avoir de nombreux clients qui parlent au même serveur, ce qui est vraiment ce qu'est Redis ou n'importe quelle application client-serveur. Chaque client effectue une lecture (généralement bloquante) sur un socket en attendant la réponse du serveur.

Le cli dans redis-cli signifie interface de ligne de commande , et le server dans redis-server est pour, eh bien, faire fonctionner un serveur. De la même manière que vous exécuteriez python en ligne de commande, vous pouvez exécuter redis-cli pour sauter dans un REPL interactif (Read Eval Print Loop) où vous pouvez exécuter des commandes client directement depuis le shell.

Cependant, vous devrez d'abord lancer redis-server afin que vous ayez un serveur Redis en cours d'exécution avec qui parler. Une façon courante de le faire en développement est de démarrer un serveur sur localhost (adresse IPv4 127.0.0.1 ), qui est la valeur par défaut, sauf si vous indiquez le contraire à Redis. Vous pouvez également passer redis-server le nom de votre fichier de configuration, ce qui revient à spécifier toutes ses paires clé-valeur en tant qu'arguments de ligne de commande :

$ 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

Nous définissons le daemonize option de configuration sur yes , de sorte que le serveur s'exécute en arrière-plan. (Sinon, utilisez --daemonize yes comme option de redis-server .)

Vous êtes maintenant prêt à lancer le REPL Redis. Entrez redis-cli sur votre ligne de commande. Vous verrez le host:port du serveur paire suivie d'un > invite :

127.0.0.1:6379>

Voici l'une des commandes Redis les plus simples, PING , qui teste simplement la connectivité au serveur et renvoie "PONG" si tout va bien :

127.0.0.1:6379> PING
PONG

Les commandes Redis ne sont pas sensibles à la casse, bien que leurs homologues Python ne le soient certainement pas.

Remarque : Comme autre contrôle d'intégrité, vous pouvez rechercher l'ID de processus du serveur Redis avec pgrep :

$ pgrep redis-server
26983

Pour tuer le serveur, utilisez pkill redis-server depuis la ligne de commande. Sur Mac OS X, vous pouvez également utiliser redis-cli shutdown .

Ensuite, nous utiliserons certaines des commandes Redis courantes et les comparerons à ce à quoi elles ressembleraient en Python pur.

Redis en tant que dictionnaire Python

Redis signifie Service de dictionnaire à distance .

"Tu veux dire, comme un dictionnaire Python?" vous pouvez demander.

Oui. D'une manière générale, il existe de nombreux parallèles que vous pouvez établir entre un dictionnaire Python (ou une table de hachage générique) et ce qu'est et fait Redis :

• Une base de données Redis contient key:value associe et prend en charge des commandes telles que GET , SET , et DEL , ainsi que plusieurs centaines de commandes supplémentaires.

• Redis clés sont toujours des chaînes.

• Valeurs Redis peut être un certain nombre de types de données différents. Nous aborderons certains des types de données de valeur les plus essentiels dans ce didacticiel :string , list , hashes , et sets . Certains types avancés incluent des éléments géospatiaux et le nouveau type de flux.

• De nombreuses commandes Redis fonctionnent en temps constant O(1), tout comme la récupération d'une valeur à partir d'un Python dict ou n'importe quelle table de hachage.

Le créateur de Redis, Salvatore Sanfilippo, n'aimerait probablement pas la comparaison d'une base de données Redis avec un Python dict plain-vanilla . Il appelle le projet un "serveur de structure de données" (plutôt qu'un magasin clé-valeur, tel que memcached) car, à son crédit, Redis prend en charge le stockage de types supplémentaires de clé :valeur types de données autres que string:string . Mais pour nos besoins ici, c'est une comparaison utile si vous êtes familier avec l'objet dictionnaire de Python.

Allons-y et apprenons par l'exemple. Notre première base de données de jouets (avec ID 0) sera une cartographie de pays :capitale , où nous utilisons SET pour définir des paires clé-valeur :

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 séquence d'instructions correspondante en Python pur ressemblerait à ceci :

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

Nous utilisons capitals.get("Japan") plutôt que capitals["Japan"] car Redis renverra nil plutôt qu'une erreur lorsqu'une clé n'est pas trouvée, ce qui est analogue à None de Python .

Redis vous permet également de définir et d'obtenir plusieurs paires clé-valeur en une seule commande, MSET et MGET , respectivement :

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 chose la plus proche en Python est avec dict.update() :

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

Nous utilisons .get() plutôt que .__getitem__() pour imiter le comportement de Redis consistant à renvoyer une valeur nulle lorsqu'aucune clé n'est trouvée.

Comme troisième exemple, le EXISTS commande fait ce que cela ressemble, c'est-à-dire vérifier si une clé existe :

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

Python a le in mot-clé pour tester la même chose, qui achemine vers dict.__contains__(key) :

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

Ces quelques exemples sont destinés à montrer, en utilisant Python natif, ce qui se passe à un niveau élevé avec quelques commandes Redis courantes. Il n'y a pas de composant client-serveur ici pour les exemples Python, et redis-py n'est pas encore entré dans l'image. Ceci est uniquement destiné à montrer la fonctionnalité Redis à titre d'exemple.

Voici un résumé des quelques commandes Redis que vous avez vues et de leurs équivalents Python fonctionnels :

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 bibliothèque client Python Redis, redis-py , que vous aborderez sous peu dans cet article, fait les choses différemment. Il encapsule une connexion TCP réelle à un serveur Redis et envoie des commandes brutes, sous forme d'octets sérialisés à l'aide du protocole de sérialisation REdis (RESP), au serveur. Il prend ensuite la réponse brute et l'analyse dans un objet Python tel que bytes , int , ou même datetime.datetime .

Remarque  :Jusqu'à présent, vous avez parlé au serveur Redis via le redis-cli interactif REPL. Vous pouvez également émettre des commandes directement, de la même manière que vous passeriez le nom d'un script au python exécutable, tel que python myscript.py .

Jusqu'à présent, vous avez vu quelques-uns des types de données fondamentaux de Redis, qui est un mappage de string:string . Bien que cette paire clé-valeur soit courante dans la plupart des magasins de clé-valeur, Redis propose un certain nombre d'autres types de valeur possibles, que vous verrez ensuite.

Plus de types de données en Python par rapport à Redis

Avant de lancer le redis-py Client Python, il est également utile d'avoir une compréhension de base de quelques types de données Redis supplémentaires. Pour être clair, toutes les clés Redis sont des chaînes. C'est la valeur que peuvent prendre les types de données (ou structures) en plus des valeurs de chaîne utilisées dans les exemples jusqu'à présent.

Un dièse est un mappage de string:string , appelé champ-valeur paires, qui se trouvent sous une clé de niveau supérieur :

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

Cela définit trois paires champ-valeur pour une clé , "realpython" . Si vous êtes habitué à la terminologie et aux objets de Python, cela peut prêter à confusion. Un hachage Redis est à peu près analogue à un Python dict qui est imbriqué à un niveau :

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

Les champs de Redis sont similaires aux clés Python de chaque paire clé-valeur imbriquée dans le dictionnaire interne ci-dessus. Redis réserve le terme clé pour la clé de base de données de niveau supérieur qui contient la structure de hachage elle-même.

Tout comme il y a MSET pour string:string de base paires clé-valeur, il y a aussi HMSET pour les hachages pour définir plusieurs paires dans l'objet valeur de hachage :

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"

Utilisation de HMSET est probablement un parallèle plus proche de la façon dont nous avons attribué les data à un dictionnaire imbriqué ci-dessus, plutôt que de définir chaque paire imbriquée comme cela se fait avec HSET .

Deux types de valeur supplémentaires sont des listes et ensembles , qui peut remplacer un hachage ou une chaîne en tant que valeur Redis. Ils sont en grande partie ce à quoi ils ressemblent, donc je ne prendrai pas votre temps avec des exemples supplémentaires. Les hachages, les listes et les ensembles ont chacun des commandes spécifiques à ce type de données donné, qui sont dans certains cas désignées par leur lettre initiale :

• Hachage : Les commandes pour opérer sur les hachages commencent par un H , comme HSET , HGET , ou HMSET .

• Ensembles : Les commandes à opérer sur les ensembles commencent par un S , comme SCARD , qui obtient le nombre d'éléments à la valeur définie correspondant à une clé donnée.

• Listes : Les commandes à opérer sur les listes commencent par un L ou R . Les exemples incluent LPOP et RPUSH . Le L ou R fait référence à quel côté de la liste est opéré. Quelques commandes de liste sont également précédées d'un B , ce qui signifie bloquer . Une opération bloquante ne laisse pas d'autres opérations l'interrompre pendant son exécution. Par exemple, BLPOP exécute un left-pop bloquant sur une structure de liste.

Remarque : Une caractéristique remarquable du type de liste de Redis est qu'il s'agit d'une liste liée plutôt que d'un tableau. Cela signifie que l'ajout est O(1) tandis que l'indexation à un numéro d'index arbitraire est O(N).

Voici une liste rapide des commandes spécifiques aux types de données string, hash, list et set dans Redis :

Ce tableau n'est pas une image complète des commandes et des types Redis. Il existe un assortiment de types de données plus avancés, tels que des éléments géospatiaux, des ensembles triés et HyperLogLog. Sur la page des commandes Redis, vous pouvez filtrer par groupe de structure de données. Il y a aussi le résumé des types de données et l'introduction aux types de données Redis.

Puisque nous allons passer à faire des choses en Python, vous pouvez maintenant effacer votre base de données de jouets avec FLUSHDB et quittez le redis-cli REPL :

127.0.0.1:6379> FLUSHDB
OK
127.0.0.1:6379> QUIT

Cela vous ramènera à votre invite de shell. Vous pouvez quitter redis-server s'exécute en arrière-plan, car vous en aurez également besoin pour le reste du didacticiel.

Utiliser redis-py :Redis en Python

Maintenant que vous maîtrisez certaines bases de Redis, il est temps de passer à redis-py , le client Python qui vous permet de communiquer avec Redis à partir d'une API Python conviviale.

Premiers pas

redis-py est une bibliothèque cliente Python bien établie qui vous permet de communiquer directement avec un serveur Redis via des appels Python :

$ python -m pip install redis

Ensuite, assurez-vous que votre serveur Redis est toujours opérationnel en arrière-plan. Vous pouvez vérifier avec pgrep redis-server , et si vous arrivez les mains vides, redémarrez un serveur local avec redis-server /etc/redis/6379.conf .

Passons maintenant à la partie centrée sur Python. Voici le "hello world" de redis-py :

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

Redis , utilisé dans la ligne 2, est la classe centrale du package et le cheval de bataille par lequel vous exécutez (presque) n'importe quelle commande Redis. La connexion et la réutilisation du socket TCP sont effectuées pour vous dans les coulisses, et vous appelez des commandes Redis à l'aide de méthodes sur l'instance de classe r .

Notez également que le type de l'objet renvoyé, b'Nassau' à la ligne 6, est le bytes de Python tapez, pas str . C'est bytes plutôt que str c'est le type de retour le plus courant dans redis-py , vous devrez donc peut-être appeler r.get("Bahamas").decode("utf-8") en fonction de ce que vous voulez réellement faire avec la chaîne d'octets renvoyée.

Le code ci-dessus vous semble-t-il familier ? Dans presque tous les cas, les méthodes correspondent au nom de la commande Redis qui fait la même chose. Ici, vous avez appelé r.mset() et r.get() , qui correspondent à MSET et GET dans l'API Redis native.

Cela signifie également que HGETALL devient r.hgetall() , PING devient r.ping() , etc. Il y a quelques exceptions, mais la règle vaut pour la grande majorité des commandes.

Bien que les arguments de la commande Redis se traduisent généralement par une signature de méthode d'apparence similaire, ils prennent des objets Python. Par exemple, l'appel à r.mset() dans l'exemple ci-dessus utilise un Python dict comme premier argument, plutôt qu'une séquence de chaînes d'octets.

Nous avons construit le Redis instance r sans arguments, mais il est fourni avec un certain nombre de paramètres si vous en avez besoin :

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

Vous pouvez voir que la valeur par défaut hostname:port la paire est localhost:6379 , ce qui est exactement ce dont nous avons besoin dans le cas de notre redis-server conservé localement exemple.

La db paramètre est le numéro de la base de données. Vous pouvez gérer plusieurs bases de données dans Redis à la fois, et chacune est identifiée par un nombre entier. Le nombre maximum de bases de données est de 16 par défaut.

Lorsque vous exécutez simplement redis-cli à partir de la ligne de commande, cela vous lance à la base de données 0. Utilisez le -n flag pour démarrer une nouvelle base de données, comme dans redis-cli -n 5 .

Types de clés autorisés

Une chose qu'il faut savoir est que redis-py nécessite que vous lui passiez des clés qui sont des bytes , str , int , ou float . (Il convertira les 3 derniers de ces types en bytes avant de les envoyer au serveur.)

Considérez un cas où vous souhaitez utiliser des dates de calendrier comme clés :

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

Vous devrez convertir explicitement le Python date objecter à str , ce que vous pouvez faire avec .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

Pour récapituler, Redis lui-même n'autorise que les chaînes comme clés. redis-py est un peu plus libéral dans les types Python qu'il accepte, bien qu'il convertisse finalement tout en octets avant de les envoyer à un serveur Redis.

Exemple :PyHats.com

Il est temps de sortir un exemple plus complet. Imaginons que nous ayons décidé de lancer un site Web lucratif, PyHats.com, qui vend des chapeaux scandaleusement hors de prix à tous ceux qui les achèteront, et que nous vous avons embauché pour créer le site.

Vous utiliserez Redis pour gérer une partie du catalogue de produits, de l'inventaire et de la détection du trafic de robots pour PyHats.com.

C'est le premier jour pour le site, et nous allons vendre trois chapeaux en édition limitée. Chaque chapeau est conservé dans un hachage Redis de paires champ-valeur, et le hachage a une clé qui est un entier aléatoire préfixé, tel que hat:56854717 . Utilisation du hat: le préfixe est la convention Redis pour créer une sorte d'espace de noms dans une base de données 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,
    })
}

Commençons par la base de données 1 puisque nous avons utilisé la base de données 0 dans un exemple précédent :

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

Pour faire une écriture initiale de ces données dans Redis, nous pouvons utiliser .hmset() (hash multi-set), en l'appelant pour chaque dictionnaire. Le "multi" est une référence à la définition de plusieurs paires champ-valeur, où "champ" dans ce cas correspond à une clé de l'un des dictionnaires imbriqués dans 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

Le bloc de code ci-dessus introduit également le concept de Redis pipelining , qui est un moyen de réduire le nombre de transactions aller-retour dont vous avez besoin pour écrire ou lire des données à partir de votre serveur Redis. Si vous venez d'appeler r.hmset() trois fois, cela nécessiterait un aller-retour pour chaque ligne écrite.

Avec un pipeline, toutes les commandes sont mises en mémoire tampon côté client, puis envoyées en même temps, d'un seul coup, à l'aide de pipe.hmset() à la ligne 3. C'est pourquoi les trois True les réponses sont toutes renvoyées en même temps, lorsque vous appelez pipe.execute() à la ligne 4. Vous verrez bientôt un cas d'utilisation plus avancé pour un pipeline.

Remarque  :Les documents Redis fournissent un exemple de faire la même chose avec le redis-cli , où vous pouvez rediriger le contenu d'un fichier local pour effectuer une insertion en masse.

Vérifions rapidement que tout est là dans notre base de données 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 première chose que nous voulons simuler est ce qui se passe lorsqu'un utilisateur clique sur Acheter . Si l'article est en stock, augmentez son npurchased de 1 et diminuer sa quantity (inventaire) par 1. Vous pouvez utiliser .hincrby() pour faire ceci :

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

Remarque :HINCRBY fonctionne toujours sur une valeur de hachage qui est une chaîne, mais il essaie d'interpréter la chaîne comme un entier signé 64 bits en base 10 pour exécuter l'opération.

Cela s'applique à d'autres commandes liées à l'incrémentation et à la décrémentation pour d'autres structures de données, à savoir INCR , INCRBY , INCRBYFLOAT , ZINCRBY , et HINCRBYFLOAT . Vous obtiendrez une erreur si la chaîne à la valeur ne peut pas être représentée comme un entier.

Ce n'est pas si simple, cependant. Modification de la quantity et npurchased en deux lignes de code cache la réalité qu'un clic, un achat et un paiement impliquent plus que cela. Nous devons faire quelques vérifications supplémentaires pour nous assurer de ne pas laisser quelqu'un avec un portefeuille plus léger et sans chapeau :

• Étape 1 : Vérifiez si l'article est en stock ou déclenchez une exception sur le backend.
• Étape 2 : If it is in stock, then execute the transaction, decrease the quantity field, and increase the npurchased field.
• 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 button. 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() au dessus de. Let’s mimic 3 purchases, which should modify the quantity and npurchased champs :

>>> 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 modules :

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 objet. 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 objet. 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 toi même. 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"])

C'est tout ce qu'on peut en dire. 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