Hvordan håndterer du WebSockets i FastAPI?

Question

Accepted Answer

FastAPI støtter **WebSockets** for real-time, toveis kommunikasjon (chat, live oppdateringer, varsler) via `@app.websocket` dekoratoren. I motsetning til HTTPs request-response, forblir en WebSocket-tilkobling åpen, slik at server og klient kan sende meldinger fritt.

## Et grunnleggende WebSocket-endepunkt

```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ønsteret: `accept()` tilkoblingen, deretter en løkke — `receive_text()`/`receive_json()` leser meldinger, `send_text()`/`send_json()` sender dem. Et `WebSocketDisconnect` unntak signaliserer at klienten har gått (hvor du rydder opp).

## Kringkasting 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
```

Håndtering av en liste over aktive tilkoblinger lar deg **kringkaste** til alle klienter — grunnlaget for chat- og live-oppdateringsfunksjoner.

## Skaleringsforbehold

```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 er viktig

WebSockets aktiverer **real-time, toveis** funksjoner — chat, live-varsler, tilstedeværelse, samarbeidsredigering, live dashboards — som HTTPs request-response-modell ikke kan tilby (serveren kan pushes til klienter, ikke bare svare).

Å forstå FastAPIs WebSocket-støtte er verdifullt for å bygge moderne interaktive applikasjoner: `@app.websocket` dekoratoren med accept/receive/send-løkken dekker grunnleggende real-time kommunikasjon, og håndtering av aktive tilkoblinger muliggør **kringkasting** (kjernen i multi-bruker-funksjoner som chat).

FastAPIs asynkronale grunnlag egner seg godt for WebSockets.

Kritisk viktig er **skaleringsforbehold**: WebSocket-tilkoblinger er tilstandsavhengige og knyttet til en enkelt serverinstans, så skalering på tvers av flere instanser krever en **Redis Pub/Sub-backplane** for å videreformidle meldinger mellom instanser — en vanlig felle, siden (som økter) tilkoblingstilstand ikke kan leve i en prosesss minne når du kjører flere instanser.

Å kjenne det grunnleggende WebSocket-mønsteret, kringkasting, frakobling-håndtering og skaleringshensynet er viktig seniorlevelkunnskap for å bygge de real-time, interaktive opplevelsene som i økende grad forventes i moderne applikasjoner.