Hogyan kezel WebSocketeket a FastAPI-ban?

Question

Accepted Answer

A FastAPI támogatja a **WebSocketeket** valós idejű, kétirányú kommunikációhoz (csevegés, élő frissítések, értesítések) az `@app.websocket` dekorátor segítségével. A HTTP kérés-válasz modellel ellentétben a WebSocket-kapcsolat nyitva marad, lehetővé téve a szerver és az ügyfél számára az üzenetek szabadon való küldését.

## Alapvető WebSocket végpont

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

A minta: az `accept()` fogadja a kapcsolatot, majd a ciklus — a `receive_text()`/`receive_json()` olvassa az üzeneteket, a `send_text()`/`send_json()` elküldi azokat. A `WebSocketDisconnect` kivétel jelzi, hogy az ügyfél elhagyta (ahol kitisztításod).

## Sugárzás több klienshez (pl. csevegés)

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

Az aktív kapcsolatok listájának kezelése lehetővé teszi a **sugárzást** az összes klienshez — a csevegés és élő frissítési funkciók alapja.

## Skálázási figyelmeztetés

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

## Miért fontos

A WebSocketek lehetővé teszik a **valós idejű, kétirányú** funkciókat — csevegés, élő értesítések, jelenlét, együttes szerkesztés, élő irányítópultok — amelyeket a HTTP kérés-válasz modellje nem tud biztosítani (a szerver képes üzeneteket küldeni az ügyfeleknek, nem csak válaszolni).

A FastAPI WebSocket-támogatásának megértése értékes a modern interaktív alkalmazások létrehozásához: az `@app.websocket` dekorátor az accept/receive/send ciklus mellett az alapvető valós idejű kommunikációt fedi le, az aktív kapcsolatok kezelése pedig lehetővé teszi a **sugárzást** (a többfelhasználós funkciók, például csevegés alapja).

A FastAPI aszinkron alapja jól megfelel a WebSocketeknek.

Kritikusan fontos a **skálázási figyelmeztetés**: a WebSocket-kapcsolatok állapotosak és egyetlen szerver-instanciához vannak kötve, így a több instancián átívelő skálázáshoz **Redis Pub/Sub backplane** szükséges az üzenetek instanciák közötti továbbításához — gyakori veszély, mivel (mint a munkamenetek) a kapcsolat állapota nem maradhat egyetlen folyamat memóriájában több instancia futtatásakor.

Az alapvető WebSocket-minta, a sugárzás, a kapcsolatbontás kezelése és a skálázási megfontolás ismerete fontos szeniorszintű tudás a modern alkalmazásokban egyre inkább elvárt valós idejű, interaktív élmények létrehozásához.