HTTPX est-il une alternative plus sûre à ThreadPoolExecutor dans les points de terminaison FastAPI ?

Préoccupations liées à l'utilisation simultanée de ThreadPoolExecutor dans les points de terminaison FastAPI

Problème :

Concurrent.futures. ThreadPoolExecutor est utilisé pour le traitement parallèle, mais son impact potentiel dans une FastAPI suscite des inquiétudes. point final. Plus précisément, si plusieurs appels d'API déclenchent la création d'un trop grand nombre de threads, cela pourrait entraîner un épuisement des ressources et des plantages.

Solution :

Plutôt que de s'appuyer sur ThreadPoolExecutor, le La bibliothèque HTTPX présente une alternative plus sûre avec son API asynchrone. Grâce à HTTPX, vous pouvez créer un client et le réutiliser pour plusieurs requêtes. Pour effectuer des opérations asynchrones, un AsyncClient est recommandé.

Configuration HTTPX :

HTTPX permet de personnaliser la taille du pool de connexions et les paramètres de délai d'expiration. Par exemple :

limits = httpx.Limits(max_keepalive_connections=5, max_connections=10)
async with httpx.AsyncClient(limits=limits) as client:
    ...

Ajustez les limites et les valeurs de délai d'attente en fonction de vos besoins spécifiques.

Exécution de requêtes asynchrones :

Pour créer plusieurs requêtes asynchrones demandes, vous pouvez utiliser asyncio.gather(). Il attendra l'achèvement de chaque demande et renverra une liste de résultats dans le même ordre que les tâches fournies.

Gestion du cycle de vie :

Pour gérer les événements de durée de vie dans le Application FastAPI, pensez à utiliser la dépendance de durée de vie. Cela vous permet d'initialiser et de nettoyer les ressources, telles que le client HTTPX, lorsque l'application démarre et s'arrête.

Réponses en streaming :

Si vous devez éviter En chargeant des réponses entières en mémoire, pensez à utiliser les capacités de streaming de HTTPX et StreamingResponse de FastAPI. Cela vous permet de traiter de manière itérative des morceaux de données de réponse, offrant ainsi une meilleure évolutivité.

Exemple de code :

from fastapi import FastAPI, Request
from contextlib import asynccontextmanager
import httpx
import asyncio

URLS = ['https://www.foxnews.com/',
        'https://edition.cnn.com/',
        'https://www.nbcnews.com/',
        'https://www.bbc.co.uk/',
        'https://www.reuters.com/']

@asynccontextmanager
async def lifespan(app: FastAPI):
    # Custom settings
    client = httpx.AsyncClient(...)
    yield {'client': client}
    await client.aclose()  # Close the client on shutdown

app = FastAPI(lifespan=lifespan)

async def send(url, client):
    return await client.get(url)

@app.get('/')
async def main(request: Request):
    client = request.state.client
    tasks = [send(url, client) for url in URLS]
    responses = await asyncio.gather(*tasks)
    # Process the responses as needed (e.g., extract data, modify content)

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!