Comment httpx peut-il améliorer les requêtes HTTP en aval sûres et efficaces dans FastAPI ?

Effectuer des requêtes HTTP en aval en toute sécurité dans FastAPI à l'aide de httpx

Lors de l'exécution de requêtes HTTP dans FastAPI à l'aide de la bibliothèque de requêtes Python standard, la sécurité des threads devient une préoccupation parmi les requêtes simultanées. Pour résoudre ce problème efficacement, envisagez d'utiliser httpx, une bibliothèque qui offre à la fois la sécurité des threads et des performances améliorées.

Utilisation de l'API httpx Async

httpx est livré avec une API asynchrone, vous permettant de créer facilement Requêtes HTTP tout en gérant efficacement plusieurs tâches simultanées. Voici un exemple de son utilisation au sein d'un point de terminaison FastAPI :

from httpx import AsyncClient
from fastapi import FastAPI, Request

app = FastAPI()

@app.on_event("startup")
async def startup_event():
    app.state.client = AsyncClient()

@app.on_event('shutdown')
async def shutdown_event():
    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))

Dans cet exemple :

• startup_event() initialise et stocke un httpx AsyncClient partagé dans l'état de l'application.
• shutdown_event() ferme gracieusement le client lors de l'application shutdown.
• home() effectue une requête HTTP vers https://www.example.com à l'aide du client partagé, en utilisant le streaming pour gérer efficacement les réponses volumineuses.

Utilisation l'API synchrone httpx

Si la définition de points de terminaison avec async def n'est pas souhaitée, opter pour l'API synchrone de httpx devient nécessaire. Cette approche maintient la sécurité des threads et simplifie l'implémentation du point de terminaison :

from httpx import Client
from fastapi import FastAPI, Request

app = FastAPI()

@app.on_event("startup")
def startup_event():
    app.state.client = Client()

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

@app.get('/')
def home(request: Request):
    client = request.state.client
    req = client.build_request('GET', 'https://www.example.com')
    try:
        r = client.send(req)
        content_type = r.headers.get('content-type')
    except Exception as e:
        content_type = 'text/plain'
        e = str(e)

    if content_type == 'application/json':
        return r.json()
    elif content_type == 'text/plain':
        return PlainTextResponse(content=r.text)
    else:
        return Response(content=r.content)

Dans cet exemple, l'API synchrone gère les requêtes HTTP dans un bloc try/sauf, permettant une gestion gracieuse de toutes les exceptions pouvant survenir lors de la requête.

Fonctionnalités et considérations supplémentaires

• Avantages de l'API asynchrone : Le L'API asynchrone offre des performances supérieures et évolue plus efficacement avec les requêtes simultanées.
• Réponses en streaming : Utilisez les réponses en streaming lorsque vous traitez de grandes quantités de données dans des requêtes ou des réponses.
• Contrôle du pool de connexions : Vous pouvez optimiser l'utilisation du pool de connexions en définissant l'argument limites lors de la création du httpx client.
• Sécurité des threads : httpx est conçu pour être thread-safe, garantissant une exécution fiable sur plusieurs threads.

En tirant parti de httpx et de ses fonctionnalités, vous peut effectuer en toute confiance des requêtes HTTP en aval dans FastAPI, en gérant plusieurs tâches simultanées de manière transparente et en garantissant la stabilité de l'application.

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!