FastAPI Backend Development Bootcamp · Урок

Стратегии кэширования с Redis

Интегрируйте Redis для кэширования ответов API и часто используемых данных, чтобы повысить производительность.

Урок 1 из 411 шагов

«Стратегии кэширования с Redis» — бесплатный урок FastAPI Backend Development Bootcamp на CoddyKit. Это урок 1 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения FastAPI Backend Development Bootcamp, и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс FastAPI Backend Development Bootcamp содержит 4 уроков всего.

Части этого урока еще не переведены и отображаются на английском.

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.

Можно начать бесплатно

Изучай FastAPI Backend Development Bootcamp с ИИ-репетитором — бесплатно

Пиши и запускай код прямо в браузере, получай мгновенную помощь от ИИ-репетитора 24/7 и продолжи учиться на сайте или в приложении.

Курсы: 21
Уроки: 84

Начать учиться бесплатно Посмотреть полный курс

Часто задаваемые вопросы

Урок «Стратегии кэширования с Redis» бесплатный?

Да — полный текст урока «Стратегии кэширования с Redis» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс FastAPI Backend Development Bootcamp, подпишись на CoddyKit PRO. Курс FastAPI Backend Development Bootcamp содержит 4 уроков всего.

Чему я научусь в уроке «Стратегии кэширования с Redis»?

Интегрируйте Redis для кэширования ответов API и часто используемых данных, чтобы повысить производительность. Ты практикуешь FastAPI Backend Development Bootcamp с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать FastAPI Backend Development Bootcamp?

Предыдущий опыт не требуется. FastAPI Backend Development Bootcamp на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 1 из 4.

Сколько времени занимает урок «Стратегии кэширования с Redis»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке FastAPI Backend Development Bootcamp?

Да. Каждый урок FastAPI Backend Development Bootcamp включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

← Назад к FastAPI Backend Development Bootcamp