ਤੁਸੀ FastAPI ਵਿੱਚ WebSockets ਨੂੰ ਕਿਵੇਂ ਸੰਭਾਲਦੇ ਹੋ?

Question

Accepted Answer

FastAPI **WebSockets** ਨੂੰ real-time, bidirectional communication (chat, live updates, notifications) ਲਈ `@app.websocket` decorator ਦੇ ਰਾਹੀਂ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। HTTP ਦੇ request-response ਦੇ ਉਲਟ, ਇੱਕ WebSocket ਕनेक्शन ਖੁੱਲਾ ਰਹਿੰਦਾ ਹੈ, ਜੋ server ਅਤੇ client ਨੂੰ ਸੁਤੰਤਰ ਰੂਪ ਵਿੱਚ ਸੁਨੇਹੇ ਭੇਜਣ ਦਿੰਦਾ ਹੈ।

## ਇੱਕ ਮੂਲ 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()` ਕनেक्शन, ਫਿਰ loop — `receive_text()`/`receive_json()` ਸੁਨੇਹੇ ਪੜ੍ਹਦਾ ਹੈ, `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 ਦੀ ਸੂਚੀ ਨੂੰ ਸੰਭਾਲਣ ਦੀ ਸਮਰੱਥਾ ਤੁਹਾਨੂੰ ਸਾਰੇ clients ਨੂੰ **broadcast** ਕਰਨ ਦਿੰਦੀ ਹੈ — chat ਅਤੇ live-update ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਆਧਾਰ।

## 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** ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦੇ ਹਨ — chat, live notifications, presence, collaborative editing, live dashboards — ਜੋ HTTP ਦਾ request-response ਮਾਡਲ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰ ਸਕਦਾ (server clients ਨੂੰ push ਕਰ ਸਕਦਾ ਹੈ, ਸਿਰਫ ਜਵਾਬ ਦੇ ਰਹੇ ਨਹੀਂ)।

FastAPI ਦੀ WebSocket ਸਮਰਥਨ ਨੂੰ ਸਮਝਣਾ ਆਧੁਨਿਕ ਇੰਟਰਐਕਟਿਵ ਐਪਲੀਕੇਸ਼ਨ ਬਣਾਉਣ ਲਈ ਮੂਲਵਾਨ ਹੈ: `@app.websocket` decorator accept/receive/send loop ਦੇ ਨਾਲ ਬੁਨਿਆਦੀ real-time communication ਨੂੰ ਕਵਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਸਰਗਰਮ connections ਨੂੰ ਪ੍ਰਬੰਧਤ ਕਰਕੇ **broadcasting** (chat ਵਰਗੀਆਂ multi-user ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਮੂਲ) ਨੂੰ ਸਮਰਥ ਬਣਾਉਂਦਾ ਹੈ।

FastAPI ਦੀ async ਬੁਨਿਆਦ WebSockets ਲਈ ਚੰਗੀ ਤਰ੍ਹਾਂ ਅਨੁਕੂਲ ਹੈ।

ਵਿਚਾਰਧੀਨ ਮਹੱਤਵਪੂਰਨ ਹੈ **scaling caveat**: WebSocket connections ਸਥਿਤੀਸ਼ੀਲ ਹਨ ਅਤੇ ਇੱਕ ਸਿੰਗਲ server instance ਨਾਲ ਬੰਧੇ ਹਨ, ਇਸ ਲਈ ਕਈ instances ਵਿੱਚ scaling ਲਈ **Redis Pub/Sub backplane** ਦੀ ਲੋੜ ਹੈ ਤਾਂ ਕਿ instances ਵਿਚਕਾਰ ਸੁਨੇਹਿਆਂ ਨੂੰ relay ਕੀਤਾ ਜਾ ਸਕੇ — ਇੱਕ ਆਮ pitfall, ਕਿਉਂਕਿ (sessions ਦੀ ਤਰ੍ਹਾਂ) connection state ਇੱਕ process ਦੀ memory ਵਿੱਚ ਨਹੀਂ ਰਹ ਸਕਦਾ ਜਦੋਂ ਕਈ instances ਚਲਾ ਰਹੇ ਹਨ।

ਮੂਲ WebSocket pattern, broadcasting, disconnect handling, ਅਤੇ scaling consideration ਨੂੰ ਜਾਨਣਾ ਮਹੱਤਵਪੂਰਨ senior-level ਗਿਆਨ ਹੈ real-time, ਇੰਟਰਐਕਟਿਵ ਅਨੁਭਵ ਬਣਾਉਣ ਲਈ ਜੋ ਆਧੁਨਿਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਵਧਦੇ ਪੱਖ ਤੋਂ ਉਮੀਦ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।