Redis

À quoi ça sert

PostgreSQL est très bien pour stocker durablement des données structurées, mais lent (quelques millisecondes par requête simple). Redis vise un autre besoin : des petites données souvent lues ou écrites, où la latence doit être quasi nulle.

Cas d'usage typiques :

• Cache — tu stockes le résultat d'un calcul ou d'une requête SQL pour le réutiliser pendant n secondes (TTL).
• Sessions web — token utilisateur → infos de session, partagé entre plusieurs instances de ton API.
• File de tâches — Redis sert de broker pour Celery/RQ/Dramatiq.
• Compteurs / rate limiting — incrémenter un compteur atomiquement, expirer après 1 minute (« max 100 requêtes / min »).
• Pub/Sub — diffuser des événements entre processus (chat en temps réel, notifications).
• Streams — depuis Redis 5, un mode similaire à Kafka (en plus simple et plus petit).

Un exemple d'usage

Tu veux mettre en cache le résultat d'un endpoint de prédiction qui est souvent appelé avec les mêmes entrées (par exemple, des features identiques pendant la même journée) :

import redis, json, hashlib

r = redis.Redis(host="localhost", port=6379, decode_responses=True)

def predict_cached(features: dict) -> dict:
    key = "pred:" + hashlib.sha1(json.dumps(features, sort_keys=True).encode()).hexdigest()

    cached = r.get(key)
    if cached:
        return json.loads(cached)

    result = model_predict(features)  # calcul lent
    r.setex(key, 3600, json.dumps(result))  # TTL 1h
    return result

Première requête pour un jeu d'entrées donné : calcul lent + écriture Redis (~1 ms). Toutes les suivantes pendant 1 h : un simple GET Redis (~0,1 ms). Aucune autre brique à installer.

How-to : démarrer avec Redis

1. Lancer Redis avec Docker

   bash Copier

   docker run -d --name redis \
     -p 6379:6379 \
     -v redis-data:/data \
     redis:7 redis-server --appendonly yes

   --appendonly yes active la persistence AOF : Redis relit son log au redémarrage et retrouve son état. Suffisant pour un cache, pas suffisant pour des données critiques.

2. Tester avec redis-cli

   bash Copier

   docker exec -it redis redis-cli
   
   # Une fois dans le shell :
   SET hello world
   GET hello
   SET temp "5 secondes" EX 5
   GET temp        # puis attends 6s et refais : (nil)
   INCR counter
   INCR counter
   KEYS *
   DEL hello

3. Installer le client Python

   bash Copier

   uv add redis

   decode_responses=True à la création du client renvoie des str au lieu de bytes — plus confortable pour démarrer.

4. Connaître les structures de données

   Redis ne fait pas que clé→string. Cinq grandes structures à connaître :

   • String — texte ou nombre. SET, GET, INCR.
   • Hash — un mini-dico par clé. Idéal pour des objets. HSET user:42 name Alice age 30.
   • List — liste ordonnée, push aux deux bouts. LPUSH, RPOP. Sert à faire des queues simples.
   • Set — ensemble de valeurs uniques. SADD, SISMEMBER. Pour des « tags », des « ids vus ».
   • Sorted set (ZSET) — set + score. Top N, leaderboards. ZADD, ZRANGE.

5. Atomicité et compteurs

   Toutes les commandes Redis sont atomiques. INCR sur un compteur partagé entre 100 workers ne perdra pas d'incréments. Pour grouper plusieurs commandes atomiquement, utilise pipeline ou MULTI/EXEC :

   python Copier

   pipe = r.pipeline()
   pipe.incr("requests:user:42")
   pipe.expire("requests:user:42", 60)
   count, _ = pipe.execute()
   if count > 100:
       raise RateLimitExceeded()

6. Sécurité minimale

   En local pas de souci, mais dès que Redis est exposé, mets un mot de passe (requirepass dans la config) et bloque le port 6379 au pare-feu. Une instance Redis ouverte sur internet sans auth se fait piller en quelques minutes — c'est l'un des classiques de l'OWASP.

7. UI : RedisInsight

   Pour explorer visuellement (clés, valeurs, structures, métriques) : RedisInsight, l'UI officielle gratuite. Image Docker redis/redisinsight, port 5540. Très utile pour comprendre ce que stocke Celery par exemple.

Aide-mémoire

# String / TTL
SET k v
SET k v EX 60        # expire dans 60s
SETEX k 60 v         # idem, autre forme
GET k
DEL k
TTL k                # temps restant
INCR k
EXPIRE k 30

# Hash
HSET user:42 name Alice age 30
HGETALL user:42
HINCRBY user:42 age 1

# List (FIFO simple)
LPUSH q msg1
RPOP q

# Pub/Sub
SUBSCRIBE chan
PUBLISH chan "hello"

# Inspection
KEYS pattern*        # évite en prod, utilise SCAN
INFO memory
DBSIZE

# Format standard accepté par Celery, FastAPI, etc.
redis://[:password@]host:6379/0

# En local par défaut
redis://localhost:6379/0

Redis et le reste de l'écosystème

• Celery — broker recommandé pour démarrer (plus simple que RabbitMQ). Sert aussi de result backend pour stocker les résultats des tâches.
• RabbitMQ — l'autre broker classique. Plus de garanties (acks, DLQ, routing complexe), plus lourd à opérer.
• FastAPI — cache avant la base de données, sessions, rate limiting. Lib pratique : fastapi-cache.
• SQLAlchemy — Redis ne remplace pas une base SQL. Pattern courant : Postgres pour le persistant, Redis pour le cache et le transitoire.
• Docker / Kubernetes — un conteneur suffit en dev. En prod sur K8s : Helm chart Bitnami ou opérateur Redis officiel pour la HA (réplication + Sentinel).
• Prometheus + Grafana — exporter redis_exporter + dashboard Grafana 763 pour suivre mémoire, hit ratio, ops/s.

Pour aller plus loin

• Documentation officielle : redis.io/docs
• Aide-mémoire des commandes : redis.io/commands
• Try Redis (sans rien installer) : try.redis.io
• Client Python : redis-py.readthedocs.io