Real-Time Streaming Systems (WebRTC + Live Data) · Lekcja

Skalowanie signalingu za pomocą pokoi i Redis

Skalowanie signalingu za pomocą pokoi i Redis to bezpłatna lekcja Real-Time Streaming Systems (WebRTC + Live Data) 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 Real-Time Streaming Systems (WebRTC + Live Data), a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Real-Time Streaming Systems (WebRTC + Live Data) zawiera 4 lekcji w sumie.

Części tej lekcji nie zostały jeszcze przetłumaczone i są wyświetlane po angielsku.

One Server Is Not Enough

You have built, deployed, and tested a signaling server. As users grow, a single instance becomes a bottleneck. This lesson covers scaling signaling horizontally across multiple instances using rooms and Redis.

The Room Concept

Signaling messages should only reach the right peers. A room groups the participants of one call so offers, answers, and ICE candidates are routed only to members of that room.

Joining a Room

When a client connects, it joins a room identified by a call id. The server tracks which sockets belong to which room.

io.on('connection', (socket) => {
  socket.on('join', (roomId) => {
    socket.join(roomId);
    socket.to(roomId).emit('peer-joined', socket.id);
  });
});

Routing Within a Room

Signaling messages are relayed only to other members of the sender's room, never broadcast to everyone.

socket.on('signal', ({ roomId, data }) => {
  socket.to(roomId).emit('signal', { from: socket.id, data });
});

The Multi-Instance Problem

With several server instances behind a load balancer, two peers in the same call may connect to different instances. Instance A does not know about a room member on instance B, so signaling fails.

Pub/Sub to the Rescue

A shared Redis pub/sub layer lets instances forward messages to each other. When instance A emits to a room, Redis publishes it so instance B delivers it to its local members.

Adding the Redis Adapter

Socket.IO offers a Redis adapter that handles cross-instance routing transparently, so your room code stays unchanged.

const { createAdapter } = require('@socket.io/redis-adapter');
const { createClient } = require('redis');

const pub = createClient({ url: 'redis://localhost:6379' });
const sub = pub.duplicate();
await Promise.all([pub.connect(), sub.connect()]);
io.adapter(createAdapter(pub, sub));

Sticky Sessions

For long-lived WebSocket connections, configure the load balancer for sticky sessions so a client stays on one instance for the life of its connection, avoiding handshake breakage.

Tracking Presence

Store room membership in Redis so any instance can answer who is in a call and clean up when a client disconnects.

socket.on('join', async (roomId) => {
  await pub.sAdd('room:' + roomId, socket.id);
});
socket.on('disconnect', async () => {
  // remove from all rooms it belonged to
});

Handling Disconnects

Notify remaining peers when someone leaves so they can tear down the corresponding peer connection cleanly.

socket.on('disconnect', () => {
  socket.rooms.forEach((roomId) => {
    socket.to(roomId).emit('peer-left', socket.id);
  });
});

Scaling Strategy Summary

To scale signaling: group peers into rooms, run multiple stateless instances, connect them with a Redis adapter, enable sticky sessions, and track presence in Redis. The signaling layer then grows horizontally while calls keep connecting.

Quick Check

Test your understanding of scaling signaling.

Recap

You learned to scale signaling:

Rooms route messages only to call participants
Multiple instances need a Redis pub/sub adapter to share rooms
Sticky sessions keep WebSocket connections stable
Presence tracking and disconnect handling keep state consistent

This architecture supports many concurrent calls reliably.

Często zadawane pytania

Czy lekcja „Skalowanie signalingu za pomocą pokoi i Redis” jest bezpłatna?

Tak — pełny tekst „Skalowanie signalingu za pomocą pokoi i Redis” 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 Real-Time Streaming Systems (WebRTC + Live Data), przejdź na CoddyKit PRO. Kurs Real-Time Streaming Systems (WebRTC + Live Data) zawiera 4 lekcji w sumie.

Co nauczysz się w „Skalowanie signalingu za pomocą pokoi i Redis”?

Naucz się horyzontalnie skalować serwer signalingu WebRTC, używając routingu komunikatów opartego na pokojach i adaptera Redis pub/sub, aby peery z różnych instancji serwera mogły się łączyć. Ćwiczysz Real-Time Streaming Systems (WebRTC + Live Data) 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ąć Real-Time Streaming Systems (WebRTC + Live Data)?

Nie wymagamy żadnego doświadczenia. Real-Time Streaming Systems (WebRTC + Live Data) 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 signalingu za pomocą pokoi i Redis”?

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 Real-Time Streaming Systems (WebRTC + Live Data)?

Tak. Każda lekcja Real-Time Streaming Systems (WebRTC + Live Data) 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

Wybór backendu do sygnalizacji
Implementacja logiki sygnalizacji
Wdrażanie i testowanie sygnalizacji
Skalowanie signalingu za pomocą pokoi i Redis

← Powrót do Real-Time Streaming Systems (WebRTC + Live Data)