Jak zpracováváte WebSockets v FastAPI?

Question

Accepted Answer

FastAPI podporuje **WebSockets** pro komunikaci v reálném čase v obou směrech (chat, živé aktualizace, oznámení) prostřednictvím dekorátoru `@app.websocket`. Na rozdíl od HTTP modelu požadavek-odpověď zůstává připojení WebSocket otevřené, což umožňuje serveru a klientovi volně si posílat zprávy.

## Základní koncový bod WebSocket

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

Vzor: `accept()` připojení, pak smyčka — `receive_text()`/`receive_json()` čte zprávy, `send_text()`/`send_json()` je posílá. Výjimka `WebSocketDisconnect` signalizuje, že klient odešel (kde provádíte vyčištění).

## Vysílání více klientům (např. 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
```

Správa seznamu aktivních připojení vám umožňuje **vysílat** všem klientům — základ chatovacích a živých aktualizačních funkcí.

## Upozornění na škálování

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

## Proč to záleží

WebSockets umožňují **komunikaci v reálném čase v obou směrech** — chat, živá oznámení, přítomnost, kolaborativní úpravy, živé řídicí panely — což HTTP model požadavek-odpověď nemůže poskytnout (server může posílat klientům, ne jen reagovat).

Pochopení podpory WebSocket v FastAPI je cenné pro vytváření moderních interaktivních aplikací: dekorátor `@app.websocket` se smyčkou accept/receive/send pokrývá základní komunikaci v reálném čase a správa aktivních připojení umožňuje **vysílání** (základ víceuživatelských funkcí jako chat).

Asynchronní základ FastAPI se dobře hodí pro WebSockets.

Kriticky důležité je **upozornění na škálování**: připojení WebSocket jsou stavová a vázána na jednu instanci serveru, takže škálování across více instancí vyžaduje **Redis Pub/Sub backplane** k přeposílání zpráv mezi instancemi — běžná chyba, protože (jako relace) stav připojení nemůže existovat v paměti jednoho procesu při spouštění více instancí.

Znalost základního vzoru WebSocket, vysílání, zpracování odpojení a úvahy o škálování je důležitá znalost na úrovni senior pro vytváření zkušeností v reálném čase a interaktivních aplikací, které jsou stále více očekávány v moderních aplikacích.