Bootcamp i backendutvikling med FastAPI · leksjon

Bufringsstrategier med Redis

Integrer Redis for å bufre API-svar og data som brukes ofte, slik at ytelsen forbedres.

Leksjon 1 av 411 trinn

Bufringsstrategier med Redis er en gratis leksjon i Bootcamp i backendutvikling med FastAPI på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Bootcamp i backendutvikling med FastAPI, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Bootcamp i backendutvikling med FastAPI inneholder totalt 4 leksjoner.

Hvorfor bufring er viktig

Se for Dem at appen Deres gjentatte ganger henter de samme dataene fra en treg database eller en ekstern tjeneste. Dette gjør opplevelsen tregere for brukerne!

Bufring er prosessen med å lagre data som ofte aksesseres, på et raskere og midlertidig sted. Det fungerer som en snarvei for rask tilgang til informasjon.

Gir raskere svartider: Brukerne får dataene raskere.
Reduserer belastningen: Databasene og API-ene Deres belastes mindre.
Forbedrer ytelsen: Applikasjonen føles raskere og kan håndtere flere brukere.

Møt Redis: En rask hurtigbuffer

Redis (Remote Dictionary Server) er et åpent datalager i minnet. At det ligger i minnet, betyr at dataene lagres i RAM, noe som gjør det utrolig raskt!

Det kalles ofte et «datastrukturlager» fordi det støtter ulike datatyper som strenger, hasher, lister og mengder – ikke bare enkle nøkkel-verdi-par.

For hurtigbufring i FastAPI fungerer Redis som et lynraskt nøkkel-verdi-lager, perfekt for lagring av API-svar.

Slik fungerer hurtigbufring med Redis

Når et FastAPI-endepunkt trenger data, sjekker det først Redis.

Cache-treff: Hvis dataene finnes i Redis, returneres de umiddelbart. Dette går svært raskt!
Cache-bom: Hvis dataene ikke finnes i Redis, henter FastAPI dem fra den opprinnelige kilden (for eksempel en database). Før dataene returneres, lagres en kopi i Redis for fremtidige forespørsler.

Denne strategien sørger for at påfølgende forespørsler etter de samme dataene drar nytte av hurtigbufferens hastighet.

Koble FastAPI til Redis

For å bruke Redis med Python benytter vi biblioteket redis-py (nærmere bestemt den asynkrone versjonen, redis.asyncio). Installer det først: pip install redis.

Deretter oppretter du en tilkobling til Redis-serveren. Du kan injisere denne tilkoblingen som en avhengighet i FastAPI-applikasjonen.

Slik oppretter du en enkel asynkron Redis-klient og tester tilkoblingen:

import redis.asyncio as redis
import asyncio

async def connect_to_redis():
    # Connect to Redis server (default host/port)
    r = redis.Redis(host='localhost', port=6377, db=0, decode_responses=True)
    try:
        # Ping to check connection
        await r.ping()
        print("Successfully connected to Redis!")
    except redis.exceptions.ConnectionError as e:
        print(f"Could not connect to Redis: {e}")
    finally:
        # Close the connection when done
        await r.close()

if __name__ == "__main__":
    # Run the async function
    asyncio.run(connect_to_redis())

Grunnleggende SET- og GET-operasjoner

Redis er et nøkkel-verdi-lager. Du bruker SET til å lagre en verdi knyttet til en unik nøkkel, og GET til å hente den.

Parameteren decode_responses=True i klientoppsettet sørger for at hentede byteverdier automatisk dekodes til Python-strenger.

La oss se på et enkelt eksempel på hvordan du lagrer og henter en streng:

import redis.asyncio as redis
import asyncio

async def basic_cache_example():
    r = redis.Redis(host='localhost', port=6377, db=0, decode_responses=True)
    key = "app:greeting"
    value = "Hello from your Redis cache!"

    # Store a value with a key
    await r.set(key, value)
    print(f"Set key '{key}' with value: '{value}'")

    # Retrieve the value using its key
    cached_value = await r.get(key)
    print(f"Retrieved value for '{key}': '{cached_value}'")

    await r.close()

if __name__ == "__main__":
    asyncio.run(basic_cache_example())

Hurtigbufring av komplekse data (JSON)

API-svar består vanligvis av komplekse datastrukturer, for eksempel Python-ordbøker, som deretter serialiseres til JSON. Redis lagrer strengverdier.

For å hurtigbufre en ordbok konverterer vi den først til en JSON-streng ved hjelp av Pythons innebygde json-modul. Når vi henter den, tolker vi JSON-strengen tilbake til en ordbok.

Dermed kan vi hurtigbufre innholdsrike dataobjekter på en effektiv måte.

import redis.asyncio as redis
import asyncio
import json

async def cache_json_object_example():
    r = redis.Redis(host='localhost', port=6377, db=0, decode_responses=True)
    
    user_id = "user_456"
    user_profile = {"name": "Alice", "email": "alice@example.com", "age": 30}
    
    # Convert Python dict to JSON string
    json_profile = json.dumps(user_profile)
    
    # Store the JSON string in Redis
    await r.set(f"user:{user_id}", json_profile)
    print(f"Cached user profile for {user_id}")
    
    # Retrieve the JSON string from Redis
    cached_json = await r.get(f"user:{user_id}")
    if cached_json:
        # Convert JSON string back to Python dict
        retrieved_profile = json.loads(cached_json)
        print(f"Retrieved user name: {retrieved_profile['name']}")
    
    await r.close()

if __name__ == "__main__":
    asyncio.run(cache_json_object_example())

