Programmeren van WebSockets en realtime-systemen · Les

Gedistribueerd statusbeheer

Ontdek hoe u externe message brokers (bijvoorbeeld Redis Pub/Sub en Kafka) gebruikt om de status over meerdere WebSocket-servers te synchroniseren.

Les 3 van 412 stappen

Gedistribueerd statusbeheer is een gratis Programmeren van WebSockets en realtime-systemen-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Programmeren van WebSockets en realtime-systemen. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Programmeren van WebSockets en realtime-systemen bevat in totaal 4 lessen.

Uitdagingen bij schalen: gedeelde status

Je hebt geleerd hoe je WebSocketapplicaties kunt schalen door meerdere serverexemplaren achter een load balancer te laten draaien. Maar wat gebeurt er wanneer een client verbinding maakt met server A en een andere client die met server B is verbonden een bericht naar de eerste client moet sturen?

Dit is de uitdaging van gedistribueerd statusbeheer: hoe delen je servers informatie en hoe stemmen ze hun acties op elkaar af?

Waarom de status centraliseren?

Stel je een chatapplicatie voor. Als client 1 zich op server A bevindt en client 2 op server B, en client 1 een bericht stuurt, hoe vertelt server A dan aan server B dat dit bericht bij client 2 moet worden afgeleverd?

Zonder een manier waarop servers met elkaar kunnen communiceren, bereiken berichten of updates mogelijk alleen clients die met dezelfde server zijn verbonden. Daarmee gaat de realtime-ervaring verloren.

Kennismaken met message brokers

Om dit op te lossen gebruiken we een message broker. Zie het als een centraal postkantoor voor je servers.

Servers sturen berichten naar de broker.
Andere servers kunnen vervolgens berichten van de broker ontvangen.

Zo kunnen al je WebSocketservers indirect met elkaar communiceren, zonder dat ze van elkaars bestaan hoeven te weten.

Het Pub/Sub-patroon

Veel message brokers gebruiken een Publisher-Subscriber-patroon (Pub/Sub). Het werkt als volgt:

Publishers sturen berichten naar specifieke kanalen of onderwerpen.
Subscribers tonen interesse in een of meer kanalen en ontvangen alle berichten die daar naartoe worden gepubliceerd.

Dit patroon is ideaal om gegevens over meerdere serverexemplaren te verspreiden.

Voorbeeld van Redis Pub/Sub

Redis is een populaire, open-sourcegegevensopslag in het geheugen die vaak als message broker wordt gebruikt. De Pub/Sub-functie is snel en eenvoudig te gebruiken.

Je kunt meerdere Node.js-WebSocketservers hebben die allemaal met één Redis-exemplaar zijn verbonden en dit gebruiken om berichten uit te wisselen.

De basis van Redis Pub/Sub

Stel dat je twee WebSocketservers hebt, Server A en Server B, die beide met Redis zijn verbonden.

Wanneer Server A een bericht ontvangt dat moet worden gedeeld, publiceert deze dat bericht naar een Redis-kanaal, bijvoorbeeld 'global_chat'.
Server B heeft zich geabonneerd op 'global_chat' en ontvangt het bericht dus direct van Redis.

Daarna kan Server B het bericht doorsturen naar de eigen verbonden clients.

De server publiceert naar Redis

Hier volgt een vereenvoudigd Node.js-voorbeeld van een WebSocketserver die berichten publiceert naar een Redis-kanaal. We gebruiken de bibliotheek ws voor WebSockets en ioredis voor Redis.

Zorg dat Redis actief is en dat ws en ioredis zijn geïnstalleerd (`npm i ws ioredis`).

const WebSocket = require('ws');
const Redis = require('ioredis');

const wss = new WebSocket.Server({ port: 8080 });
const publisher = new Redis(); // Connects to localhost:6379

wss.on('connection', ws => {
  console.log('Client connected to Server 1');

  ws.on('message', message => {
    const msg = message.toString();
    console.log(`Server 1 received: ${msg}`);
    // Publish message to 'chat_messages' channel
    publisher.publish('chat_messages', msg);
    ws.send(`You said: ${msg}`); // Echo back to sender
  });
});

console.log('Server 1 listening on ws://localhost:8080');

De server abonneert zich en stuurt door

