FastAPI-Datenbankintegration: Ein tiefer Einblick in asynchrone Datenbankoperationen

In der Welt der modernen Webentwicklung ist Leistung nicht nur ein Feature, sondern eine grundlegende Anforderung. Benutzer erwarten schnelle, reaktionsfähige Anwendungen, und Entwickler suchen ständig nach Werkzeugen und Techniken, um diese Erwartungen zu erfüllen. FastAPI hat sich als Kraftpaket im Python-Ökosystem etabliert und wird für seine unglaubliche Geschwindigkeit gefeiert, die größtenteils auf seiner asynchronen Natur beruht. Ein schnelles Framework ist jedoch nur ein Teil der Gleichung. Wenn Ihre Anwendung die meiste Zeit damit verbringt, auf eine langsame Datenbank zu warten, haben Sie einen Hochleistungsmotor geschaffen, der im Stau steckt.

Hier werden asynchrone Datenbankoperationen entscheidend. Indem Sie Ihrer FastAPI-Anwendung ermöglichen, Datenbankabfragen zu bearbeiten, ohne den gesamten Prozess zu blockieren, können Sie echte Parallelität freisetzen und Anwendungen erstellen, die nicht nur schnell, sondern auch hochgradig skalierbar sind. Dieser umfassende Leitfaden führt Sie durch das Warum, Was und Wie der Integration asynchroner Datenbanken mit FastAPI und befähigt Sie, wirklich hochleistungsfähige Dienste für ein globales Publikum zu entwickeln.

Das Kernkonzept: Warum asynchrones I/O wichtig ist

Bevor wir uns dem Code zuwenden, ist es entscheidend, das grundlegende Problem zu verstehen, das asynchrone Operationen lösen: I/O-gebundenes Warten.

Stellen Sie sich einen hochqualifizierten Koch in einer Küche vor. In einem synchronen (oder blockierenden) Modell würde dieser Koch eine Aufgabe nach der anderen ausführen. Er würde einen Topf Wasser auf den Herd stellen, um es zum Kochen zu bringen, und dann daneben stehen und zusehen, bis es kocht. Erst nachdem das Wasser kocht, würde er mit dem Schneiden von Gemüse fortfahren. Das ist unglaublich ineffizient. Die Zeit des Kochs (die CPU) wird während der Wartezeit (der I/O-Operation) verschwendet.

Betrachten wir nun ein asynchrones (nicht-blockierendes) Modell. Der Koch stellt das Wasser zum Kochen auf und beginnt, anstatt zu warten, sofort mit dem Schneiden von Gemüse. Er könnte auch ein Blech in den Ofen schieben. Er kann zwischen den Aufgaben wechseln und an mehreren Fronten Fortschritte machen, während er auf langsamere Operationen (wie das Kochen von Wasser oder das Backen) wartet. Wenn eine Aufgabe abgeschlossen ist (das Wasser kocht), wird der Koch benachrichtigt und kann mit dem nächsten Schritt für dieses Gericht fortfahren.

In einer Webanwendung entsprechen Datenbankabfragen, API-Aufrufe und das Lesen von Dateien dem Warten auf kochendes Wasser. Eine traditionelle synchrone Anwendung würde eine Anfrage bearbeiten, eine Abfrage an die Datenbank senden und dann untätig bleiben und alle anderen eingehenden Anfragen blockieren, bis die Datenbank antwortet. Eine asynchrone Anwendung, die von Pythons `asyncio` und Frameworks wie FastAPI angetrieben wird, kann Tausende von gleichzeitigen Verbindungen verwalten, indem sie effizient zwischen ihnen wechselt, wann immer eine auf I/O wartet.

Hauptvorteile asynchroner Datenbankoperationen:

• Erhöhte Gleichzeitigkeit: Eine deutlich größere Anzahl von gleichzeitigen Benutzern mit denselben Hardwareressourcen bewältigen.
• Verbesserter Durchsatz: Mehr Anfragen pro Sekunde verarbeiten, da die Anwendung nicht auf die Datenbank warten muss.
• Verbesserte Benutzererfahrung: Schnellere Antwortzeiten führen zu einer reaktionsfähigeren und zufriedenstellenderen Erfahrung für den Endbenutzer.
• Ressourceneffizienz: Bessere Auslastung von CPU und Speicher, was zu geringeren Infrastrukturkosten führen kann.

