Unashughulikiaje WebSockets katika FastAPI?

Question

Accepted Answer

FastAPI inasaidia **WebSockets** kwa mawasiliano ya wakati halisi, ya pande mbili (chat, masasisho ya moja kwa moja, arifa) kupitia decorator ya `@app.websocket`. Tofauti na ombi-jibu la HTTP, muunganisho wa WebSocket hubaki wazi, ukiruhusu server na mteja kutuma ujumbe kwa uhuru.

## Endpoint ya msingi ya WebSocket

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

Mfumo: `accept()` muunganisho, kisha endesha mzunguko (loop) — `receive_text()`/`receive_json()` husoma ujumbe, `send_text()`/`send_json()` huutuma. Exception ya `WebSocketDisconnect` huashiria mteja ameondoka (mahali unaposafisha).

## Kutangaza kwa wateja wengi (k.m. 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
```

Kusimamia orodha ya miunganisho hai kunakuwezesha **kutangaza** kwa wateja wote — msingi wa vipengele vya chat na masasisho ya moja kwa moja.

## Onyo la upanuzi (scaling)

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

## Kwa nini ni muhimu

WebSockets huwezesha vipengele vya **wakati halisi, vya pande mbili** — chat, arifa za moja kwa moja, uwepo (presence), uhariri wa pamoja, dashibodi za moja kwa moja — ambavyo modeli ya ombi-jibu ya HTTP haiwezi kutoa (server inaweza kusukuma kwa wateja, si kujibu tu).

Kuelewa msaada wa WebSocket wa FastAPI ni jambo la thamani kwa kujenga programu za kisasa za kiushirikiano: decorator ya `@app.websocket` na mzunguko wa accept/receive/send hushughulikia mawasiliano ya msingi ya wakati halisi, na kusimamia miunganisho hai huwezesha **kutangaza** (msingi wa vipengele vya watumiaji wengi kama chat).

Msingi wa async wa FastAPI unafaa WebSockets vizuri.

La muhimu sana ni **onyo la upanuzi**: miunganisho ya WebSocket ina hali (stateful) na imefungamana na server instance moja, hivyo kupanua katika instances kadhaa kunahitaji **Redis Pub/Sub backplane** kupeleka ujumbe kati ya instances — shida ya kawaida, kwa kuwa (kama sessions) hali ya muunganisho haiwezi kukaa kwenye kumbukumbu ya mchakato mmoja unapoendesha instances kadhaa.

Kujua mfumo wa msingi wa WebSocket, kutangaza, ushughulikiaji wa kukatika, na fikra ya upanuzi ni maarifa muhimu ya kiwango cha senior kwa kujenga uzoefu wa wakati halisi, wa kiushirikiano unaozidi kutarajiwa katika programu za kisasa.