Comment gérer efficacement les requêtes HTTP en aval dans FastAPI/Uvicorn à l'aide de httpx ?

Faire des requêtes HTTP en aval dans FastAPI/Uvicorn à l'aide de httpx

Introduction

Lors de l'utilisation d'un Point de terminaison d'API dans FastAPI/Uvicorn qui s'appuie sur des requêtes HTTP externes, il est crucial de garantir une gestion sécurisée des threads concurrence. Cet article explore l'approche recommandée pour résoudre ce problème à l'aide de la bibliothèque httpx.

À l'aide de httpx

Dans les requêtes httpx, httpx propose une API asynchrone qui prend en charge plusieurs requêtes HTTP simultanées à l'aide d'un client partagé. Cela améliore les performances en réutilisant les connexions et les en-têtes.

Implémentation de httpx dans FastAPI

Pour utiliser httpx dans FastAPI, vous pouvez utiliser son AsyncClient :

from fastapi import FastAPI
from httpx import AsyncClient

app = FastAPI()
app.state.client = AsyncClient()

@app.on_event("shutdown")
async def shutdown_event():
    await app.state.client.aclose()

Dans cet exemple, un client partagé est créé dans le cadre de l'état de FastAPI, permettant d'y accéder par points de terminaison.

Exemple asynchrone

Le point de terminaison suivant effectue une requête HTTP asynchrone et renvoie la réponse au client :

from fastapi import FastAPI, StreamingResponse, BackgroundTask

@app.get("/")
async def home():
    client = app.state.client
    req = client.build_request("GET", "https://www.example.com/")
    r = await client.send(req, stream=True)
    return StreamingResponse(r.aiter_raw(), background=BackgroundTask(r.aclose))

Exemple mis à jour

Avec la dépréciation des événements de démarrage et d'arrêt, vous pouvez désormais employer un gestionnaire de durée de vie :

from fastapi import FastAPI, Request, lifespan
from starlette.background import BackgroundTask
from httpx import AsyncClient, Request

@lifespan.on_event("startup")
async def startup_handler(app: FastAPI):
    app.state.client = AsyncClient()

@lifespan.on_event("shutdown")
async def shutdown_handler():
    await app.state.client.aclose()

@app.get("/")
async def home(request: Request):
    client = request.state.client
    req = client.build_request("GET", "https://www.example.com")
    r = await client.send(req, stream=True)
    return StreamingResponse(r.aiter_raw(), background=BackgroundTask(r.aclose))

Lecture du contenu de la réponse

Si vous devez lire le contenu de la réponse côté serveur avant de l'envoyer au client, vous pouvez utiliser un générateur :

def gen():
    async for chunk in r.aiter_raw():
        yield chunk
    await r.aclose()

return StreamingResponse(gen())

Conclusion

En tirant parti de httpx et Grâce à son client asynchrone partagé, vous pouvez gérer efficacement les requêtes HTTP en aval dans FastAPI/Uvicorn, garantissant ainsi la sécurité des threads et l'optimisation des performances dans un environnement multithread.

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!