In der heutigen digitalen Welt hat jede Aktion, ob sie in einer Dating -App wischt oder einen Kauf abschließt - zu APIs, die effizient hinter den Kulissen arbeiten. Als Back-End-Entwickler wissen wir, dass jede Millisekundenzone zählt. Aber wie können wir APIs schneller reagieren lassen? Die Antwort liegt im Caching.

Caching ist eine Technik, die häufig auf Daten im Speicher zugegriffen wird, sodass APIs sofort reagieren können, anstatt jedes Mal eine langsamere Datenbank abzufragen. Stellen Sie sich vor, Sie auf Ihre Küchenarbeitsplatte auf Ihrer Küchenarbeitsplatte (Salz, Pfeffer, Öl) zu halten, anstatt sie jedes Mal, wenn Sie kochen, aus der Speisekammer zu holen - dies spart Zeit und macht den Prozess effizienter. In ähnlicher Weise reduziert Caching die API -Antwortzeiten, indem häufig angeforderte Daten an einem schnellen, zugänglichen Ort wie Redis gespeichert werden.

Erforderliche Bibliotheken zu installieren

Um sich mit Redis-Cache mit Fastapi zu verbinden, müssen die folgenden Bibliotheken vorinstalliert werden.

pip install fastapi uvicorn aiocache pydantic

Pydantic dient zum Erstellen von Datenbanktabellen und -strukturen. AIOCache führt asynchronen Operationen auf Cache aus. Uvicorn ist für den Server verantwortlich.

Redis -Setup und Überprüfung:

REDIS direkt in einem Windows -System einrichten ist an dieser Kreuzung nicht möglich. Daher muss es eingerichtet und im Windows -Subsystem für Linux ausgeführt werden. Anweisungen zur Installation von WSL finden Sie unten

Post Installation von WSL, müssen die folgenden Befehle reparieren
installieren.

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

Um Redis Server -Konnektivität zu testen, wird der folgende Befehl verwendet

redis-cli

Nach diesem Befehl wird es ein virtuelles Terminal von Port 6379 eingeben. In diesem Terminal können die Befehle der Redis eingegeben und getestet werden.

Einrichten der Fastapi -Anwendung

Lassen Sie uns eine einfache Fastapi -App erstellen, die Benutzerinformationen abruft und für zukünftige Anfragen zwischengespeichert. Wir werden Redis für die Speicherung zwischengespeicherter Antworten verwenden.

Schritt 1: Definieren Sie das pydantische Modell für Benutzerdaten

Wir werden Pydantic verwenden, um unser Benutzermodell zu definieren, das die Struktur der API -Antwort darstellt.

from pydantic import BaseModel

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

Schritt 2: Erstellen Sie einen Caching Decorator

Um zu vermeiden, dass die Caching -Logik für jeden Endpunkt wiederholt wird, erstellen wir einen wiederverwendbaren Caching -Dekorator mit der AIOCache -Bibliothek. Dieser Dekorateur versucht, die Antwort von Redis abzurufen, bevor er die tatsächliche Funktion aufruft.

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

Schritt 3: Implementieren Sie eine Fastapi -Route für Benutzerdetails

Wir werden jetzt eine Fastapi -Route implementieren, auf der Benutzerinformationen basierend auf einer Benutzer -ID abgerufen werden. Die Antwort wird unter Verwendung von Redis für einen schnelleren Zugriff in nachfolgenden Anfragen zwischengespeichert.

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

Schritt 4: Führen Sie die Anwendung aus

Starten Sie Ihre Fastapi -Anwendung durch Ausführen:

uvicorn main:app --reload

Jetzt können Sie die API testen, indem Sie Benutzerdetails über:
abrufen:

http://127.0.0.1:8000/users/1

http://127.0.0.1:8000/users/1

Die erste Anfrage wird die Daten aus der user_db abgerufen, aber nachfolgende Anfragen werden die Daten von Redis abrufen.

Testen des Cache

Sie können den Cache überprüfen, indem Sie die in Redis gespeicherten Schlüssel inspizieren. Öffnen Sie die Redis Cli:

http://127.0.0.1:8000/users/1

redis-cli Schlüssel *

Sie erhalten alle Schlüssel, die in der Redis aufbewahrt wurden, bis ttl.

Wie das Zwischenspeichern in diesem Beispiel funktioniert

Erste Anfrage

: Wenn die Benutzerdaten zum ersten Mal angefordert werden, ruft die API sie aus der Datenbank (user_db) ab und speichert das Ergebnis in Redis mit einer Zeit-zu-Live (TTL) von 120 Sekunden.

Nachfolgende Anfragen:

Alle nachfolgenden Anfragen für denselben Benutzer innerhalb der TTL -Zeit werden direkt aus Redis bedient, sodass die Antwort schneller und die Last in der Datenbank reduziert wird.

TTL (Zeit zum Leben):

Nach 120 Sekunden läuft der Cache -Eintrag ab und die Daten werden auf der nächsten Anfrage erneut aus der Datenbank abgerufen.

.

Abschluss

In diesem Tutorial haben wir demonstriert, wie Redis Caching in einer FastAPI -Anwendung mit einem einfachen Benutzerdetails -Beispiel implementiert wird. Durch das Zwischenspeichern von API -Antworten können Sie die Leistung Ihrer Anwendung erheblich verbessern, insbesondere für Daten, die sich nicht häufig ändern.

Bitte machen Sie upvote und teilen Sie, wenn Sie diesen Artikel nützlich finden.