როგორ გაქვთ WebSocket-ების მენეჯმენტი FastAPI-ში?

Question

Accepted Answer

FastAPI მხარს უჭერს **WebSocket**-ებს რეალურ დროში ორმხრივი კომუნიკაციისთვის (ჩატი, ცოცხალი განახლებები, შეტყობინებები) `@app.websocket` დეკორატორის გამოყენებით. HTTP-ის მოთხოვნა-პასუხის მოდელისგან განსხვავებით, 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.)
```

## რატომ არის ეს მნიშვნელოვანი

WebSocket-ები აპირებენ **რეალურ დროში, ორმხრივი** ფუნქციები — ჩატი, ცოცხალი შეტყობინებები, სიმყარე, თანამშრომელი რედაქტირება, ცოცხალი ინფოპანელი — რომელთა HTTP-ის მოთხოვნა-პასუხის მოდელი ვერ იძლევა (სერვერმა შეიძლება აიძულოს კლიენტებზე, არა მხოლოდ პასუხი).

FastAPI-ის WebSocket მხარდამჭერის გაგება ღირებული პროდუქტი თანამედროვე ინტერაქტიული აპლიკაციების დასაწერად: `@app.websocket` დეკორატორი accept/receive/send ციკლით დაფარავს ძირითად რეალურ დროში კომუნიკაციას, და აქტიური კავშირების მენეჯმენტი აპირებს **მაუწყებელი** (მულტიმომხმარებელი ფუნქციების როგორიცაა ჩატი სიძირე).

FastAPI-ის async საფუძველი კარგად ჯდება WebSocket-ებზე.

კრიტიკულად მნიშვნელოვანი არის **მასშტაბირების შენიშვნა**: WebSocket კავშირი სახელმწიფოა და დაკავშირებულია ერთ სერვერის ინსტანციასთან, ამიტომ მასშტაბირება რამდენიმე ინსტანციის პირებში მოითხოვს **Redis Pub/Sub backplane** ბირთვში რელე შეტყობინებებს ინსტანციებს შორის — საერთო პიტნი, რადგან (როგორც სესიები) კავშირის მდგომარეობა არ შეიძლება ერთი პროცესის მეხსიერებაში სწორი როდესაც რამდენიმე ინსტანციის გაშვება.

ძირითადი WebSocket შაბლონის, მაუწყებელი, კავშირის გაწყვეტის დამუშავება, და მასშტაბირების განხილვა მნიშვნელოვანი უფროსი დონის ცოდნაა რეალურ დროში, ინტერაქტიული გამოსცემთ დასაწერად რომელიც სულ უფრო მოლოდინდა თანამედროვე აპლიკაციებში.