Hvordan håndterer du WebSockets i FastAPI?

Question

Accepted Answer

FastAPI understøtter **WebSockets** til kommunikation i realtid og tovejskommunikation (chat, live-opdateringer, notifikationer) via `@app.websocket`-dekoratøren. I modsætning til HTTPs request-response-model forbliver en WebSocket-forbindelse åben, hvilket tillader serveren og klienten at sende meddelelser frit.

## Et grundlæggende 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)
```

Mønstret: `accept()` forbindelsen, derefter loop — `receive_text()`/`receive_json()` læser meddelelser, `send_text()`/`send_json()` sender dem. En `WebSocketDisconnect`-undtagelse signalerer, at klienten har forladt (hvor du renser op).

## Broadcasting til flere klienter (f.eks. 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
```

Administrering af en liste over aktive forbindelser lader dig **broadcast** til alle klienter — grundlaget for chat- og live-update-funktioner.

## Skalerings-advarsel

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

## Hvorfor det betyder noget

WebSockets muliggør **realtid, tovejskommunikation** — chat, live-notifikationer, tilstedeværelse, samarbejdende redigering, live-dashboards — som HTTPs request-response-model ikke kan levere (serveren kan push til klienter, ikke bare reagere).

At forstå FastAPIs WebSocket-understøttelse er værdifuldt for at bygge moderne interaktive applikationer: `@app.websocket`-dekoratøren med accept/receive/send-loop dækker grundlæggende realtidskommunikation, og administration af aktive forbindelser muliggør **broadcasting** (grundlaget for multi-user-funktioner som chat).

FastAPIs async-fundament passer godt til WebSockets.

Kritisk vigtig er **skalerings-advarslen**: WebSocket-forbindelser er stateful og bundet til en enkelt serverinstans, så skalering på tværs af flere instanser kræver en **Redis Pub/Sub-bagplan** til at videresende meddelelser mellem instanser — en almindelig fælde, da (som sessioner) forbindelsestilstand ikke kan bo i en processs hukommelse, når der kører flere instanser.

At kende det grundlæggende WebSocket-mønster, broadcasting, disconnect-håndtering og skalerings-overvejelse er vigtig knowledge på senior-niveau for at bygge de realtid, interaktive oplevelser, som i stigende grad forventes i moderne applikationer.