Cas d'usage Redis : cache, files d'attente et limitation de débit

Vous avez développé une application web qui fonctionne bien en développement, mais à mesure que le trafic augmente, vous remarquez des temps de réponse lents et une surcharge de la base de données. Le coupable est souvent la répétition d'opérations coûteuses : récupérer les mêmes données depuis la base de données, traiter des tâches de manière synchrone, ou autoriser des taux de requêtes abusifs. Redis, un magasin de données en mémoire, offre des solutions élégantes à ces problèmes. Dans cet article, nous allons explorer trois cas d'usage pratiques de Redis : le cache, les files d'attente et la limitation de débit. Vous apprendrez à implémenter chaque modèle avec des exemples de code et comprendrez quand les appliquer.

Pourquoi Redis ?

Redis est un magasin clé-valeur open-source en mémoire, connu pour sa rapidité et sa polyvalence. Il prend en charge des structures de données telles que les chaînes, les listes, les ensembles et les hachages, ce qui le rend adapté à diverses tâches au-delà du simple cache. Comme il conserve les données en mémoire, Redis offre une latence inférieure à la milliseconde, idéale pour les scénarios à hautes performances. Il propose également des options de persistance, pour ne pas perdre de données lors d'un redémarrage. Plongeons dans les trois cas d'usage.

1. Cache avec Redis

Le cache est le cas d'usage le plus courant de Redis. L'idée est simple : stocker les résultats d'opérations coûteuses (comme des requêtes de base de données ou des appels API) dans Redis, et les servir directement pour les requêtes suivantes. Cela réduit la charge sur votre base de données principale et accélère les temps de réponse.

Comment implémenter le cache

1. Vérifier le cache : Avant d'interroger la base de données, recherchez les données dans Redis à l'aide d'une clé unique (par exemple, user:123).
2. Si trouvé (cache hit) : Renvoyez immédiatement les données mises en cache.
3. Si non trouvé (cache miss) : Récupérez les données depuis la base de données, stockez-les dans Redis avec un temps d'expiration (TTL), et renvoyez-les.

Voici un exemple en Python utilisant redis-py :

import redis
import json

r = redis.Redis(host='localhost', port=6379, db=0)

def get_user(user_id):
    cache_key = f'user:{user_id}'
    cached = r.get(cache_key)
    if cached:
        return json.loads(cached)
    # Simuler la récupération depuis la base de données
    user = fetch_user_from_db(user_id)
    r.setex(cache_key, 3600, json.dumps(user))  # Cache pendant 1 heure
    return user

Bonnes pratiques : Choisissez des clés significatives, définissez des TTL appropriés pour éviter les données obsolètes, et envisagez des stratégies d'invalidation du cache. Pour les charges de travail à forte lecture, le cache peut réduire la charge de la base de données de plusieurs ordres de grandeur.

2. Files d'attente avec Redis

Les files d'attente découplent les tâches chronophages du cycle requête-réponse. Par exemple, l'envoi d'e-mails, le traitement d'images ou la génération de rapports peuvent être effectués de manière asynchrone. Les listes ou les flux Redis sont parfaits pour implémenter des files d'attente simples.

Implémentation d'une file d'attente de base

Utilisez LPUSH pour ajouter des tâches à gauche d'une liste et BRPOP pour bloquer et dépiler à droite. Cela crée une file d'attente FIFO.

# Producteur : ajouter une tâche
r.lpush('email_queue', json.dumps({'to': 'user@example.com', 'subject': 'Welcome'}))

# Consommateur : traiter les tâches
while True:
    _, job = r.brpop('email_queue', timeout=30)
    if job:
        process_email(json.loads(job))

Pour des besoins plus avancés, les Redis Streams offrent des groupes de consommateurs, des accusés de réception et la possibilité de rejouer les messages, ce qui les rend adaptés à un traitement robuste des messages.

3. Limitation de débit avec Redis

La limitation de débit protège votre API contre les abus et garantit une utilisation équitable. Les opérations atomiques de Redis facilitent la mise en œuvre de compteurs qui expirent automatiquement.

Limitation de débit à fenêtre fixe

Dans une approche à fenêtre fixe, vous autorisez N requêtes par fenêtre temporelle (par exemple, 100 requêtes par heure par IP). Utilisez INCR et EXPIRE :

def is_allowed(ip, limit=100, window=3600):
    key = f'rate:{ip}'
    current = r.incr(key)
    if current == 1:
        r.expire(key, window)
    return current