Hoe ga je om met WebSockets in FastAPI?

Question

Accepted Answer

FastAPI ondersteunt **WebSockets** voor real-time, bidirectionele communicatie (chat, live updates, notificaties) via de `@app.websocket` decorator. In tegenstelling tot HTTP's request-response blijft een WebSocket-verbinding open, waardoor server en client vrij berichten kunnen versturen.

## Een basis WebSocket-endpoint

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

Het patroon: `accept()` de verbinding, vervolgens een loop — `receive_text()`/`receive_json()` leest berichten, `send_text()`/`send_json()` verstuurt ze. Een `WebSocketDisconnect` exception geeft aan dat de client is vertrokken (waar je opruimt).

## Uitzending naar meerdere clients (bijv. 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
```

Het beheren van een lijst met actieve verbindingen stelt je in staat om naar alle clients te **broadcasten** — de basis van chat- en live-update-functies.

## Schaalbaarheidskaveat

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

## Waarom het belangrijk is

WebSockets maken **real-time, bidirectionele** functies mogelijk — chat, live notificaties, aanwezigheid, gezamenlijk bewerken, live dashboards — die het request-response model van HTTP niet kan bieden (de server kan naar clients pushen, niet alleen reageren).

Het begrijpen van FastAPI's WebSocket-ondersteuning is waardevol voor het bouwen van moderne interactieve toepassingen: de `@app.websocket` decorator met de accept/receive/send-loop dekt basisgebruik van real-time communicatie, en het beheren van actieve verbindingen maakt **uitzending** mogelijk (de kern van multi-user functies zoals chat).

De async-basis van FastAPI is goed geschikt voor WebSockets.

Kritiek belangrijk is het **schaalbaarheidskaveat**: WebSocket-verbindingen zijn statefull en gebonden aan een enkel server-exemplaar, dus schaling over meerdere exemplaren vereist een **Redis Pub/Sub backplane** om berichten tussen exemplaren door te sturen — een veelvoorkomend probleem, omdat (zoals sessies) verbindingsstatus niet in het geheugen van één proces kan leven wanneer meerdere exemplaren actief zijn.

Kennis van het basispatroon voor WebSockets, uitzending, afbreekingsbeheer en de schaalbaarheidsfactor is belangrijke kennis op senior-niveau voor het bouwen van de real-time, interactieve ervaringen die in moderne toepassingen steeds vaker worden verwacht.