ASGI und Uvicorn im FastAPI-Entwicklungsprozess verstehen

Bei der Entwicklung mit FastAPI müssen wir den Uvicorn-Server verwenden. Anfänger fragen sich vielleicht warum. Heute werden wir diese Frage beantworten.

Uvicorn

Lassen Sie uns eine einfache HTTP-Anfrage mit HTTP implementieren:

import json

# Definiere eine Hilfsfunktion, um Bytes in Headern in Strings umzuwandeln
def convert_bytes_to_str(data):
    if isinstance(data, bytes):
        return data.decode('utf-8')
    if isinstance(data, tuple):
        return tuple(convert_bytes_to_str(item) for item in data)
    if isinstance(data, list):
        return [convert_bytes_to_str(item) for item in data]
    if isinstance(data, dict):
        return {key: convert_bytes_to_str(value) for key, value in data.items()}
    return data


async def app(scope, receive, send):
    # print(scope)
    data = convert_bytes_to_str(scope)
    print(json.dumps(data, indent=4))
    # Überprüfe den Typ der Anfrage
    if scope['type'] == 'http':
        # Warte auf den HTTP-Anfragekörper
        event = await receive()

        # Antwortinhalt
        response_body = json.dumps({"message": "Hallo, ASGI!"}).encode('utf-8')

        # Sende die HTTP-Antwortheader
        await send({
            'type': 'http.response.start',
           'status': 200,
            'headers': [
                (b'content-type', b'application/json'),
            ],
        })

        # Sende den HTTP-Antwortkörper
        await send({
            'type': 'http.response.body',
            'body': response_body,
        })

Das scope-Feld enthält binäre Strings, daher benötigen wir eine Konvertierungsfunktion convert_bytes_to_str. Lassen Sie uns diese kurz analysieren. Informationen zum Anfragepfad und zur Methode befinden sich in scope. Da scope mehr als nur HTTP unterstützt, müssen wir type verwenden, um den Typ des aktuellen Protokolls zu bestimmen. Dann verwenden wir die Funktion receive, um den Anfragekörper zu empfangen. Als Nächstes erstellen wir einen Antwortkörper mit json.dumps und codieren ihn mit encode. Schließlich senden wir die Anfrageheader und den Anfragekörper.

Hier senden wir die Daten zweimal. Dieses Design erfüllt die Anforderungen der asynchronen Programmierung und verbessert die Verarbeitungsfähigkeit für verschiedene Anwendungsszenarien (Streaming-Antwort). Mit einem Verständnis für reale Projekte können wir ASGI nun von einer theoretischen Basis aus verstehen.

ASGI

Das Asynchronous Server Gateway Interface (ASGI) ist ein Python-Protokoll zum Erstellen asynchroner Webanwendungen.

Hauptmerkmale von ASGI

Asynchrone Unterstützung: Ermöglicht asynchrone Programmierung.
Multi-Protokoll-Unterstützung: Unterstützt Protokolle wie WebSocket und Long-Polling, was bedeutet, dass es http/https/websocket unterstützt.
Concurrency-Unterstützung: Kann mehrere Anfragen gleichzeitig verarbeiten.
Kommunikation: Anwendungen und Server sowie verschiedene Teile einer Anwendung interagieren durch das Senden und Empfangen von Nachrichten.

Zusammensetzung des ASGI-Protokolls

Anwendungsschnittstelle
- Die ASGI-Anwendungsschnittstelle definiert, wie eine Anwendung mit einem ASGI-Server interagiert. Eine ASGI-Anwendung ist ein aufrufbares Objekt, normalerweise eine asynchrone Funktion, die zwei Parameter akzeptiert: scope und receive und einen asynchronen Generator send zurückgibt.
  - scope: Ein Dictionary, das Informationen über die Anfrage enthält, wie z. B. den Anfrage-Typ (HTTP oder WebSocket), Pfad, Query-String, Serverinformationen usw.
  - receive: Ein asynchroner Aufruf, der verwendet wird, um Ereignisse vom ASGI-Server zu empfangen.
  - send: Ein asynchroner Generator, der verwendet wird, um Ereignisse zurück an den ASGI-Server zu senden.
Serverschnittstelle
- Zu den Hauptaufgaben der Serverschnittstelle gehören:
  - Akzeptieren von Verbindungen von Clients.
  - Erstellen eines scope für jede Verbindung.
  - Aufrufen der receive- und send-Methoden der Anwendung, um Ereignisse zu übergeben.
  - Behandeln von Netzwerkfehlern und Schließen von Verbindungen.
