FastAPI-இல் WebSockets-ஐ எவ்வாறு கையாள்வது?

Question

Accepted Answer

FastAPI `@app.websocket` decorator மூலம் real-time, bidirectional communication-க்காக (chat, live updates, notifications) **WebSockets**-ஐ ஆதரிக்கிறது. 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: connection-ஐ `accept()` செய், பிறகு loop செய் — `receive_text()`/`receive_json()` messages-ஐப் படிக்கிறது, `send_text()`/`send_json()` அவற்றை அனுப்புகிறது. ஒரு `WebSocketDisconnect` exception client வெளியேறியதைக் குறிக்கிறது (அங்கே cleanup செய்கிறீர்கள்).

## பல 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
```

active 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 செய்ய முடியும், வெறுமனே response செய்வது மட்டுமல்ல).

FastAPI-இன் WebSocket ஆதரவைப் புரிந்துகொள்வது நவீன interactive applications-ஐ உருவாக்குவதற்கு மதிப்புமிக்கது: accept/receive/send loop-உடன் `@app.websocket` decorator அடிப்படை real-time communication-ஐ உள்ளடக்குகிறது, மேலும் active connections-ஐ நிர்வகிப்பது **broadcasting**-ஐ இயக்குகிறது (chat போன்ற multi-user features-இன் மையம்).

FastAPI-இன் async foundation WebSockets-க்கு நன்கு பொருந்துகிறது.

மிக முக்கியமானது **scaling caveat**: WebSocket connections stateful-ஆகவும் ஒரே server instance-உடன் இணைக்கப்பட்டுள்ளன, எனவே பல instances முழுவதும் scale செய்வதற்கு instances இடையே messages-ஐ relay செய்ய ஒரு **Redis Pub/Sub backplane** தேவை — ஒரு பொதுவான pitfall, ஏனெனில் (sessions போல) பல instances-ஐ இயக்கும்போது connection state ஒரு process-இன் memory-இல் வாழ முடியாது.

அடிப்படை WebSocket pattern, broadcasting, disconnect handling, மற்றும் scaling consideration-ஐ அறிந்திருப்பது நவீன applications-இல் பெருகிய முறையில் எதிர்பார்க்கப்படும் real-time, interactive experiences-ஐ உருவாக்குவதற்கான முக்கியமான senior-level அறிவாகும்.