Dans le monde numérique d'aujourd'hui, chaque action - qu'elle fasse glisser une application de rencontres ou terminer un achat - des lies sur les API fonctionnant efficacement dans les coulisses. En tant que développeurs back-end, nous savons que chaque milliseconde compte. Mais comment pouvons-nous faire répondre aux API plus rapidement? La réponse réside dans la mise en cache.

La mise en cache est une technique qui stocke les données fréquemment accessibles en mémoire, permettant aux API de répondre instantanément au lieu d'interroger une base de données plus lente à chaque fois. Pensez-y comme garder les ingrédients clés (sel, poivre, huile) sur votre comptoir de cuisine au lieu de les chercher du garde-manger chaque fois que vous cuisinez - cela fait gagner du temps et rend le processus plus efficace. De même, la mise en cache réduit les temps de réponse de l'API en stockant des données couramment demandées dans un endroit rapide et accessible, comme Redis.

Les bibliothèques requises sont installées

Pour se connecter avec le cache Redis avec Fastapi, nous avons besoin que les bibliothèques suivantes soient préinstallées.

pip install fastapi uvicorn aiocache pydantic

Pydontic est pour créer des tables et des structures de base de données. Aiocache effectuera des opérations asynchrones sur le cache. Uvicorn est responsable de l'exécution du serveur.

Configuration et vérification redis:

La configuration de Redis directement dans un système Windows n'est pas possible à cette jonction. Par conséquent, il doit être configuré et exécuté dans le sous-système Windows pour Linux. Les instructions pour l'installation de WSL sont données ci-dessous

Installez WSL | Microsoft Learn

Installez le sous-système Windows pour Linux avec la commande, WSL --stall. Utilisez un terminal bash sur votre machine Windows exécutée par votre distribution Linux préférée - Ubuntu, Debian, Suse, Kali, Fedora, Pengwin, Alpine et plus sont disponibles.

Learn.microsoft.com

Post Installation WSL, les commandes suivantes sont nécessaires pour installer redis

sudo apt update
sudo apt install redis-server
sudo systemctl start redis

Pour tester la connectivité Redis Server, la commande suivante est utilisée

redis-cli

Après cette commande, il entrera dans un terminal virtuel du port 6379. Dans ce terminal, les commandes redis peuvent être dactylographiées et testées.

Configuration de l'application Fastapi

Créons une application Fastapi simple qui récupère les informations utilisateur et les cache pour les demandes futures. Nous utiliserons Redis pour stocker les réponses mises en cache.

Étape 1: Définissez le modèle pydante pour les données des utilisateurs

Nous utiliserons Pydontic pour définir notre modèle d'utilisateur, qui représente la structure de la réponse de l'API.

from pydantic import BaseModel

class User(BaseModel):
    id: int
    name: str
    email: str
    age: int

Étape 2: Créez un décorateur de mise en cache

Pour éviter de répéter la logique de mise en cache pour chaque point de terminaison, nous créerons un décorateur de mise en cache réutilisable à l'aide de la bibliothèque Aiocache. Ce décorateur tentera de récupérer la réponse de Redis avant d'appeler la fonction réelle.

import json
from functools import wraps
from aiocache import Cache
from fastapi import HTTPException

def cache_response(ttl: int = 60, namespace: str = "main"):
    """
    Caching decorator for FastAPI endpoints.

    ttl: Time to live for the cache in seconds.
    namespace: Namespace for cache keys in Redis.
    """
    def decorator(func):
        @wraps(func)
        async def wrapper(*args, **kwargs):
            user_id = kwargs.get('user_id') or args[0]  # Assuming the user ID is the first argument
            cache_key = f"{namespace}:user:{user_id}"

            cache = Cache.REDIS(endpoint="localhost", port=6379, namespace=namespace)

            # Try to retrieve data from cache
            cached_value = await cache.get(cache_key)
            if cached_value:
                return json.loads(cached_value)  # Return cached data

            # Call the actual function if cache is not hit
            response = await func(*args, **kwargs)

            try:
                # Store the response in Redis with a TTL
                await cache.set(cache_key, json.dumps(response), ttl=ttl)
            except Exception as e:
                raise HTTPException(status_code=500, detail=f"Error caching data: {e}")

            return response
        return wrapper
    return decorator

Étape 3: Implémentez une route fastapi pour les détails de l'utilisateur

Nous implémenterons désormais une route FastAPI qui récupère les informations utilisateur en fonction d'un ID utilisateur. La réponse sera mise en cache à l'aide de redis pour un accès plus rapide dans les demandes suivantes.

from fastapi import FastAPI

app = FastAPI()

# Sample data representing users in a database
users_db = {
    1: {"id": 1, "name": "Alice", "email": "[email protected]", "age": 25},
    2: {"id": 2, "name": "Bob", "email": "[email protected]", "age": 30},
    3: {"id": 3, "name": "Charlie", "email": "[email protected]", "age": 22},
}

@app.get("/users/{user_id}")
@cache_response(ttl=120, namespace="users")
async def get_user_details(user_id: int):
    # Simulate a database call by retrieving data from users_db
    user = users_db.get(user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")

    return user

Étape 4: Exécutez l'application

Démarrez votre application Fastapi en exécutant:

uvicorn main:app --reload

Maintenant, vous pouvez tester l'API en récupérant les détails de l'utilisateur via:

http://127.0.0.1:8000/users/1

La première demande rapportera les données de users_db, mais les demandes suivantes récupéreront les données de Redis.

Tester le cache

Vous pouvez vérifier le cache en inspectant les touches stockées dans redis. Ouvrez le redis CLI:

redis-cli
KEYS *

vous obtiendrez toutes les clés qui ont été stockées dans le redis jusqu'à ttl.

Comment la mise en cache fonctionne dans cet exemple

Première demande

: Lorsque les données utilisateur sont demandées pour la première fois, l'API la récupère à partir de la base de données (USERS_DB) et stocke le résultat en redis avec un temps pour vivre (TTL) de 120 secondes.

Demandes suivantes:

Toutes les demandes ultérieures pour le même utilisateur au cours de la période TTL sont servies directement à partir de redis, rendant la réponse plus rapidement et réduisant la charge sur la base de données.

TTL (temps de vivre):

Après 120 secondes, l'entrée de cache expire et les données sont à nouveau récupérées à partir de la base de données sur la demande suivante, rafraîchissant le cache.

Conclusion

Dans ce tutoriel, nous avons démontré comment implémenter Redis Cach dans une application FastAPI à l'aide d'un exemple de détails utilisateur simple. En mettant en cache les réponses API, vous pouvez améliorer considérablement les performances de votre application, en particulier pour les données qui ne changent pas fréquemment.

Veuillez faire upvote et partager si vous trouvez cet article utile.