Event-Loop-Schnittstelle
- Die Event-Loop-Schnittstelle ist ein impliziter Teil des ASGI-Protokolls. Sie wird vom ASGI-Server verwaltet und nicht direkt vom ASGI-Protokoll definiert.
- Die Event-Loop ist für die Planung und Ausführung asynchroner Aufgaben verantwortlich, was den Kern der asynchronen Programmierung darstellt. Zu ihren Hauptfunktionen gehören:
  - Ausführen und Planen asynchroner Aufgaben.
  - Verwalten asynchroner I/O-Operationen, wie z. B. Netzwerkanfragen.
  - Behandeln von Callback-Funktionen und asynchronen Generatoren.
- In ASGI wird die Event-Loop normalerweise von den folgenden Python-Bibliotheken bereitgestellt:
  - asyncio: Ein asynchrones I/O-Framework in der Python-Standardbibliothek.
  - uvloop: Eine asynchrone Event-Loop basierend auf libuv, die häufig mit dem Uvicorn-Server verwendet wird.

ASGI-Server und -Anwendungen verlassen sich auf die Event-Loop, um asynchrone Operationen auszuführen, wodurch sie eine große Anzahl gleichzeitiger Verbindungen effizient verarbeiten können.

ASGI-Ereignisse

Das ASGI-Ereignis-gesteuerte Modell verwaltet das Lebenszyklusmanagement (Start und Stopp), die HTTP-Anfragebehandlung und das WebSocket-Verbindungsmanagement. Durch verschiedene Arten von Ereignissen können Entwickler Verbindungen und Datenflüsse präzise steuern, um asynchrone und gleichzeitige Verarbeitung zu erreichen.

Lebensdauerereignisse
- Lebensdauerereignisse beziehen sich auf die Start- und Stoppzyklen einer ASGI-Anwendung. Sie werden typischerweise verwendet, um Initialisierungs- und Bereinigungsaufgaben durchzuführen.
  - lifespan.startup
  - lifespan.shutdown
HTTP-Ereignisse
- Die ASGI-Behandlung von HTTP-Anfragen ist in mehrere Ereignisse unterteilt, die die Verwaltung der Details jeder HTTP-Anfrage ermöglichen.
  - http.request
  - http.response.start
  - http.response.body
  - http.disconnect
  - websocket.send
WebSocket-Ereignisse
- ASGI unterstützt WebSocket-Verbindungen und ermöglicht so eine Zwei-Wege-Kommunikation.
  - websocket.connect
  - websocket.receive

ASGI-Lebenszyklus

Der ASGI-Anwendungslebenszyklus bezieht sich auf die Phasen, die die Anwendung während des Starts und Stopps durchläuft. Er wird über den Lebensdauerereigniskanal verwaltet.

scope['type']: lifespan
message['type']: Nachricht für Start und Stopp: lifespan.startup/lifespan.shutdown
Sendetyp: {'type': 'lifespan.shutdown.complete'}

Der ASGI-Lebenszyklus ist in zwei Teile unterteilt: den Start und Stopp der Anwendung sowie den Aufbau, die Verarbeitung, die Antwort und den Stopp von Anfragen.

Uvicorn und die Anwendungsschicht

Wie bereits erwähnt, implementiert Uvicorn die ASGI-Serverschicht. Sie ist jedoch auf der Anwendungsschicht nicht sehr benutzerfreundlich, da sie zu Low-Level ist. Daher sind viele Frameworks höherer Ebene entstanden:

Starlette: Ein leichtgewichtiges ASGI-Framework/Toolkit zum Erstellen von hochleistungsfähigen Webdiensten. Es ist eine Basiskomponente von FastAPI und kann auch unabhängig zum Erstellen einfacher Webanwendungen verwendet werden.
FastAPI: Ein modernes, schnelles (High-Performance) Webframework zum Erstellen von APIs, das mit Python 3.6+ Type-Hints verwendet wird. Es basiert auf Starlette und Standard-Python-Type-Hints und bietet automatische Datenvalidierung und -Serialisierung sowie interaktive API-Dokumentationsgenerierung.

Es besteht keine Notwendigkeit, hier auf andere Aspekte einzugehen; zu viele Informationen können überwältigend sein. Uvicorn benötigt eine app, daher ist für diese beiden Frameworks das instanziierte Objekt app. Dann verwenden wir die Uvicorn-CLI, um die Anwendung zu starten:

uvicorn main:app --reload

Zusammenfassung

Dieser Artikel untersucht hauptsächlich das Python-Web-ASGI-Protokoll über Uvicorn. ASGI ist die asynchrone Server-Gateway-Schnittstelle von Python, die die asynchronen, gleichzeitigen und Multi-Protokoll-Funktionen moderner Python-Webprogramme integriert.