Wie kann httpx sichere und effiziente Downstream-HTTP-Anfragen in FastAPI verbessern?

Downstream-HTTP-Anfragen sicher in FastAPI mit httpx erstellen

Beim Erstellen von HTTP-Anfragen in FastAPI mithilfe der Standard-Python-Anfragebibliothek wird die Thread-Sicherheit bei gleichzeitigen Anfragen zu einem Problem. Um dieses Problem effektiv anzugehen, sollten Sie den Einsatz von httpx in Betracht ziehen, einer Bibliothek, die sowohl Thread-Sicherheit als auch verbesserte Leistung bietet.

Verwendung der httpx-Async-API

httpx verfügt über eine asynchrone API, die Ihnen eine einfache Erstellung ermöglicht HTTP-Anfragen bei gleichzeitiger effizienter Bearbeitung mehrerer gleichzeitiger Aufgaben. Hier ist ein Beispiel für die Verwendung innerhalb eines FastAPI-Endpunkts:

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

In diesem Beispiel:

• startup_event() initialisiert und speichert einen freigegebenen httpx AsyncClient im Status der App.
• shutdown_event() schließt den Client beim Herunterfahren der Anwendung ordnungsgemäß.
• home() führt mithilfe des gemeinsam genutzten Clients eine HTTP-Anfrage an https://www.example.com aus und nutzt Streaming, um große Antworten effizient zu verarbeiten.

Verwendung der httpx Synchronous API

If Das Definieren von Endpunkten mit async def ist nicht erwünscht, die Entscheidung für die synchrone API von httpx wird notwendig. Dieser Ansatz gewährleistet die Thread-Sicherheit und vereinfacht die Endpunktimplementierung:

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)

In diesem Beispiel verarbeitet die synchrone API HTTP-Anfragen innerhalb eines Try/Except-Blocks und ermöglicht so eine ordnungsgemäße Behandlung aller Ausnahmen, die während der Anfrage auftreten können.

Zusätzliche Funktionen und Überlegungen

• Vorteile der Async-API: Die asynchrone API bietet überlegene Leistung und skaliert effizienter bei gleichzeitigen Anfragen.
• Streaming-Antworten: Verwenden Sie Streaming-Antworten, wenn Sie große Datenmengen in Anfragen oder Antworten verarbeiten.
• Verbindungspool steuern: Sie können die Nutzung des Verbindungspools optimieren, indem Sie beim Erstellen des httpx das Argument „Limits“ festlegen Client.
• Thread-Sicherheit: httpx ist threadsicher und gewährleistet eine zuverlässige Ausführung über mehrere Threads hinweg.

Durch die Nutzung von httpx und seinen Funktionen können Sie kann sicher nachgelagerte HTTP-Anfragen innerhalb von FastAPI stellen, mehrere gleichzeitige Aufgaben nahtlos bearbeiten und die Anwendungsstabilität gewährleisten.

Das obige ist der detaillierte Inhalt vonWie kann httpx sichere und effiziente Downstream-HTTP-Anfragen in FastAPI verbessern?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!