Kuinka käsittelet WebSocketeja FastAPI:ssa?

Question

Accepted Answer

FastAPI tukee **WebSocketeja** reaaliaikaiselle kaksisuuntaiselle kommunikaatiolle (chat, live-päivitykset, ilmoitukset) `@app.websocket`-dekoraattorin avulla. Toisin kuin HTTP:n request-response-malli, WebSocket-yhteys pysyy avoinna, jolloin palvelin ja asiakas voivat lähettää viestejä vapaasti.

## Perus WebSocket-päätepiste

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

Kuvio: `accept()` yhteys, sitten silmukka — `receive_text()`/`receive_json()` lukee viestejä, `send_text()`/`send_json()` lähettää ne. `WebSocketDisconnect`-poikkeus osoittaa, että asiakas poistui (jossa siivoot).

## Yleislähetys useille asiakkaille (esim. 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
```

Aktiivinten yhteyksien luettelon hallinta antaa sinulle mahdollisuuden **lähettää yleisesti** kaikille asiakkaille — chat- ja live-päivitys-ominaisuuksien perusta.

## Skaalautumisvaroitus

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

## Miksi se on tärkeää

WebSocketit mahdollistavat **reaaliaikaiset, kaksisuuntaiset** ominaisuudet — chat, live-ilmoitukset, läsnäolo, yhteistyöperusteinen muokkaus, live-koontinäytöt — joita HTTP:n request-response-malli ei voi tarjota (palvelin voi lähettää asiakkaille, ei vain vastata).

FastAPI:n WebSocket-tuen ymmärtäminen on arvokasta nykyaikaisten interaktiivisten sovellusten rakentamisessa: `@app.websocket`-dekoraattori accept/receive/send-silmukan kanssa kattaa perusreaaliaikaiset viestinnän, ja aktiivisten yhteyksien hallinta mahdollistaa **yleislähetyksen** (moninkäyttäjä-ominaisuuksien, kuten chatin, perusta).

FastAPI:n asynkroninen perusta sopii hyvin WebSocketeille.

Kriitisin tärkeä on **skaalautumisvaroitus**: WebSocket-yhteydet ovat tilallisia ja sidottuja yhteen palvelimen instanssiin, joten skaalautuminen useiden instanssien yli vaatii **Redis Pub/Sub-taustajärjestelmää** viestien välittämiseen instanssien välillä — yleinen sudenkuoppa, koska (kuten istunnot) yhteystila ei voi asua yhden prosessin muistissa useita instansseja ajettaessa.

Perus WebSocket-kuvion, yleislähetyksen, yhteyden katkaisu-käsittelyn ja skaalautumisen huomioinnin tunteminen on tärkeä johtotason tieto nykyaikaisissa sovelluksissa yhä enemmän odotettavien reaaliaikaisten, interaktiivisten kokemusten rakentamiselle.