In der heutigen digitalen Welt ist jede Aktion – sei es das Wischen in einer Dating-App oder das Abschließen eines Kaufs – auf APIs angewiesen, die hinter den Kulissen effizient arbeiten. Als Back-End-Entwickler wissen wir, dass jede Millisekunde zählt. Aber wie können wir dafür sorgen, dass APIs schneller reagieren? Die Antwort liegt im Caching.
Caching ist eine Technik, die häufig aufgerufene Daten im Speicher speichert und es APIs ermöglicht, sofort zu reagieren, anstatt jedes Mal eine langsamere Datenbank abzufragen. Stellen Sie sich das so vor, als ob Sie wichtige Zutaten (Salz, Pfeffer, Öl) auf Ihrer Küchenarbeitsplatte aufbewahren, anstatt sie jedes Mal, wenn Sie kochen, aus der Speisekammer zu holen – das spart Zeit und macht den Prozess effizienter. Ebenso reduziert Caching die API-Antwortzeiten, indem häufig angeforderte Daten an einem schnellen, zugänglichen Ort wie Redis gespeichert werden.
Erforderliche Bibliotheken müssen installiert werden
Um eine Verbindung mit Redis Cache mit FastAPI herzustellen, müssen die folgenden Bibliotheken vorinstalliert sein.
pip install fastapi uvicorn aiocache pydantic
Pydantic dient zum Erstellen von Datenbanktabellen und -strukturen. aiocache führt asynchrone Vorgänge im Cache aus. uvicorn ist für den Serverbetrieb verantwortlich.
Redis-Einrichtung und -Verifizierung:
Eine direkte Einrichtung von Redis in einem Windows-System ist derzeit nicht möglich. Daher muss es im Windows-Subsystem für Linux eingerichtet und ausgeführt werden. Anweisungen zur Installation von WSL finden Sie unten
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.
Setting Up the FastAPI Application
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.
Step 1: Define the Pydantic Model for User Data
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
Step 2: Create a Caching Decorator
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
Step 3: Implement a FastAPI Route for User Details
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
Step 4: Run the Application
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.
Testing the Cache
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.
How Caching Works in This Example
First Request
: 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.
Subsequent Requests:
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.
TTL (Time to Live):
After 120 seconds, the cache entry expires, and the data is fetched from the database again on the next request, refreshing the cache.
Conclusion
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 中国語 Web サイトの他の関連記事を参照してください。

PythonとCにはそれぞれ独自の利点があり、選択はプロジェクトの要件に基づいている必要があります。 1)Pythonは、簡潔な構文と動的タイピングのため、迅速な開発とデータ処理に適しています。 2)Cは、静的なタイピングと手動メモリ管理により、高性能およびシステムプログラミングに適しています。

PythonまたはCの選択は、プロジェクトの要件に依存します。1)迅速な開発、データ処理、およびプロトタイプ設計が必要な場合は、Pythonを選択します。 2)高性能、低レイテンシ、および緊密なハードウェアコントロールが必要な場合は、Cを選択します。

毎日2時間のPython学習を投資することで、プログラミングスキルを効果的に改善できます。 1.新しい知識を学ぶ:ドキュメントを読むか、チュートリアルを見る。 2。練習:コードと完全な演習を書きます。 3。レビュー:学んだコンテンツを統合します。 4。プロジェクトの実践:実際のプロジェクトで学んだことを適用します。このような構造化された学習計画は、Pythonを体系的にマスターし、キャリア目標を達成するのに役立ちます。

2時間以内にPythonを効率的に学習する方法は次のとおりです。1。基本的な知識を確認し、Pythonのインストールと基本的な構文に精通していることを確認します。 2。変数、リスト、関数など、Pythonのコア概念を理解します。 3.例を使用して、基本的および高度な使用をマスターします。 4.一般的なエラーとデバッグテクニックを学習します。 5.リストの概念を使用したり、PEP8スタイルガイドに従ったりするなど、パフォーマンスの最適化とベストプラクティスを適用します。

Pythonは初心者やデータサイエンスに適しており、Cはシステムプログラミングとゲーム開発に適しています。 1. Pythonはシンプルで使いやすく、データサイエンスやWeb開発に適しています。 2.Cは、ゲーム開発とシステムプログラミングに適した、高性能と制御を提供します。選択は、プロジェクトのニーズと個人的な関心に基づいている必要があります。

Pythonはデータサイエンスと迅速な発展により適していますが、Cは高性能およびシステムプログラミングにより適しています。 1. Python構文は簡潔で学習しやすく、データ処理と科学的コンピューティングに適しています。 2.Cには複雑な構文がありますが、優れたパフォーマンスがあり、ゲーム開発とシステムプログラミングでよく使用されます。

Pythonを学ぶために1日2時間投資することは可能です。 1.新しい知識を学ぶ:リストや辞書など、1時間で新しい概念を学びます。 2。練習と練習:1時間を使用して、小さなプログラムを書くなどのプログラミング演習を実行します。合理的な計画と忍耐力を通じて、Pythonのコアコンセプトを短時間で習得できます。

Pythonは学習と使用が簡単ですが、Cはより強力ですが複雑です。 1。Python構文は簡潔で初心者に適しています。動的なタイピングと自動メモリ管理により、使いやすくなりますが、ランタイムエラーを引き起こす可能性があります。 2.Cは、高性能アプリケーションに適した低レベルの制御と高度な機能を提供しますが、学習しきい値が高く、手動メモリとタイプの安全管理が必要です。


ホットAIツール

Undresser.AI Undress
リアルなヌード写真を作成する AI 搭載アプリ

AI Clothes Remover
写真から衣服を削除するオンライン AI ツール。

Undress AI Tool
脱衣画像を無料で

Clothoff.io
AI衣類リムーバー

Video Face Swap
完全無料の AI 顔交換ツールを使用して、あらゆるビデオの顔を簡単に交換できます。

人気の記事

ホットツール

SublimeText3 中国語版
中国語版、とても使いやすい

SublimeText3 英語版
推奨: Win バージョン、コードプロンプトをサポート!

SublimeText3 Linux 新バージョン
SublimeText3 Linux 最新バージョン

WebStorm Mac版
便利なJavaScript開発ツール

mPDF
mPDF は、UTF-8 でエンコードされた HTML から PDF ファイルを生成できる PHP ライブラリです。オリジナルの作者である Ian Back は、Web サイトから「オンザフライ」で PDF ファイルを出力し、さまざまな言語を処理するために mPDF を作成しました。 HTML2FPDF などのオリジナルのスクリプトよりも遅く、Unicode フォントを使用すると生成されるファイルが大きくなりますが、CSS スタイルなどをサポートし、多くの機能強化が施されています。 RTL (アラビア語とヘブライ語) や CJK (中国語、日本語、韓国語) を含むほぼすべての言語をサポートします。ネストされたブロックレベル要素 (P、DIV など) をサポートします。