Einrichten Ihrer asynchronen Entwicklungsumgebung

Um loszulegen, benötigen Sie einige Schlüsselkomponenten. Wir werden PostgreSQL als unsere Datenbank für diese Beispiele verwenden, da es eine ausgezeichnete Unterstützung für asynchrone Treiber hat. Die Prinzipien gelten jedoch auch für andere Datenbanken wie MySQL und SQLite, die über asynchrone Treiber verfügen.

1. Kernframework und Server

Installieren Sie zuerst FastAPI und einen ASGI-Server wie Uvicorn.

            pip install fastapi uvicorn[standard]
            

              
                Copy
              
            
          

2. Auswahl Ihres asynchronen Datenbank-Toolkits

Sie benötigen zwei Hauptkomponenten, um asynchron mit Ihrer Datenbank zu kommunizieren:

1. Ein asynchroner Datenbanktreiber: Dies ist die Low-Level-Bibliothek, die über ein asynchrones Protokoll mit der Datenbank kommuniziert. Für PostgreSQL ist asyncpg der De-facto-Standard und bekannt für seine unglaubliche Leistung.
2. Ein asynchroner Query Builder oder ORM: Dieser bietet eine abstraktere, Python-freundlichere Möglichkeit, Ihre Abfragen zu schreiben. Wir werden zwei beliebte Optionen untersuchen:
   • databases: Ein einfacher, leichtgewichtiger asynchroner Query Builder, der eine saubere API für die Ausführung von rohem SQL bietet.
   • SQLAlchemy 2.0+: Die neuesten Versionen des leistungsstarken und funktionsreichen SQLAlchemy ORM enthalten native, erstklassige Unterstützung für `asyncio`. Dies ist oft die bevorzugte Wahl für komplexe Anwendungen.

3. Installation

Lassen Sie uns die notwendigen Bibliotheken installieren. Sie können eines der Toolkits wählen oder beide installieren, um zu experimentieren.

Für PostgreSQL mit SQLAlchemy und `databases`:

            # Treiber für PostgreSQL
pip install asyncpg

# Für den SQLAlchemy 2.0+ Ansatz
pip install sqlalchemy

# Für den 'databases' Bibliotheks-Ansatz
pip install databases[postgresql]
            

              
                Copy
              
            
          

Mit unserer vorbereiteten Umgebung wollen wir nun untersuchen, wie man diese Werkzeuge in eine FastAPI-Anwendung integriert.

Strategie 1: Einfachheit mit der `databases`-Bibliothek

Die databases-Bibliothek ist ein ausgezeichneter Ausgangspunkt. Sie ist auf Einfachheit ausgelegt und bietet einen dünnen Wrapper über den zugrunde liegenden asynchronen Treibern, der Ihnen die Leistungsfähigkeit von asynchronem rohem SQL ohne die Komplexität eines vollständigen ORMs bietet.

Schritt 1: Datenbankverbindung und Lebenszyklus-Management

In einer realen Anwendung möchten Sie nicht bei jeder Anfrage eine Verbindung zur Datenbank herstellen und trennen. Das ist ineffizient. Stattdessen werden wir beim Start der Anwendung einen Verbindungspool einrichten und ihn beim Herunterfahren ordnungsgemäß schließen. Die Event-Handler von FastAPI (`@app.on_event("startup")` und `@app.on_event("shutdown")`) sind dafür perfekt geeignet.

Erstellen wir eine Datei mit dem Namen main_databases.py:

            import databases
import sqlalchemy
from fastapi import FastAPI

# --- Datenbankkonfiguration ---
# Ersetzen Sie dies durch Ihre tatsächliche Datenbank-URL
# Format für asyncpg: "postgresql+asyncpg://user:password@host/dbname"
DATABASE_URL = "postgresql+asyncpg://user:password@localhost/testdb"

database = databases.Database(DATABASE_URL)

# SQLAlchemy-Modell-Metadaten (zur Tabellenerstellung)
metadata = sqlalchemy.MetaData()