Administrere utløpstid for hurtigbufferen (TTL)

Bufrede data kan bli «foreldet» hvis de opprinnelige dataene i databasen endres. Det kan være verre å levere foreldede data enn å ikke bruke hurtigbuffer i det hele tatt!

Time-To-Live (TTL) er et viktig konsept. Det er en varighet (i sekunder) etter hvilken et bufret element automatisk fjernes fra Redis.

Ved å bruke TTL sørger du for at hurtigbufferen holder seg oppdatert, slik at du unngår å levere utdatert informasjon manuelt.

Hurtigbufring med TTL i FastAPI

Når du bruker SET-kommandoen i Redis, kan du legge til en ex-parameter for å angi utløpstiden i sekunder (eller px for millisekunder).

Dette eksempelet viser et FastAPI-endepunkt som hurtigbufrer et element i 60 sekunder. Hvis du ber om det samme elementet innen 60 sekunder, leveres det fra hurtigbufferen. Ellers hentes det fra den (simulerte) databasen på nytt.

from fastapi import FastAPI, Depends
import redis.asyncio as redis
import asyncio
import json

app = FastAPI()

# Dependency to get a Redis client instance
async def get_redis_client():
    r = redis.Redis(host='localhost', port=6377, db=0, decode_responses=True)
    try:
        yield r # Provide the client
    finally:
        await r.close() # Ensure client is closed after request

@app.get("/products/{product_id}")
async def read_product(product_id: str, redis_client: redis.Redis = Depends(get_redis_client)):
    cache_key = f"product:{product_id}"
    
    # 1. Try to get data from cache
    cached_data = await redis_client.get(cache_key)
    if cached_data:
        print(f"Cache hit for {product_id}!")
        return json.loads(cached_data)
    
    # 2. If not in cache, simulate fetching from database
    print(f"Cache miss for {product_id}. Fetching from DB...")
    await asyncio.sleep(1) # Simulate I/O delay for DB call
    product_data = {"id": product_id, "name": f"Product {product_id}", "price": 99.99}
    
    # 3. Store in cache with 60-second TTL
    await redis_client.set(cache_key, json.dumps(product_data), ex=60)
    
    return product_data

# To run this example:
# 1. Ensure a Redis server is running (e.g., `redis-server` in your terminal).
# 2. Save this code as `main.py`.
# 3. Run Uvicorn: `uvicorn main:app --reload`.
# 4. Access in your browser: `http://127.0.0.1:8000/products/123`.
#    Refresh the page to see 'Cache hit' messages after the first request.

Ugyldiggjøring av hurtigbufferen og hensyn

Selv om TTL håndterer automatisk utløp, kan det noen ganger være nødvendig å fjerne et element manuelt fra hurtigbufferen hvis kildedataene endres før TTL-en utløper.

Dette kalles ugyldiggjøring av hurtigbufferen. Hvis en bruker for eksempel oppdaterer profilen sin, kan du eksplisitt slette de gamle profildataene fra hurtigbufferen ved hjelp av redis_client.delete(key).

Hensyn ved hurtigbufring:

Dataenes endringshyppighet: Ikke hurtigbufre data som endres svært ofte, for eksempel hvert sekund.
Minnebruk: Redis lagrer data i RAM, så ta hensyn til hvor mye minne serveren har tilgjengelig.
Konsistens: Finn en balanse mellom aktualitet og ytelse.

Hurtigsjekk

Du har lært om Redis og hvordan du implementerer grunnleggende strategier for hurtigbufring. La oss teste forståelsen din av fordelene.

Besvar den i den interaktive leksjonen

Oppsummering: Hurtigbufring for bedre ytelse

Utmerket arbeid! Du har utforsket hvordan Redis kan forbedre ytelsen og skalerbarheten til FastAPI-applikasjonen din betydelig.

Her er en kort oppsummering av det vi har gått gjennom:

Hva er hurtigbufring: Midlertidig lagring av data for raskere tilgang.
Introduksjon til Redis: Et raskt nøkkel-verdi-lager i minnet.
Tilkobling til Redis: Bruk av redis.asyncio for klienttilkobling.
Grunnleggende operasjoner: SET og GET for hurtigbufring av strenger og JSON.
Time-To-Live (TTL): Automatisk utløp av bufrede data med ex-parameteren.
Ugyldiggjøring: Manuell fjerning av foreldede data.

Deretter kan du utforske mer avanserte Redis-funksjoner, for eksempel Pub/Sub for oppdateringer i sanntid eller Redis Hashes for mer strukturerte bufrede data.

Gratis å komme i gang

Lær deg Bootcamp i backendutvikling med FastAPI med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 21
Leksjoner: 84

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Bufringsstrategier med Redis» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Bootcamp i backendutvikling med FastAPI, inkludert «Bufringsstrategier med Redis», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Bootcamp i backendutvikling med FastAPI inneholder totalt 4 leksjoner.

Hva lærer jeg i «Bufringsstrategier med Redis»?

Integrer Redis for å bufre API-svar og data som brukes ofte, slik at ytelsen forbedres. Du øver på Bootcamp i backendutvikling med FastAPI med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Bootcamp i backendutvikling med FastAPI?

Ingen tidligere erfaring er nødvendig. Bootcamp i backendutvikling med FastAPI på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Bufringsstrategier med Redis»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Bootcamp i backendutvikling med FastAPI-leksjonen?

Ja. Alle Bootcamp i backendutvikling med FastAPI-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

← Tilbake til Bootcamp i backendutvikling med FastAPI