Si të trajtoni WebSockets në FastAPI?

Question

Accepted Answer

FastAPI mbështet **WebSockets** për komunikim real-time, bidireksional (chat, përditësimet direkte, njoftimet) përmes dekoratorit `@app.websocket`. Ndryshe nga HTTP-ja me modelin kërkesë-përgjigje, një lidhje WebSocket mbetet e hapur, duke lejuar serverin dhe klientin të dërgojnë mesazhe lirisht.

## Një pikë fundore bazike WebSocket

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

Shënia: `accept()` pranon lidhjen, pastaj bëjë loop — `receive_text()`/`receive_json()` lexon mesazhet, `send_text()`/`send_json()` i dërgon ato. Një përjashtim `WebSocketDisconnect` sinjalizon se klienti ka ikur (ku bëni pastrimin).

## Transmetimi në shumë klientë (p.sh. 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
```

Menadzhimi i një liste lidhjedhjesh aktive ju lejon të **transmetoni** në të gjithë klientët — themeli i chat dhe veçorive të përditësimit direkt.

## Paralajmërim shkallëzimi

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

## Përse ka rëndësi

WebSockets mundësojnë veçori **real-time, bidireksionale** — chat, njoftimet direkte, pranisje, redaktim bashkëpunues, tabela informacioni direkte — që modeli kërkesë-përgjigje i HTTP-së nuk mund të sigurojë (serveri mund t'i dërgojë klientëve, jo vetëm t'u përgjigjet).

Kuptimi i mbështetjes WebSocket të FastAPI-t është i vlefshëm për ndërtimin e aplikacioneve moderne interaktive: dekoratua `@app.websocket` me ciklin pranë/marrjeje/dërgimi mbulon komunikimin bazik real-time, dhe menadzhimi i lidhjedhjeve aktive mundëson **transmetimin** (thelbi i veçorive shumë-përdoruesish si chat).

Fondacioni asinkron i FastAPI përputhet mirë me WebSockets.

Sangopër i rëndësishëm është **paralajmërimja e shkallëzimit**: lidhjet WebSocket janë me gjendje dhe lidhur në një instancë të vetme serveri, kështu që shkallëzimi nëpër shumë instanca kërkon një **Redis Pub/Sub backplane** për transmetimin e mesazheve ndërmjet instancave — një kurth i zakonshëm, pasi (si seancave) gjendje lidhjes nuk mund të jetë në kujtesën e një procesi të vetëm kur ekzekutohen shumë instanca.

Dija e modelit bazik WebSocket, transmetimit, trajtimit të shkëputjeve, dhe konsideratës së shkallëzimit është njohuri e rëndësishme në nivel sênior për ndërtimin e përvojave real-time, interaktive që priten gjithnjë e më shumë në aplikacionet moderne.