# Definieren einer Beispieltabelle
notes = sqlalchemy.Table(
    "notes",
    metadata,
    sqlalchemy.Column("id", sqlalchemy.Integer, primary_key=True),
    sqlalchemy.Column("title", sqlalchemy.String(100)),
    sqlalchemy.Column("content", sqlalchemy.String(500)),
)

# Erstellen einer Engine zur Tabellenerstellung (dieser Teil ist synchron)
# Die 'databases'-Bibliothek handhabt keine Schemaerstellung
engine = sqlalchemy.create_engine(DATABASE_URL.replace("+asyncpg", ""))
metadata.create_all(engine)

# --- FastAPI-Anwendung ---
app = FastAPI(title="FastAPI mit Databases-Bibliothek")

@app.on_event("startup")
async def startup():
    print("Verbinde mit der Datenbank...")
    await database.connect()
    print("Datenbankverbindung hergestellt.")

@app.on_event("shutdown")
async def shutdown():
    print("Trenne von der Datenbank...")
    await database.disconnect()
    print("Datenbankverbindung geschlossen.")

# --- API-Endpunkte ---
@app.get("/")
def read_root():
    return {"message": "Willkommen bei der Async Database API!"}

            

              
                Copy
              
            
          

Wichtige Punkte:

• Wir definieren die DATABASE_URL mit dem postgresql+asyncpg-Schema.
• Ein globales database-Objekt wird erstellt.
• Der startup-Event-Handler ruft await database.connect() auf, was den Verbindungspool initialisiert.
• Der shutdown-Event-Handler ruft await database.disconnect() auf, um alle Verbindungen sauber zu schließen.

Schritt 2: Implementierung asynchroner CRUD-Endpunkte

Fügen wir nun Endpunkte hinzu, um Create-, Read-, Update- und Delete- (CRUD) Operationen durchzuführen. Wir werden auch Pydantic für die Datenvalidierung und -serialisierung verwenden.

Fügen Sie Folgendes zu Ihrer main_databases.py-Datei hinzu:

            from pydantic import BaseModel
from typing import List, Optional
from fastapi import HTTPException

# --- Pydantic-Modelle zur Datenvalidierung ---
class NoteIn(BaseModel):
    title: str
    content: str

class Note(BaseModel):
    id: int
    title: str
    content: str

# --- CRUD-Endpunkte ---

@app.post("/notes/", response_model=Note)
async def create_note(note: NoteIn):
    """Erstellt eine neue Notiz in der Datenbank."""
    query = notes.insert().values(title=note.title, content=note.content)
    last_record_id = await database.execute(query)
    return {**note.dict(), "id": last_record_id}

@app.get("/notes/", response_model=List[Note])
async def read_all_notes():
    """Ruft alle Notizen aus der Datenbank ab."""
    query = notes.select()
    return await database.fetch_all(query)

@app.get("/notes/{note_id}", response_model=Note)
async def read_note(note_id: int):
    """Ruft eine einzelne Notiz anhand ihrer ID ab."""
    query = notes.select().where(notes.c.id == note_id)
    result = await database.fetch_one(query)
    if result is None:
        raise HTTPException(status_code=404, detail="Notiz nicht gefunden")
    return result

@app.put("/notes/{note_id}", response_model=Note)
async def update_note(note_id: int, note: NoteIn):
    """Aktualisiert eine bestehende Notiz."""
    query = (
        notes.update()
        .where(notes.c.id == note_id)
        .values(title=note.title, content=note.content)
    )
    result = await database.execute(query)
    if result == 0:
        raise HTTPException(status_code=404, detail="Notiz nicht gefunden")
    return {**note.dict(), "id": note_id}

@app.delete("/notes/{note_id}")
async def delete_note(note_id: int):
    """Löscht eine Notiz anhand ihrer ID."""
    query = notes.delete().where(notes.c.id == note_id)
    result = await database.execute(query)
    if result == 0:
        raise HTTPException(status_code=404, detail="Notiz nicht gefunden")
    return {"message": "Notiz erfolgreich gelöscht"}


            

              
                Copy
              
            
          

Analyse der asynchronen Aufrufe:

