0Pricing
FastAPI Backend Development Bootcamp · Leçon

Mise à l’échelle de WebSockets avec une dorsale pub/sub

Apprenez à diffuser des messages WebSocket entre plusieurs instances FastAPI grâce à une dorsale pub/sub Redis.

Mise à l’échelle de WebSockets avec une dorsale pub/sub est une leçon FastAPI Backend Development Bootcamp gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage FastAPI Backend Development Bootcamp, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours FastAPI Backend Development Bootcamp comprend 4 leçons au total.

Certaines parties de cette leçon n'ont pas encore été traduites et s'affichent en anglais.

The Multi-Instance Problem

A single FastAPI process can hold WebSocket connections in memory. But in production you run multiple instances behind a load balancer.

A message arriving on instance A cannot reach a client connected to instance B unless the instances share state.

What is a Backplane?

A backplane is a shared messaging channel that every instance subscribes to. When one instance receives an event, it publishes to the backplane and all instances relay it to their local clients.

Redis Pub/Sub

Redis pub/sub is a popular backplane: a PUBLISH to a channel is delivered to every SUBSCRIBEr in real time.

PUBLISH chat:room1 "hello"
SUBSCRIBE chat:room1

Local Connection Manager

Each instance still tracks its own connected clients in memory.

class ConnectionManager:
    def __init__(self):
        self.active = []
    async def broadcast_local(self, msg):
        for ws in self.active:
            await ws.send_text(msg)

Publishing to Redis

Instead of broadcasting locally, publish incoming messages to a Redis channel.

import redis.asyncio as redis

r = redis.Redis()
async def publish(channel, message):
    await r.publish(channel, message)

Subscribing on Startup

Each instance opens a Redis subscription and listens in a background task.

async def listen():
    pubsub = r.pubsub()
    await pubsub.subscribe("chat:room1")
    async for msg in pubsub.listen():
        if msg["type"] == "message":
            await manager.broadcast_local(msg["data"])

Wiring It with Lifespan

Start the listener when the app boots using FastAPI lifespan events.

from contextlib import asynccontextmanager

@asynccontextmanager
async def lifespan(app):
    task = asyncio.create_task(listen())
    yield
    task.cancel()

The Full Message Flow

Client to instance A then A publishes to Redis then Redis fans out to A and B then each relays to its local clients.

Now any client receives any message regardless of which instance it connected to.

Per-Room Channels

Use one Redis channel per chat room so instances only receive messages relevant to their connected clients.

channel = "chat:" + room_id
await r.publish(channel, payload)

Avoiding Echo Loops

Because the publisher also receives its own message via the subscription, broadcast only from the listener, not directly, to avoid sending twice.

Sticky Sessions vs Stateless

With a backplane, instances become effectively stateless for messaging, so you no longer need sticky sessions on the load balancer for delivery to work.

Quick Check

Test your scaling knowledge.

Recap

You learned to scale real-time apps horizontally:

  • In-memory managers only reach local clients
  • A Redis pub/sub backplane fans messages out across instances
  • Use per-room channels and avoid echo loops

This pattern lets WebSocket apps scale to many instances behind a load balancer.

Questions Fréquemment Posées

La leçon « Mise à l’échelle de WebSockets avec une dorsale pub/sub » est-elle gratuite ?

Oui — le texte complet de « Mise à l’échelle de WebSockets avec une dorsale pub/sub » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours FastAPI Backend Development Bootcamp, passe à CoddyKit PRO. Le cours FastAPI Backend Development Bootcamp comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Mise à l’échelle de WebSockets avec une dorsale pub/sub » ?

Apprenez à diffuser des messages WebSocket entre plusieurs instances FastAPI grâce à une dorsale pub/sub Redis. Tu pratiques FastAPI Backend Development Bootcamp avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer FastAPI Backend Development Bootcamp ?

Aucune expérience préalable n'est requise. FastAPI Backend Development Bootcamp sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Mise à l’échelle de WebSockets avec une dorsale pub/sub » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon FastAPI Backend Development Bootcamp ?

Oui. Chaque leçon FastAPI Backend Development Bootcamp inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Fondamentaux du protocole WebSocket
  2. Implémentation de WebSockets dans FastAPI
  3. Créer une application de discussion en temps réel
  4. Mise à l’échelle de WebSockets avec une dorsale pub/sub
← Retour à FastAPI Backend Development Bootcamp