Kako rokujete z WebSocketi v FastAPI-ju?

Question

Accepted Answer

FastAPI podpira **WebSockete** za komunikacijo v realnem času v obe smeri (klepet, živih posodobitve, obvestila) prek dekorerja `@app.websocket`. Za razliko od HTTP-jev zahtevek-odgovor model ostane WebSocket povezava odprta, kar omogoča strežniku in odjemalcu prosto pošiljanje sporočil.

## Osnovna WebSocket končna točka

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

Vzorec: `accept()` sprejeme povezavo, nato zanko — `receive_text()`/`receive_json()` prebere sporočila, `send_text()`/`send_json()` jih pošlje. Izjema `WebSocketDisconnect` signalizira, da je odjemalec odšel (kjer opravite čiščenje).

## Oddajanje več odjemalcem (npr. klepet)

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

Upravljanje seznama aktivnih povezav vam omogoča **oddajanje** vsem odjemalcem — osnova klepetnih in funkcij s povratnimi informacijami v realnem času.

## Opozorilo skaliranja

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

## Zakaj je to pomembno

WebSocketi omogočajo **komunikacijo v realnem času v obe smeri** — klepet, obvestila v realnem času, prisotnost, skupinsko urejanje, ogledne deske v realnem času — ki jih model zahtevek-odgovor HTTP-ja ne more zagotoviti (strežnik lahko pošilja odjemalcem, ne samo odgovarja).

Razumevanje WebSocket podpore FastAPI-ja je dragoceno za graditev sodobnih interaktivnih aplikacij: dekorator `@app.websocket` z zanko accept/receive/send pokriva osnovno komunikacijo v realnem času, upravljanje aktivnih povezav pa omogoča **oddajanje** (jedro funkcij za več uporabnikov, kot je klepet).

Asincni temelj FastAPI-ja je za WebSockete primeren.

Kritično pomembno je **opozorilo skaliranja**: WebSocket povezave so s stanjem in vezane na en sam primerek strežnika, zato skaliranje preko več primekov zahteva **Redis Pub/Sub backplane** za posredovanje sporočil med primeri — pogosta pasti, saj (kot sejami) stanje povezave ne more biti v pomnilniku enega procesa pri zagonu večih primerov.

Znanje osnovnega WebSocket vzorca, oddajanja, ravnanja z odgajanjem in razmisleka skaliranja je važno znanje na ravni starejšega razvojnika za graditev doživetij v realnem času in interaktivnih, ki se vse bolj pričakuje v sodobnih aplikacijah.