Wie kann man Downstream-HTTP-Anfragen in FastAPI/Uvicorn mithilfe von httpx effizient verarbeiten?

Downstream-HTTP-Anfragen in FastAPI/Uvicorn mit httpx erstellen

Einführung

Bei der Verwendung von an Für einen API-Endpunkt in FastAPI/Uvicorn, der auf externen HTTP-Anfragen basiert, ist es von entscheidender Bedeutung, eine threadsichere Verarbeitung sicherzustellen Parallelität. In diesem Artikel wird der empfohlene Ansatz zur Behebung dieses Problems mithilfe der httpx-Bibliothek untersucht.

Verwendung von httpx

In местоrequests bietet httpx eine asynchrone API, die mehrere gleichzeitige HTTP-Anfragen mithilfe von a unterstützt gemeinsamer Client. Dies verbessert die Leistung durch die Wiederverwendung von Verbindungen und Headern.

Implementieren von httpx in FastAPI

Um httpx in FastAPI zu verwenden, können Sie dessen AsyncClient verwenden:

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()

In diesem Beispiel wird ein gemeinsam genutzter Client als Teil des FastAPI-Status erstellt, sodass darauf zugegriffen werden kann Endpunkte.

Asynchrones Beispiel

Der folgende Endpunkt stellt eine asynchrone HTTP-Anfrage und streamt die Antwort zurück an den 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))

Aktualisiertes Beispiel

Mit der Abschaffung von Start- und Herunterfahrereignissen können Sie jetzt eine Lebensdauer verwenden Handler:

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))

Antwortinhalt lesen

Wenn Sie den Antwortinhalt auf der Serverseite lesen müssen, bevor Sie ihn an den Client senden, können Sie einen Generator verwenden :

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

return StreamingResponse(gen())

Fazit

Durch die Nutzung von httpx und seiner gemeinsamen Asynchronität Client können Sie nachgelagerte HTTP-Anfragen effizient innerhalb von FastAPI/Uvicorn verarbeiten und so Thread-Sicherheit und Leistungsoptimierung in einer Multithread-Umgebung gewährleisten.

Das obige ist der detaillierte Inhalt vonWie kann man Downstream-HTTP-Anfragen in FastAPI/Uvicorn mithilfe von httpx effizient verarbeiten?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!