Comment gérez-vous les WebSockets dans FastAPI ?

Question

Accepted Answer

FastAPI supporte les **WebSockets** pour une communication bidirectionnelle en temps réel (chat, mises à jour en direct, notifications) via le décorateur `@app.websocket`. Contrairement au modèle requête-réponse HTTP, une connexion WebSocket reste ouverte, permettant au serveur et au client d'envoyer des messages librement.

## Un endpoint WebSocket basique

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

Le modèle : `accept()` accepte la connexion, puis boucle — `receive_text()`/`receive_json()` lit les messages, `send_text()`/`send_json()` les envoie. Une exception `WebSocketDisconnect` signale que le client a quitté (où vous nettoyez).

## Diffusion vers plusieurs clients (par exemple 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
```

Gérer une liste de connexions actives vous permet de **diffuser** vers tous les clients — la base des fonctionnalités de chat et de mise à jour en direct.

## Mise à l'échelle — 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.)
```

## Pourquoi c'est important

Les WebSockets activent les fonctionnalités **bidirectionnelles en temps réel** — chat, notifications en direct, présence, édition collaborative, tableaux de bord en direct — que le modèle requête-réponse HTTP ne peut pas fournir (le serveur peut pousser vers les clients, pas seulement répondre).

Comprendre le support WebSocket de FastAPI est précieux pour construire des applications interactives modernes : le décorateur `@app.websocket` avec la boucle accept/receive/send couvre la communication en temps réel basique, et la gestion des connexions actives permet la **diffusion** (le cœur des fonctionnalités multi-utilisateurs comme le chat).

La fondation asynchrone de FastAPI convient bien aux WebSockets.

Critiquement important est le **caveat de mise à l'échelle** : les connexions WebSocket sont avec état et liées à une seule instance de serveur, donc la mise à l'échelle sur plusieurs instances nécessite un **backplane Redis Pub/Sub** pour relayer les messages entre instances — un piège courant, car (comme les sessions) l'état de connexion ne peut pas vivre dans la mémoire d'un seul processus lors de l'exécution de plusieurs instances.

Connaître le modèle WebSocket basique, la diffusion, la gestion de la déconnexion, et la considération de mise à l'échelle est une connaissance importante au niveau senior pour construire les expériences interactives et en temps réel de plus en plus attendues dans les applications modernes.