Hur hanterar du WebSockets i FastAPI?

Question

Accepted Answer

FastAPI stöder **WebSockets** för realtids-, dubbelriktad kommunikation (chatt, direktuppdateringar, aviseringar) via dekoratorn `@app.websocket`. Till skillnad från HTTP:s request-response-modell förblir en WebSocket-anslutning öppen, vilket gör att servern och klienten kan skicka meddelanden fritt.

## En grundläggande 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()` anslutningen, sedan en loop — `receive_text()`/`receive_json()` läser meddelanden, `send_text()`/`send_json()` skickar dem. Ett `WebSocketDisconnect`-undantag signalerar att klienten försvann (där du gör städning).

## Broadcasting till flera klienter (t.ex. chatt)

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

Hantering av en lista över aktiva anslutningar låter dig **broadcastera** till alla klienter — grunden för chatt- och liveuppdateringsfunktioner.

## Skalningsförbehåll

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

## Varför det spelar roll

WebSockets möjliggör **realtids-, dubbelriktade** funktioner — chatt, direktaviseringar, närvaro, samarbeterad redigering, liveinstrumentpaneler — som HTTP:s request-response-modell inte kan tillhandahålla (servern kan pusha till klienter, inte bara svara).

Att förstå FastAPI:s WebSocket-stöd är värdefullt för att bygga moderna interaktiva program: dekoratorn `@app.websocket` tillsammans med accept/receive/send-loopen täcker grundläggande realtidskommunikation, och hantering av aktiva anslutningar möjliggör **broadcasting** (kärnan i multiuser-funktioner som chatt).

FastAPI:s asynkrona grund passar WebSockets väl.

Kritiskt viktigt är **skalningsförbehållet**: WebSocket-anslutningar är tillståndskänsliga och bundna till en enda serverinstans, så skalning över flera instanser kräver en **Redis Pub/Sub-backplane** för att vidarebefordra meddelanden mellan instanser — en vanlig fallgrop, eftersom (som sessioner) anslutningstillståndet inte kan finnas i en process minne när flera instanser körs.

Att känna till det grundläggande WebSocket-mönstret, broadcasting, frånkopplingshantering och skalningsövervägandet är viktig kunskap på seniornivå för att bygga de realtids-, interaktiva upplevelser som i allt större utsträckning förväntas i moderna program.