• await database.execute(query): Wird für Operationen verwendet, die keine Zeilen zurückgeben, wie INSERT, UPDATE und DELETE. Es gibt die Anzahl der betroffenen Zeilen oder den Primärschlüssel des neuen Datensatzes zurück.
• await database.fetch_all(query): Wird für SELECT-Abfragen verwendet, bei denen Sie mehrere Zeilen erwarten. Es gibt eine Liste von Datensätzen zurück.
• await database.fetch_one(query): Wird für SELECT-Abfragen verwendet, bei denen Sie höchstens eine Zeile erwarten. Es gibt einen einzelnen Datensatz oder None zurück.

Beachten Sie, dass jeder Datenbankinteraktion await vorangestellt ist. Das ist die Magie, die es der Ereignisschleife ermöglicht, zu anderen Aufgaben zu wechseln, während sie auf die Antwort der Datenbank wartet, und so eine hohe Gleichzeitigkeit ermöglicht.

Strategie 2: Das moderne Kraftpaket – SQLAlchemy 2.0+ Async ORM

Während die databases-Bibliothek für ihre Einfachheit großartig ist, profitieren viele große Anwendungen von einem voll ausgestatteten Object-Relational Mapper (ORM). Ein ORM ermöglicht es Ihnen, mit Datenbankdatensätzen als Python-Objekte zu arbeiten, was die Produktivität der Entwickler und die Wartbarkeit des Codes erheblich verbessern kann. SQLAlchemy ist das leistungsstärkste ORM in der Python-Welt, und seine Versionen 2.0+ bieten eine hochmoderne native asynchrone Schnittstelle.

Schritt 1: Einrichten der asynchronen Engine und Session

Der Kern der asynchronen Funktionalität von SQLAlchemy liegt in der AsyncEngine und AsyncSession. Die Einrichtung unterscheidet sich geringfügig von der synchronen Version.

Wir werden unseren Code für eine bessere Struktur in einige Dateien aufteilen: database.py, models.py, schemas.py, und main_sqlalchemy.py.

database.py:

            from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession
from sqlalchemy.orm import sessionmaker

DATABASE_URL = "postgresql+asyncpg://user:password@localhost/testdb"

# Erstellen einer asynchronen Engine
engine = create_async_engine(DATABASE_URL, echo=True)

# Erstellen einer Session-Factory
# expire_on_commit=False verhindert, dass Attribute nach dem Commit ablaufen
AsyncSessionLocal = sessionmaker(
    bind=engine, class_=AsyncSession, expire_on_commit=False
)

            

              
                Copy
              
            
          

models.py:

            from sqlalchemy import Column, Integer, String
from sqlalchemy.orm import declarative_base

Base = declarative_base()

class Note(Base):
    __tablename__ = "notes"

    id = Column(Integer, primary_key=True, index=True)
    title = Column(String(100), index=True)
    content = Column(String(500))

            

              
                Copy
              
            
          

schemas.py (Pydantic-Modelle):

            from pydantic import BaseModel

class NoteBase(BaseModel):
    title: str
    content: str

class NoteCreate(NoteBase):
    pass

class Note(NoteBase):
    id: int

    class Config:
        orm_mode = True

            

              
                Copy
              
            
          

Der `orm_mode = True` in der Config-Klasse des Pydantic-Modells ist ein entscheidender Zauber. Er weist Pydantic an, die Daten nicht nur aus Dictionaries, sondern auch aus ORM-Modellattributen zu lesen.

Schritt 2: Sessions mit Dependency Injection verwalten

Die empfohlene Methode zur Verwaltung von Datenbanksitzungen in FastAPI ist die Dependency Injection. Wir erstellen eine Abhängigkeit, die eine Datenbanksitzung für eine einzelne Anfrage bereitstellt und sicherstellt, dass sie danach geschlossen wird, auch wenn ein Fehler auftritt.

Fügen Sie dies zu Ihrer main_sqlalchemy.py hinzu:

            from fastapi import Depends, FastAPI, HTTPException
from sqlalchemy.ext.asyncio import AsyncSession
from sqlalchemy.future import select

from . import models, schemas
from .database import engine, AsyncSessionLocal

app = FastAPI()

# --- Abhängigkeit zum Abrufen einer DB-Sitzung ---
async def get_db() -> AsyncSession:
    async with AsyncSessionLocal() as session:
        try:
            yield session
        finally:
            await session.close()

