0Pricing
FastAPI Backend Development Bootcamp · Lektion

WebSockets mit einem Pub/Sub-Backplane skalieren

Lernen Sie, WebSocket-Nachrichten mithilfe eines Redis-Pub/Sub-Backplanes über mehrere FastAPI-Instanzen hinweg zu verteilen.

WebSockets mit einem Pub/Sub-Backplane skalieren ist eine kostenlose FastAPI Backend Development Bootcamp-Lektion auf CoddyKit. Dies ist Lektion 4 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des FastAPI Backend Development Bootcamp-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der FastAPI Backend Development Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Teile dieser Lektion wurden noch nicht übersetzt und werden auf Englisch angezeigt.

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.

Häufig gestellte Fragen

Ist die Lektion „WebSockets mit einem Pub/Sub-Backplane skalieren“ kostenlos?

Ja — der vollständige Text von „WebSockets mit einem Pub/Sub-Backplane skalieren“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des FastAPI Backend Development Bootcamp-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der FastAPI Backend Development Bootcamp-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „WebSockets mit einem Pub/Sub-Backplane skalieren“?

Lernen Sie, WebSocket-Nachrichten mithilfe eines Redis-Pub/Sub-Backplanes über mehrere FastAPI-Instanzen hinweg zu verteilen. Du übst FastAPI Backend Development Bootcamp mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um FastAPI Backend Development Bootcamp zu starten?

Keine Vorkenntnisse erforderlich. FastAPI Backend Development Bootcamp auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 4 von 4.

Wie lange dauert die Lektion „WebSockets mit einem Pub/Sub-Backplane skalieren“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser FastAPI Backend Development Bootcamp-Lektion Code schreiben und ausführen?

Ja. Jede FastAPI Backend Development Bootcamp-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Grundlagen des WebSocket-Protokolls
  2. WebSockets in FastAPI implementieren
  3. Eine Echtzeit-Chat-Anwendung erstellen
  4. WebSockets mit einem Pub/Sub-Backplane skalieren
← Zurück zu FastAPI Backend Development Bootcamp