FastAPI Backend Development Bootcamp · Lekcja

Strategie buforowania z Redis

Zintegrują Państwo Redis do buforowania odpowiedzi API i często używanych danych w celu poprawy wydajności.

Strategie buforowania z Redis to bezpłatna lekcja FastAPI Backend Development Bootcamp na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej FastAPI Backend Development Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

Why Caching Matters

Imagine your app fetching the same data repeatedly from a slow database or an external service. This slows things down for your users!

Caching is the process of storing frequently accessed data in a faster, temporary location. It's like having a quick-access shortcut for information.

Speeds up response times: Users get data faster.
Reduces load: Less strain on your databases and APIs.
Improves performance: Your application feels snappier and can handle more users.

Meet Redis: A Fast Cache

Redis (Remote Dictionary Server) is an open-source, in-memory data store. Being in-memory means it keeps data in RAM, making it incredibly fast!

It's often called a 'data structure store' because it supports various data types like strings, hashes, lists, and sets, not just simple key-value pairs.

For caching in FastAPI, Redis acts like a lightning-fast key-value store, perfect for storing API responses.

How Redis Caching Works

When a FastAPI endpoint needs data, it first checks Redis.

Cache Hit: If the data is found in Redis, it's returned immediately. This is super fast!
Cache Miss: If the data isn't in Redis, FastAPI fetches it from the original source (e.g., a database). Before returning it, a copy is stored in Redis for future requests.

This strategy ensures that subsequent requests for the same data benefit from the speed of the cache.

Connecting FastAPI to Redis

To use Redis with Python, we'll leverage the redis-py library (specifically its asynchronous version, redis.asyncio). First, install it: pip install redis.

Then, you establish a connection to your Redis server. You can inject this connection as a dependency in your FastAPI application.

Here's how to create a basic asynchronous Redis client and test the connection:

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())

Basic SET and GET Operations

Redis is a key-value store. You use SET to store a value associated with a unique key, and GET to retrieve it.

The decode_responses=True parameter in the client setup ensures that retrieved bytes are automatically decoded into Python strings.

Let's see a simple example of storing and fetching a string:

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())

Caching Complex Data (JSON)

API responses are typically complex data structures, like Python dictionaries, which are then serialized to JSON. Redis stores string values.

To cache a dictionary, we first convert it to a JSON string using Python's built-in json module. When retrieving, we parse the JSON string back into a dictionary.

This allows us to cache rich data objects efficiently.

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())

Managing Cache Expiry (TTL)

Cached data can become 'stale' if the original data in the database changes. Serving stale data can be worse than no cache at all!

Time-To-Live (TTL) is a crucial concept. It's a duration (in seconds) after which a cached item is automatically removed from Redis.

Using TTL ensures your cache stays fresh, preventing you from serving outdated information without manual intervention.

Caching with TTL in FastAPI

When using the SET command in Redis, you can add an ex parameter to specify the expiry time in seconds (or px for milliseconds).

This example demonstrates a FastAPI endpoint that caches an item for 60 seconds. If you request the same item within 60 seconds, it's served from the cache; otherwise, it's fetched from the (simulated) database again.

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.

Cache Invalidation & Considerations

While TTL handles automatic expiry, sometimes you need to manually remove an item from the cache if its source data changes before the TTL expires.

This is called cache invalidation. For example, if a user updates their profile, you'd explicitly delete their old profile data from the cache using redis_client.delete(key).

Considerations for caching:

Data Volatility: Don't cache highly dynamic data that changes every second.
Memory Usage: Redis stores data in RAM, so be mindful of your server's memory capacity.
Consistency: Balance between freshness and performance.

Quick Check

You've learned about Redis and how to implement basic caching strategies. Let's test your understanding of its benefits.

Recap: Caching for Performance

Excellent work! You've successfully explored how Redis can significantly boost your FastAPI application's performance and scalability.

Here's a quick recap of what we covered:

What is Caching: Storing data temporarily for faster access.
Introducing Redis: A fast, in-memory key-value store.
Connecting to Redis: Using redis.asyncio for client connection.
Basic Operations: SET and GET for caching strings and JSON.
Time-To-Live (TTL): Automatically expiring cached data with the ex parameter.
Invalidation: Manually removing stale data.

Next, you might explore more advanced Redis features like Pub/Sub for real-time updates or using Redis Hashes for more structured cached data.

Często zadawane pytania

Czy lekcja „Strategie buforowania z Redis” jest bezpłatna?

Tak — pełny tekst „Strategie buforowania z Redis” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu FastAPI Backend Development Bootcamp, przejdź na CoddyKit PRO. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.

Co nauczysz się w „Strategie buforowania z Redis”?

Zintegrują Państwo Redis do buforowania odpowiedzi API i często używanych danych w celu poprawy wydajności. Ćwiczysz FastAPI Backend Development Bootcamp z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć FastAPI Backend Development Bootcamp?

Nie wymagamy żadnego doświadczenia. FastAPI Backend Development Bootcamp w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Strategie buforowania z Redis”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji FastAPI Backend Development Bootcamp?

Tak. Każda lekcja FastAPI Backend Development Bootcamp zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do FastAPI Backend Development Bootcamp