Yaya kake gudanar da WebSockets a FastAPI?

Question

Accepted Answer

FastAPI yana goyan bayan **WebSockets** don sadarwar jiya-jiya, talakici (chat, sabuntawar kai tsaye, sanarwa) ta hanyar `@app.websocket` decorator. Ba kamar HTTP ba, haɗin WebSocket yana zaune buɗe, yana ba da damar server da client incore aiki jiya-jiya.

## Kabiri WebSocket na asali

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

Alaka: `accept()` yana tanadi haɗin, sannan loop — `receive_text()`/`receive_json()` yana karantawa aiki, `send_text()`/`send_json()` yana aika su. Kwaɗi `WebSocketDisconnect` yana nuna cewa client ya waje (inda kake tsaftace).

## Watsa wa masu kasuwa da yawa (misali 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
```

Sarrafa jerin masu aiki na haɗi yana ba ka damar su **watsa** ga duk masu kasuwa — tushen chat da sabuntawa kai-tsaye.

## Ƙaƙƙoba scalin

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

## Me yasa ya zama mahimmanci

WebSockets suna ba da damar **jiya-jiya, talakici** abubuwa — chat, sanarwa kai-tsaye, kasua, gyara sadarwa, dashboard kai-tsaye — wadda alamar bubuwa-amsa na HTTP ba za ta iya ba (server na iya turawa zuwa masu kasuwa, ba kawai amsa).

Hankalin goyan bayan WebSocket na FastAPI ya zama mai kyau don gina aikace-aikacen karasa na jiya: decorator `@app.websocket` tare da accept/receive/send loop yana aiki sadarwa kai-tsaye na asali, kuma sarrafa haɗi mai aiki yana ba da damar **watsa** (tushen fasalai da yawa masu kasuwa kamar chat).

Asali mai amfani na FastAPI ya dace da WebSockets sosai.

Mahimmanci ne a mahimmanci **ƙaƙƙoba scalin**: haɗin WebSocket sune jiha-da-jiha kuma suna ɗaure zuwa misali ɗaya na server, don haka siyin scale akan misalai da yawa suna bukatar **Redis Pub/Sub backplane** don watsa aiki tsakanin misalai — maye cikin gida, saboda (kamar sauri) jiya-jiya baƙi ba za ta iya zaune a ƙwaƙwalwa na aiki gida daya ba lokacin aiki misalai da yawa.

Sanin alaka WebSocket ta asali, watsa, ɗiga keta, da ƙaƙƙoba scalin shine mahimmanci-matakala sani don gina jiya-jiya, aikace-aikace mai karasa da aka buɗe da ƙarin karɓo a aikace-aikace na jiya.