Créez des applications Web asynchrones et hautes performances à l'aide de FastAPI

Utilisez FastAPI pour créer des applications Web asynchrones et hautes performances

Avec le développement rapide d'Internet, les performances et l'efficacité des applications Web sont devenues l'une des priorités des utilisateurs. Les frameworks Web traditionnels sont souvent inefficaces lorsqu’il s’agit de traiter un grand nombre de requêtes et ne peuvent pas répondre aux exigences élevées de concurrence. Afin d'améliorer les performances et l'efficacité des applications Web, FastAPI a vu le jour.

FastAPI est un framework Web moderne basé sur Python qui maintient la simplicité et la facilité d'utilisation tout en offrant des performances exceptionnelles. FastAPI adopte un modèle de programmation asynchrone et utilise les coroutines et les mécanismes d'E/S asynchrones de Python pour permettre aux applications de gérer efficacement un grand nombre de requêtes simultanées. Ce qui suit explique comment utiliser FastAPI pour créer une application Web asynchrone hautes performances.

1. Installez FastAPI

Tout d'abord, vous devez installer FastAPI à l'aide de la commande pip :

pip install fastapi

2. Écrivez le code

Ensuite, créez un fichier Python, tel que main.py, et écrivez le code suivant :

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello, World!"}

Le code ci-dessus crée une application FastAPI et définit une route de requête GET, "/" représente le répertoire racine. Lors de l'accès au répertoire racine, une réponse JSON contenant « Hello, World ! » sera renvoyée.

3. Exécutez l'application

Utilisez uvicorn pour exécuter l'application FastAPI :

uvicorn main:app --reload

Maintenant, l'application FastAPI est en cours d'exécution. Ouvrez le navigateur et visitez http://localhost:8000, et vous verrez la réponse « Hello, World ! »

4. Écrire des fonctions de traitement asynchrone

FastAPI prend en charge l'utilisation de fonctions de traitement asynchrone pour gérer les requêtes. Voici un exemple d'utilisation d'une fonction de traitement asynchrone :

from fastapi import FastAPI
import asyncio

app = FastAPI()

async def background_task():
    while True:
        print("Running background task...")
        await asyncio.sleep(1)

@app.get("/")
async def root():
    asyncio.create_task(background_task())
    return {"message": "Hello, World!"}

Dans le code ci-dessus, nous définissons une tâche asynchrone background_task(), qui imprimera "Exécution d'une tâche en arrière-plan..." chaque seconde. Dans la fonction de gestionnaire de la route racine "/", nous utilisons asyncio.create_task() pour créer une tâche en arrière-plan. De cette façon, lors de l'accès au répertoire racine, l'exécution de background_task() sera lancée en même temps.

5. Traitement des paramètres de requête

FastAPI prend en charge la transmission des paramètres via les paramètres de chemin d'URL, les paramètres de requête, les corps de requête, etc., ce qui est très flexible. Voici un exemple d'utilisation des paramètres de chemin d'URL et des paramètres de requête :

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
async def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

Dans le code ci-dessus, nous définissons une route de requête GET avec le paramètre de chemin item_id et le paramètre de requête q. Lors de l'accès, par exemple, à /items/42?q=test, la réponse suivante sera renvoyée :

{
    "item_id": 42,
    "q": "test"
}

6. Opérations de base de données asynchrones

FastAPI prend intrinsèquement en charge les opérations asynchrones et peut facilement interagir avec les bases de données asynchrones. Voici un exemple d'utilisation d'opérations de base de données asynchrones :

from fastapi import FastAPI
from databases import Database

app = FastAPI()
database = Database("sqlite:///test.db")

@app.on_event("startup")
async def startup():
    await database.connect()

@app.on_event("shutdown")
async def shutdown():
    await database.disconnect()

@app.get("/")
async def root():
    query = "SELECT * FROM items"
    items = await database.fetch_all(query)
    return {"items": items}

Dans le code ci-dessus, nous utilisons la bibliothèque de bases de données pour créer une connexion à la base de données SQLite et effectuer des opérations de connexion et de déconnexion lorsque l'application démarre et s'arrête. Dans la fonction de gestionnaire de la route racine, nous exécutons une requête SELECT et renvoyons les résultats.

7. Déployer des applications

Utilisez des outils tels que uvicorn, Gunicorn, etc. pour déployer des applications FastAPI dans l'environnement de production. Par exemple, utilisez Gunicorn pour déployer une application FastAPI :

gunicorn -w 4 -k uvicorn.workers.UvicornWorker main:app

La commande ci-dessus démarrera 4 processus et utilisera UvicornWorker pour gérer les requêtes.

Résumé

FastAPI est un framework Web moderne très puissant qui peut nous aider à créer des applications Web asynchrones et hautes performances. En tirant parti des fonctionnalités de programmation asynchrone de Python, nous pouvons facilement gérer un grand nombre de requêtes simultanées et réaliser des opérations de base de données efficaces. Que vous développiez un projet personnel ou que vous construisiez une application au niveau de l'entreprise, FastAPI est une option qui vaut la peine d'être essayée.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!