Cas d'usage Redis : Cache, Files d'attente et Limitation de débit

Vous avez construit une application web qui gagne en popularité, mais maintenant chaque chargement de page sollicite la base de données, les tâches en arrière-plan s'accumulent et quelques utilisateurs surchargent votre API. Vous avez besoin d'un magasin de données en mémoire rapide pour relever ces défis. Redis est la solution de choix pour le cache, les files d'attente et la limitation de débit. Dans cet article, nous explorerons ces trois cas d'usage principaux avec des exemples pratiques et des bonnes pratiques.

Pourquoi Redis pour le cache, les files d'attente et la limitation de débit ?

Redis est un magasin clé-valeur en mémoire connu pour sa rapidité et sa polyvalence. Il prend en charge des structures de données riches comme les chaînes, les listes, les ensembles, les ensembles triés et les hachages, ce qui le rend idéal pour diverses tâches. Ses opérations atomiques et ses capacités de publication/abonnement étendent encore son utilité. Que vous cherchiez à réduire la charge de la base de données, à découpler les services ou à protéger les API, Redis offre une boîte à outils simple mais puissante.

1. Cache avec Redis

Le cache est le cas d'usage le plus courant de Redis. En stockant les données fréquemment consultées en mémoire, vous réduisez la latence et la charge de la base de données. La fonctionnalité TTL (durée de vie) de Redis expire automatiquement les données obsolètes.

Comment implémenter le cache

1. Vérifier le cache : Avant d'interroger la base de données, vérifiez si les données existent dans Redis.
2. En cas d'absence dans le cache : Récupérez les données depuis la base de données et stockez le résultat dans Redis avec un temps d'expiration.
3. En cas de présence dans le cache : Retournez directement les données mises en cache.

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 pour le cache

• Définir des TTL appropriés : Équilibrez la fraîcheur et le taux de succès. Des TTL courts pour les données volatiles, plus longs pour le contenu statique.
• Utiliser l'invalidation du cache : Lorsque les données changent, supprimez ou mettez à jour la clé de cache pour éviter les lectures obsolètes.
• Gérer les ruées sur le cache : Utilisez des verrous ou une expiration anticipée probabiliste pour éviter que de nombreuses requêtes ne sollicitent la base de données simultanément en cas d'absence dans le cache.
• Surveiller le taux de succès : Visez un taux de succès élevé (par exemple, >80 %) pour garantir l'efficacité du cache.

2. Files d'attente avec Redis

Les listes et ensembles triés de Redis permettent des files d'attente de messages simples mais robustes. Ils sont parfaits pour les tâches en arrière-plan, les files d'attente de tâches et le traitement d'événements. Contrairement aux courtiers de messages dédiés, les files d'attente Redis sont légères et faciles à mettre en place.

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

Utilisez LPUSH pour ajouter des tâches et BRPOP pour les consommer de manière bloquante :

# Producteur
r.lpush('job_queue', json.dumps({'task': 'send_email', 'to': 'user@example.com'}))

# Consommateur
while True:
    _, job = r.brpop('job_queue', timeout=30)
    if job:
        process_job(json.loads(job))

Files d'attente avancées avec les ensembles triés

Pour les tâches différées ou les files d'attente prioritaires, utilisez des ensembles triés avec des horodatages comme scores. Les consommateurs récupèrent les tâches avec des scores