Skalowanie WebSockets za pomocą magistrali Pub/Sub
Dowiedz się, jak rozgłaszać wiadomości WebSocket między wieloma instancjami FastAPI za pomocą magistrali Redis pub/sub.
Skalowanie WebSockets za pomocą magistrali Pub/Sub to bezpłatna lekcja FastAPI Backend Development Bootcamp na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej FastAPI Backend Development Bootcamp, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.
Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.
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:room1Local 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.
Ucz się FastAPI Backend Development Bootcamp dzięki korepetycjom AI — za darmo
Pisz i uruchamiaj kod w przeglądarce, otrzymuj natychmiastową pomoc od korepetytora AI dostępnego 24/7 i kontynuuj naukę w sieci lub w aplikacji.
- Kursy
- 21
- Lekcje
- 84
Często zadawane pytania
Czy lekcja „Skalowanie WebSockets za pomocą magistrali Pub/Sub” jest bezpłatna?
Tak — pełny tekst „Skalowanie WebSockets za pomocą magistrali Pub/Sub” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu FastAPI Backend Development Bootcamp, przejdź na CoddyKit PRO. Kurs FastAPI Backend Development Bootcamp zawiera 4 lekcji w sumie.
Co nauczysz się w „Skalowanie WebSockets za pomocą magistrali Pub/Sub”?
Dowiedz się, jak rozgłaszać wiadomości WebSocket między wieloma instancjami FastAPI za pomocą magistrali Redis pub/sub. Ćwiczysz FastAPI Backend Development Bootcamp z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć FastAPI Backend Development Bootcamp?
Nie wymagamy żadnego doświadczenia. FastAPI Backend Development Bootcamp w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.
Ile czasu zajmuje lekcja „Skalowanie WebSockets za pomocą magistrali Pub/Sub”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji FastAPI Backend Development Bootcamp?
Tak. Każda lekcja FastAPI Backend Development Bootcamp zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Podstawy protokołu WebSocket
- Implementacja WebSockets w FastAPI
- Budowa aplikacji czatu w czasie rzeczywistym
- Skalowanie WebSockets za pomocą magistrali Pub/Sub