# --- Datenbankinitialisierung (zur Erstellung von Tabellen) ---
@app.on_event("startup")
async def startup_event():
    print("Initialisiere Datenbankschema...")
    async with engine.begin() as conn:
        # await conn.run_sync(models.Base.metadata.drop_all)
        await conn.run_sync(models.Base.metadata.create_all)
    print("Datenbankschema initialisiert.")

            

              
                Copy
              
            
          

Die get_db-Abhängigkeit ist ein Eckpfeiler dieses Musters. Für jede Anfrage an einen Endpunkt, der sie verwendet, wird sie:

1. Eine neue AsyncSession erstellen.
2. Die Sitzung an die Endpunkt-Funktion yielden.
3. Der Code im finally-Block stellt sicher, dass die Sitzung geschlossen wird und die Verbindung zum Pool zurückkehrt, unabhängig davon, ob die Anfrage erfolgreich war oder nicht.

Schritt 3: Implementierung von asynchronem CRUD mit SQLAlchemy ORM

Jetzt können wir unsere Endpunkte schreiben. Sie werden sauberer und objektorientierter aussehen als der rohe SQL-Ansatz.

Fügen Sie diese Endpunkte zu main_sqlalchemy.py hinzu:

            
@app.post("/notes/", response_model=schemas.Note)
async def create_note(
    note: schemas.NoteCreate, db: AsyncSession = Depends(get_db)
):
    db_note = models.Note(title=note.title, content=note.content)
    db.add(db_note)
    await db.commit()
    await db.refresh(db_note)
    return db_note

@app.get("/notes/", response_model=list[schemas.Note])
async def read_all_notes(skip: int = 0, limit: int = 100, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).offset(skip).limit(limit))
    notes = result.scalars().all()
    return notes

