Kaip tvarkote WebSocket-us FastAPI?

Question

Accepted Answer

FastAPI palaiko **WebSocket** realiu laiku dvikryptei komunikacijai (pokalbiai, tiesioginiai atnaujinimai, pranešimai) naudojant `@app.websocket` dekoratorių. Skirtingai nei HTTP užklausa-atsakas modelis, WebSocket ryšys išlieka atidarytas, leisdamas serveriui ir klientui laisvai siųsti žinutes.

## Bazinis WebSocket galas

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

Šablonas: `accept()` ryšį, tada kilpa — `receive_text()`/`receive_json()` skaito žinutes, `send_text()`/`send_json()` jas siunčia. `WebSocketDisconnect` išimtis signalizuoja, kad klientas nuėjo (kur jūs valote).

## Transliavimas keliems klientams (pvz., pokalbis)

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

Aktyvių ryšių sąrašo valdymas leidžia jums **transliuoti** visiems klientams — pokalbių ir tiesioginio atnaujinimo funkcijų pagrindas.

## Mastelio didinimo pastaba

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

## Kodėl tai svarbu

WebSocket suteikia **realaus laiko, dvikryptes** funkcijas — pokalbius, tiesiogines pranešimus, buvimą, bendradarbiaujamą redagavimą, tiesiogines praskleidas — kurias HTTP užklausa-atsakas modelis negali suteikti (serveris gali nusiųsti į klientus, o ne tik atsakyti).

Supratimas apie FastAPI WebSocket palaikymą yra vertingas kuriant šiuolaikinės interaktyvias programas: `@app.websocket` dekoratorius su priėmimo/priėmimo/siuntimo kilpa dengia pagrindinę realaus laiko komunikaciją, o aktyvių ryšių valdymas įgalina **transliacijas** (daugialanstinio naudotojo funkcijų pagrindas, pvz., pokalbis).

FastAPI asinchroninis pagrindas gerai tinka WebSocket-ams.

Svarbu pabrėžti **mastelio didinimo pastabą**: WebSocket ryšiai yra būseni ir susieti su vienu serverio egzemplium, todėl mastelio didinimas per kelis egzempliums reikalinga **Redis Pub/Sub backplane** žinutėms releis tarp egzemplių — bendra klaidų spragą, nes (kaip ir seansai) ryšio būsena negali gyventi vieno proceso atmintyje, kai paleidžiami keli egzempliai.

Supratimas apie pagrindinį WebSocket šabloną, transliacijas, atjungimo tvarkymą ir mastelio didinimo svarbą yra svarbi aukštesnio lygio žinios kuriant realaus laiko, interaktyvias patirtis, kurios vis labiau tikėtinos šiuolaikinėse programose.