Wie verwaltet man WebSockets in FastAPI?

Question

Accepted Answer

FastAPI unterstützt **WebSockets** für Echtzeit-Bidirektional-Kommunikation (Chat, Live-Updates, Benachrichtigungen) über den `@app.websocket`-Dekorator. Im Gegensatz zu HTTPs Request-Response-Modell bleibt eine WebSocket-Verbindung offen und ermöglicht es dem Server und dem Client, frei Nachrichten zu versenden.

## Ein grundlegender WebSocket-Endpunkt

```python
from fastapi import WebSocket, WebSocketDisconnect

@app.websocket("/ws")
async def websocket_endpoint(websocket: WebSocket):
    await websocket.accept()                  # accept the connection
    try:
        while True:
            data = await websocket.receive_text()    # receive a message from the client
            await websocket.send_text(f"Echo: {data}")  # send a message back
    except WebSocketDisconnect:
        print("client disconnected")           # handle disconnection (cleanup)
```

Das Muster: `accept()` die Verbindung, dann Loop — `receive_text()`/`receive_json()` liest Nachrichten, `send_text()`/`send_json()` versendet sie. Eine `WebSocketDisconnect`-Ausnahme signalisiert, dass der Client sich abgemeldet hat (wo Sie aufräumen).

## Broadcasting an mehrere Clients (z.B. Chat)

```python
class ConnectionManager:
    def __init__(self): self.active: list[WebSocket] = []
    async def connect(self, ws): await ws.accept(); self.active.append(ws)
    def disconnect(self, ws): self.active.remove(ws)
    async def broadcast(self, msg):
        for conn in self.active:
            await conn.send_text(msg)          # send to ALL connected clients

manager = ConnectionManager()

@app.websocket("/chat")
async def chat(ws: WebSocket):
    await manager.connect(ws)
    try:
        while True:
            msg = await ws.receive_text()
            await manager.broadcast(msg)        # everyone gets the message
    except WebSocketDisconnect:
        manager.disconnect(ws)                  # remove on disconnect
```

Verwaltung einer Liste aktiver Verbindungen ermöglicht es Ihnen, **an alle Clients zu broadcasten** — die Grundlage von Chat- und Live-Update-Funktionen.

## Skalierungs-Vorbehalt

```text
⚠️ WebSocket connections are STATEFUL and live on ONE server instance.
To scale across multiple instances, use a Redis Pub/Sub (or similar) backplane so
messages/broadcasts reach clients connected to OTHER instances.
(Like sessions, don't keep connection state only in one process when scaling horizontally.)
```

## Warum es wichtig ist

WebSockets ermöglichen **Echtzeit-Bidirektional-Kommunikation** — Chat, Live-Benachrichtigungen, Präsenz, kollaborative Bearbeitung, Live-Dashboards — die HTTPs Request-Response-Modell nicht bieten kann (der Server kann zu Clients pushen, nicht nur reagieren).

FastAPIs WebSocket-Unterstützung zu verstehen ist wertvoll beim Aufbau moderner interaktiver Anwendungen: Der `@app.websocket`-Dekorator mit der accept/receive/send-Loop deckt grundlegende Echtzeit-Kommunikation ab, und die Verwaltung aktiver Verbindungen ermöglicht **Broadcasting** (die Grundlage von Multi-User-Funktionen wie Chat).

FastAPIs Async-Fundament passt gut zu WebSockets.

Kritisch wichtig ist der **Skalierungs-Vorbehalt**: WebSocket-Verbindungen sind zustandsbehaftet und an eine einzelne Serverinstanz gebunden, daher erfordert die Skalierung über mehrere Instanzen einen **Redis Pub/Sub-Backplane** zum Weiterleiten von Nachrichten zwischen Instanzen — eine häufige Falle, da (wie Sitzungen) der Verbindungszustand nicht im Speicher eines einzelnen Prozesses leben kann, wenn mehrere Instanzen laufen.

Kenntnis des grundlegenden WebSocket-Musters, Broadcasting, Disconnect-Behandlung und Skalierungs-Überlegungen ist wichtiges Senior-Level-Wissen zum Aufbau der Echtzeit-, interaktiven Erfahrungen, die zunehmend in modernen Anwendungen erwartet werden.