在當今的數位世界中，每項操作（無論是在約會應用程式上滑動還是完成購買）都依賴在幕後高效工作的 API。作為後端開發人員，我們知道每一毫秒都很重要。但如何才能讓API反應更快呢？答案在於快取。
快取是一種將經常存取的資料儲存在記憶體中的技術，允許 API 立即回應，而不是每次都查詢速度較慢的資料庫。可以將其想像為將關鍵成分（鹽、胡椒、油）放在廚房檯面上，而不是每次烹飪時從食品儲藏室取出它們，這樣可以節省時間並使過程更加高效。同樣，快取透過將常用請求的資料儲存在快速、可存取的位置（例如 Redis）來減少 API 回應時間。
要使用FastAPI連接Redis緩存，我們需要預先安裝以下程式庫。
pip install fastapi uvicorn aiocache pydantic
Pydantic 用於建立資料庫表和結構。 aiocache會對Cache進行非同步操作。 uvicorn負責伺服器的運作。
目前還無法在 Windows 系統中直接設定 Redis。因此，它必須在適用於 Linux 的 Windows 子系統中安裝和運作。下面給出了安裝 WSL 的說明
Post installing WSL, the following commands are required to install Redis
sudo apt update sudo apt install redis-server sudo systemctl start redis
To test Redis server connectivity, the following command is used
redis-cli
After this command, it will enter into a virtual terminal of port 6379. In that terminal, the redis commands can be typed and tested.
Let’s create a simple FastAPI app that retrieves user information and caches it for future requests. We will use Redis for storing cached responses.
We’ll use Pydantic to define our User model, which represents the structure of the API response.
from pydantic import BaseModel
class User(BaseModel):
id: int
name: str
email: str
age: int
To avoid repeating the caching logic for each endpoint, we’ll create a reusable caching decorator using the aiocache library. This decorator will attempt to retrieve the response from Redis before calling the actual function.
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
We’ll now implement a FastAPI route that retrieves user information based on a user ID. The response will be cached using Redis for faster access in subsequent requests.
from fastapi import FastAPI
app = FastAPI()
# Sample data representing users in a database
users_db = {
1: {"id": 1, "name": "Alice", "email": "alice@example.com", "age": 25},
2: {"id": 2, "name": "Bob", "email": "bob@example.com", "age": 30},
3: {"id": 3, "name": "Charlie", "email": "charlie@example.com", "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
Start your FastAPI application by running:
uvicorn main:app --reload
Now, you can test the API by fetching user details via:
http://127.0.0.1:8000/users/1
The first request will fetch the data from the users_db, but subsequent requests will retrieve the data from Redis.
You can verify the cache by inspecting the keys stored in Redis. Open the Redis CLI:
redis-cli KEYS *
You will get all keys that have been stored in the Redis till TTL.
: When the user data is requested for the first time, the API fetches it from the database (users_db) and stores the result in Redis with a time-to-live (TTL) of 120 seconds.
Any subsequent requests for the same user within the TTL period are served directly from Redis, making the response faster and reducing the load on the database.
After 120 seconds, the cache entry expires, and the data is fetched from the database again on the next request, refreshing the cache.
In this tutorial, we’ve demonstrated how to implement Redis caching in a FastAPI application using a simple user details example. By caching API responses, you can significantly improve the performance of your application, particularly for data that doesn't change frequently.
Please do upvote and share if you find this article useful.
以上是FastAPI 中的快取：解鎖高效能開發：的詳細內容。更多資訊請關注PHP中文網其他相關文章！