@app.get("/notes/{note_id}", response_model=schemas.Note)
async def read_note(note_id: int, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Notiz nicht gefunden")
    return db_note

@app.put("/notes/{note_id}", response_model=schemas.Note)
async def update_note(
    note_id: int, note: schemas.NoteCreate, db: AsyncSession = Depends(get_db)
):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Notiz nicht gefunden")
    
    db_note.title = note.title
    db_note.content = note.content
    await db.commit()
    await db.refresh(db_note)
    return db_note

@app.delete("/notes/{note_id}")
async def delete_note(note_id: int, db: AsyncSession = Depends(get_db)):
    result = await db.execute(select(models.Note).filter(models.Note.id == note_id))
    db_note = result.scalar_one_or_none()
    if db_note is None:
        raise HTTPException(status_code=404, detail="Notiz nicht gefunden")
    
    await db.delete(db_note)
    await db.commit()
    return {"message": "Notiz erfolgreich gelöscht"}

            

              
                Copy
              
            
          

Analyse des asynchronen SQLAlchemy-Musters:

• db: AsyncSession = Depends(get_db): Dies injiziert unsere Datenbanksitzung in den Endpunkt.
• await db.execute(...): Dies ist die primäre Methode zum Ausführen von Abfragen.
• result.scalars().all() / result.scalar_one_or_none(): Diese Methoden werden verwendet, um die eigentlichen ORM-Objekte aus dem Abfrageergebnis zu extrahieren.
• db.add(obj): Bereitet ein Objekt zum Einfügen vor.
• await db.commit(): Führt die Transaktion asynchron in der Datenbank aus. Dies ist ein entscheidender `await`-Punkt.
• await db.refresh(obj): Aktualisiert das Python-Objekt mit allen neuen Daten aus der Datenbank nach dem Commit (wie der automatisch generierten ID).

Überlegungen zur Leistung und Best Practices

Die einfache Verwendung von `async` und `await` ist ein großartiger Anfang, aber um wirklich robuste und hochleistungsfähige Anwendungen zu erstellen, sollten Sie diese Best Practices berücksichtigen.

1. Connection Pooling verstehen

Sowohl databases als auch die AsyncEngine von SQLAlchemy verwalten im Hintergrund einen Verbindungspool. Dieser Pool hält einen Satz offener Datenbankverbindungen bereit, die von verschiedenen Anfragen wiederverwendet werden können. Dies vermeidet den teuren Overhead des Aufbaus einer neuen TCP-Verbindung und der Authentifizierung bei der Datenbank für jede einzelne Abfrage. Sie können die Poolgröße (z. B. `pool_size`, `max_overflow`) in der Engine-Konfiguration für Ihre spezifische Arbeitslast anpassen.

2. Niemals synchrone und asynchrone Datenbankaufrufe mischen

Die wichtigste Regel ist, niemals eine synchrone, blockierende I/O-Funktion innerhalb einer `async def`-Funktion aufzurufen. Ein standardmäßiger, synchroner Datenbankaufruf (z. B. mit `psycopg2` direkt) blockiert die gesamte Ereignisschleife, friert Ihre Anwendung ein und macht den Zweck von async zunichte.

Wenn Sie unbedingt einen synchronen Codeabschnitt ausführen müssen (vielleicht eine CPU-gebundene Bibliothek), verwenden Sie `run_in_threadpool` von FastAPI, um das Blockieren der Ereignisschleife zu vermeiden:

            from fastapi.concurrency import run_in_threadpool

@app.get("/run-sync-task/")
async def run_sync_task():
    # 'some_blocking_io_function' ist eine reguläre synchrone Funktion
    result = await run_in_threadpool(some_blocking_io_function, arg1, arg2)
    return {"result": result}

            

              
                Copy
              
            
          

3. Asynchrone Transaktionen verwenden

Wenn eine Operation mehrere Datenbankänderungen umfasst, die zusammen erfolgreich sein oder fehlschlagen müssen (eine atomare Operation), müssen Sie eine Transaktion verwenden. Beide Bibliotheken unterstützen dies durch einen asynchronen Kontextmanager.

Mit `databases`:

            async def transfer_funds():
    async with database.transaction():
        await database.execute(query_for_debit)
        await database.execute(query_for_credit)

            

              
                Copy
              
            
          

Mit SQLAlchemy:

            async def transfer_funds(db: AsyncSession = Depends(get_db)):
    async with db.begin(): # Dies startet eine Transaktion
        # Konten finden
        account_from = ...
        account_to = ...
        # Salden aktualisieren
        account_from.balance -= 100
        account_to.balance += 100
    # Die Transaktion wird beim Verlassen des Blocks automatisch committet
    # oder bei einer Ausnahme zurückgerollt.

            

              
                Copy
              
            
          

4. Nur das Notwendige auswählen

Vermeiden Sie `SELECT *`, wenn Sie nur wenige Spalten benötigen. Die Übertragung von weniger Daten über das Netzwerk reduziert die I/O-Wartezeit. Mit SQLAlchemy können Sie `options(load_only(model.col1, model.col2))` verwenden, um anzugeben, welche Spalten abgerufen werden sollen.

Fazit: Die asynchrone Zukunft annehmen

Die Integration asynchroner Datenbankoperationen in Ihre FastAPI-Anwendung ist der Schlüssel, um ihr volles Leistungspotenzial auszuschöpfen. Indem Sie sicherstellen, dass Ihre Anwendung nicht blockiert, während sie auf die Datenbank wartet, können Sie Dienste erstellen, die unglaublich schnell, skalierbar und effizient sind und in der Lage sind, eine globale Benutzerbasis ohne große Anstrengung zu bedienen.

Wir haben zwei leistungsstarke Strategien untersucht:

• Die `databases`-Bibliothek bietet einen unkomplizierten, leichtgewichtigen Ansatz für Entwickler, die das Schreiben von SQL bevorzugen und eine einfache, schnelle asynchrone Schnittstelle benötigen.
• SQLAlchemy 2.0+ bietet ein voll ausgestattetes, robustes ORM mit einer nativen asynchronen API und ist somit die ideale Wahl für komplexe Anwendungen, bei denen Entwicklerproduktivität und Wartbarkeit an erster Stelle stehen.

Die Wahl zwischen ihnen hängt von den Anforderungen Ihres Projekts ab, aber das Kernprinzip bleibt dasselbe: Denken Sie nicht-blockierend. Indem Sie diese Muster und Best Practices übernehmen, schreiben Sie nicht nur Code; Sie entwerfen Systeme für die hohen Gleichzeitigkeitsanforderungen des modernen Webs. Beginnen Sie noch heute mit dem Bau Ihrer nächsten hochleistungsfähigen FastAPI-Anwendung und erleben Sie die Kraft von asynchronem Python aus erster Hand.