FastAPI లో WebSockets ని ఎలా నిర్వహించాలి?

Question

Accepted Answer

FastAPI **WebSockets** కు మద్దతు ఇస్తుంది నిజ-సమయ, ద్విదిక కమ్యూనికేషన్ కోసం (చాట్, లైవ్ అప్‌డేట్‌లు, నోటిఫికేషన్‌లు) `@app.websocket` డెకోరేటర్ ద్వారా. HTTP యొక్క request-response కాకుండా, WebSocket కనెక్షన్ తెరిచిఉంటుంది, సర్వర్ మరియు క్లায়েంట్ స్వేచ్ఛగా సందేశాలను పంపించడానికి అనుమతిస్తుంది.

## ప్రాథమిక 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)
```

ప్యాటర్న్: కనెక్షన్ ని `accept()` చేయండి, ఆపై లూప్ — `receive_text()`/`receive_json()` సందేశాలను చదువుతుంది, `send_text()`/`send_json()` వాటిని పంపుతుంది. ఒక `WebSocketDisconnect` అపవాదం క్లায়েంట్ వెళ్లిపోయిందని సూచిస్తుంది (ఇక్కడ మీరు శుభ్రపరచుకోవచ్చు).

## బహుళ క్లయింట్‌లకు ప్రసారం చేయడం (ఉదా. చాట్)

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

క్రియాశీల కనెక్షన్‌ల జాబితాను నిర్వహించడం ఎല్లా క్లయింట్‌లకు **ప్రసారం** చేయడానికి మిమ్మల్ని అనుమతిస్తుంది — చాట్ మరియు లైవ్-అప్‌డేట్ ఫీచర్‌ల ఆధారం.

## స్కేలింగ్ హెచ్చరిక

```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 **నిజ-సమయ, ద్విదిక** ఫీచర్‌లను ప్రారంభించండి — చాట్, లైవ్ నోటిఫికేషన్‌లు, ఉనికి, సహకారిత్వ సంపాదన, లైవ్ డ్యాష్‌బోర్డ్‌లు — HTTP యొక్క request-response మోడల్ అందించలేనిది (సర్వర్ క్లయింట్‌లకు పుష్ చేయవచ్చు, కేవలం ప్రతిస్పందించాల్సిన అవసరం లేదు).

FastAPI యొక్క WebSocket సపోర్ట్‌ను అర్థం చేసుకోవడం ఆధునిక ఇంటరాక్టివ్ అప్లికేషన్‌లను నిర్మించడానికి విలువైనది: `@app.websocket` డెకోరేటర్ accept/receive/send లూప్‌తో ప్రాథమిక నిజ-సమయ కమ్యూనికేషన్‌ని కవర్ చేస్తుంది, మరియు క్రియాశీల కనెక్షన్‌లను నిర్వహించడం చాట్ వంటి బహు-వినియోగదారు ఫీచర్‌ల కోసం **ప్రసారం** చేయడానికి ప్రారంభిస్తుంది.

FastAPI యొక్క async ఫাউండేషన్ WebSockets కుకు బాగా సరిపోతుంది.

నిర్ణయాత్మకంగా ముఖ్యమైనది **స్కేలింగ్ హెచ్చరిక**: WebSocket కనెక్షన్‌లు స్టేట్‌ఫుల్ మరియు ఒకే సర్వర్ ఇన్‌స్టెన్స్‌కు కట్టుబడి ఉన్నాయి, కాబట్టి బహుళ ఇన్‌స్టెన్స్‌ల వెంట స్కేల్ చేయడం ఇన్‌స్టెన్స్‌ల మధ్య సందేశాలను రిలే చేయడానికి **Redis Pub/Sub backplane** అవసరం — ఒక సాధారణ ఆపద, ఎందుకంటే (సెషన్‌ల వంటి) కనెక్షన్ స్టేట్ బహుళ ఇన్‌స్టెన్స్‌ల నుండి నడుస్తున్నప్పుడు ఒక ప్రక్రియ యొక్క మెమరీలో నివసించలేదు.

ప్రాథమిక WebSocket నమూనా, ప్రసారం, డిస్‌కనెక్ట్ హ్యాండ్లింగ్, మరియు స్కేలింగ్ పరిశీలనను తెలుసుకోవడం సీనియర్-స్థర ఆధునిక అప్లికేషన్‌లలో అంతర్భాగమైన నిజ-సమయ, ఇంటరాక్టివ్ అనుభవాలను నిర్మించడానికి జ్ఞానం.