Hier volgt nog een Node.js-WebSocketserver, die op een andere poort draait en zich abonneert op hetzelfde Redis-kanaal. Wanneer deze server een bericht van Redis ontvangt, zendt hij het uit naar de eigen verbonden clients.

Je zou dit in een aparte terminal uitvoeren, los van server1.js.

const WebSocket = require('ws');
const Redis = require('ioredis');

const wss = new WebSocket.Server({ port: 8081 });
const subscriber = new Redis(); // Connects to localhost:6379

// Subscribe to the 'chat_messages' channel
subscriber.subscribe('chat_messages', (err, count) => {
  if (err) console.error('Failed to subscribe:', err.message);
  else console.log(`Subscribed to ${count} channel(s)`);
});

// Handle messages received from Redis
subscriber.on('message', (channel, message) => {
  console.log(`Server 2 received from Redis [${channel}]: ${message}`);
  // Broadcast to all connected clients on Server 2
  wss.clients.forEach(client => {
    if (client.readyState === WebSocket.OPEN) {
      client.send(`Global Chat: ${message}`);
    }
  });
});

wss.on('connection', ws => {
  console.log('Client connected to Server 2');
  ws.send('Welcome to Server 2!');
});

console.log('Server 2 listening on ws://localhost:8081');

Voordelen voor schalen

Een message broker zoals Redis Pub/Sub biedt aanzienlijke voordelen voor het schalen van WebSocketapplicaties:

Ontkoppeling: Servers hoeven niet rechtstreeks van elkaar op de hoogte te zijn. Ze communiceren alleen met de broker.
Horizontale schaalbaarheid: Je kunt eenvoudig meer WebSocketservers toevoegen wanneer het verkeer toeneemt; die verbinden zich allemaal met dezelfde broker.
Globale broadcasts: Berichten kunnen efficiënt naar alle clients worden uitgezonden, ongeacht met welke server ze verbonden zijn.

Verder dan broadcasts: aanwezigheid

Message brokers zijn niet alleen bedoeld voor het uitzenden van chatberichten. Ze zijn ook essentieel voor het synchroniseren van andere soorten gedistribueerde status, zoals de aanwezigheid van gebruikers.

Wanneer een gebruiker bijvoorbeeld inlogt, kan de server waarmee die gebruiker is verbonden een status 'online' publiceren naar een Redis-kanaal. Andere servers abonneren zich hierop om hun lijsten met online gebruikers bijgewerkt te houden.

Controle over message brokers

Stel je voor dat je meerdere WebSocketservers hebt en dat een bericht dat naar één server wordt gestuurd een client moet bereiken die met een andere server is verbonden. Welk patroon biedt hiervoor de beste oplossing?

Beantwoord dit in de interactieve les

Samenvatting: gedistribueerde status

We hebben geleerd dat voor het schalen van WebSocket-toepassingen gedistribueerde status moet worden beheerd. Message brokers zoals Redis, die het Pub/Sub-patroon gebruiken, zijn essentieel om meerdere WebSocket-servers met elkaar te laten communiceren en gegevens te laten synchroniseren. Zo ontvangen alle clients relevante updates, ongeacht met welke server ze verbonden zijn.

Hierdoor wordt je toepassing veerkrachtiger en beter schaalbaar wanneer je meer serverinstanties toevoegt.

Gratis beginnen

Leer Programmeren van WebSockets en realtime-systemen met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 12
Lessen: 47

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Gedistribueerd statusbeheer” gratis?

Ja — de volledige tekst van “Gedistribueerd statusbeheer” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Programmeren van WebSockets en realtime-systemen wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Programmeren van WebSockets en realtime-systemen bevat in totaal 4 lessen.

Wat leer ik in “Gedistribueerd statusbeheer”?

Ontdek hoe u externe message brokers (bijvoorbeeld Redis Pub/Sub en Kafka) gebruikt om de status over meerdere WebSocket-servers te synchroniseren. Je oefent met Programmeren van WebSockets en realtime-systemen door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Programmeren van WebSockets en realtime-systemen te beginnen?

Ervaring vooraf is niet nodig. Programmeren van WebSockets en realtime-systemen op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.

Hoe lang duurt de les “Gedistribueerd statusbeheer”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Programmeren van WebSockets en realtime-systemen?

Ja. Elke les over Programmeren van WebSockets en realtime-systemen bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Programmeren van WebSockets en realtime-systemen