तपाई FastAPI मा WebSockets कसरी हेर्नुहुन्छ?

Question

Accepted Answer

FastAPI ले **WebSockets** लाई real-time, bidirectional communication (chat, live updates, notifications) को लागि `@app.websocket` decorator मार्फत समर्थन गर्दछ। HTTP को request-response को विपरीत, WebSocket connection खुला रहन्छ, जसले server र client लाई स्वतन्त्र रूपमा messages पठाउन दिन्छ।

## एक आधारभूत WebSocket endpoint

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

यो pattern हो: `accept()` connection, त्यसपछि loop — `receive_text()`/`receive_json()` ले messages पढ्छ, `send_text()`/`send_json()` ले तिनीहरूलाई पठाउँछ। `WebSocketDisconnect` exception ले client गएको संकेत गर्दछ (जहाँ तपाई सफा गर्नुहुन्छ)।

## धेरै clients लाई Broadcasting गर्दै (जस्तै 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
```

सक्रिय connections को list प्रबन्ध गर्दै तपाईलाई सबै clients मा **broadcast** गर्न दिन्छ — chat र live-update features को आधार।

## Scaling caveat

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

## यो किन महत्त्वपूर्ण छ

WebSockets ले **real-time, bidirectional** features — chat, live notifications, presence, collaborative editing, live dashboards — सक्षम गर्दछ जो HTTP को request-response model प्रदान गर्न सक्दैन (server clients लाई push गर्न सक्छ, केवल respond गर्न होइन)।

FastAPI को WebSocket support बुझ्नु आधुनिक अन्तरक्रियात्मक अनुप्रयोगहरू निर्माण गर्नको लागि मूल्यवान छ: `@app.websocket` decorator accept/receive/send loop को साथ आधारभूत real-time communication लाई कभर गर्दछ, र सक्रिय connections प्रबन्ध गर्दै **broadcasting** (chat जस्तो multi-user features को मूल) सक्षम गर्दछ।

FastAPI को async foundation WebSockets को लागि राम्रो अनुकूल छ।

अत्यन्त महत्त्वपूर्ण **scaling caveat** हो: WebSocket connections stateful छन् र एकल server instance मा बाँधिएका छन्, त्यसैले धेरै instances मा scaling गर्न **Redis Pub/Sub backplane** को आवश्यकता हुन्छ messages relay गर्न instances बीचमा — एक सामान्य pitfall, किनभने (sessions जस्तो) connection state एक process को memory मा रहन सक्दैन जब धेरै instances चलिरहेको हुन्छ।

आधारभूत WebSocket pattern, broadcasting, disconnect handling, र scaling consideration बुझ्नु महत्त्वपूर्ण senior-level ज्ञान हो real-time, अन्तरक्रियात्मक अनुभवहरू निर्माण गर्नको लागि जुन आधुनिक अनुप्रयोगहरूमा क्रमशः अपेक्षित छन्।