Cum gestionezi WebSockets în FastAPI?

Question

Accepted Answer

FastAPI suportă **WebSockets** pentru comunicație real-time, bidirecțională (chat, actualizări în direct, notificări) prin decoratorul `@app.websocket`. Spre deosebire de request-response-ul HTTP, o conexiune WebSocket rămâne deschisă, permițând serverului și clientului să trimită mesaje liber.

## Un endpoint WebSocket de bază

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

Modelul: `accept()` conexiunea, apoi o buclă — `receive_text()`/`receive_json()` citește mesajele, `send_text()`/`send_json()` le trimite. O excepție `WebSocketDisconnect` semnalează că clientul a plecat (unde cureți).

## Transmisie către mai mulți clienți (ex: 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
```

Gestionarea unei liste de conexiuni active te permite să **transmiti** către toți clienții — baza funcționalităților de chat și actualizare în direct.

## Observație privind scalabilitatea

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

## De ce este important

WebSockets permit funcționalități **real-time, bidirecționale** — chat, notificări în direct, prezență, editare colaborativă, tabele de bord în direct — pe care modelul request-response al HTTP nu le poate oferi (serverul poate trimite către clienți, nu doar să răspundă).

Înțelegerea suportului WebSocket al FastAPI este valoroasă pentru construirea aplicațiilor interactive moderne: decoratorul `@app.websocket` cu bucla accept/receive/send acoperă comunicația real-time de bază, iar gestionarea conexiunilor active permite **transmisia** (baza funcționalităților multi-utilizator cum ar fi chat).

Fundamentul asincron al FastAPI se potrivește bine cu WebSockets.

Critic important este **observația privind scalabilitatea**: conexiunile WebSocket sunt cu stare și legate de o singură instanță de server, deci scalabilitatea pe mai multe instanțe necesită un **backplane Redis Pub/Sub** pentru a retransmite mesajele între instanțe — o capcană comună, deoarece (ca și sesiunile) starea conexiunii nu poate trăi în memoria unui singur proces atunci când rulezi mai multe instanțe.

Cunoașterea modelului WebSocket de bază, transmisiei, gestionării deconectării și considerației privind scalabilitatea este cunoaștere importantă la nivel senior pentru construirea experiențelor real-time și interactive din ce în ce mai așteptate în aplicațiile moderne.