Distribuerad tillståndshantering
Utforska hur externa meddelandeförmedlare (t.ex. Redis Pub/Sub, Kafka) kan användas för att synkronisera tillstånd mellan flera WebSocket-servrar.
Distribuerad tillståndshantering är en gratis lektion i Programmering av WebSockets och system i realtid på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Programmering av WebSockets och system i realtid, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Programmering av WebSockets och system i realtid innehåller totalt 4 lektioner.
Skalningsutmaningar: delat tillstånd
Du har lärt dig att skala WebSocket-applikationer genom att köra flera serverinstanser bakom en lastbalanserare. Men vad händer när en klient ansluter till Server A och en annan klient, som är ansluten till Server B, behöver skicka ett meddelande till den första klienten?
Detta är utmaningen med distribuerad tillståndshantering: hur delar servrarna information och samordnar sig?
Varför centralisera tillståndet?
Föreställ dig en chattapplikation. Om Klient 1 finns på Server A och Klient 2 på Server B, och Klient 1 skickar ett meddelande, hur talar Server A om för Server B att det ska levereras till Klient 2?
Utan ett sätt för servrarna att kommunicera kanske meddelanden eller uppdateringar bara når klienter som är anslutna till samma server, vilket förstör realtidsupplevelsen.
Introduktion till meddelandemäklare
För att lösa detta använder vi en meddelandemäklare. Tänk på den som ett centralt postkontor för dina servrar.
- Servrar skickar meddelanden till mäklaren.
- Andra servrar kan sedan ta emot meddelanden från mäklaren.
Detta gör att alla dina WebSocket-servrar kan kommunicera indirekt utan att behöva känna till varandras existens.
Pub/Sub-mönstret
Många meddelandemäklare använder ett Publisher-Subscriber-mönster (Pub/Sub). Det fungerar så här:
- Utgivare skickar meddelanden till specifika kanaler eller ämnen.
- Prenumeranter visar intresse för en eller flera kanaler och tar emot alla meddelanden som publiceras där.
Det här mönstret passar perfekt för att sända data till flera serverinstanser.
Redis Pub/Sub-exempel
Redis är ett populärt datalager med öppen källkod och lagring i minnet, som ofta används som meddelandemäklare. Dess Pub/Sub-funktion är snabb och enkel att använda.
Du kan ha flera Node.js WebSocket-servrar som alla är anslutna till en enda Redis-instans och använder den för att utbyta meddelanden.
Grunderna i Redis Pub/Sub
Anta att du har två WebSocket-servrar, Server A och Server B, som båda är anslutna till Redis.
- När
Server Atar emot ett meddelande som behöver delas publicerar den meddelandet till en Redis-kanal (till exempel'global_chat'). Server Bhar prenumererat på'global_chat'och tar därför emot meddelandet direkt från Redis.
Därefter kan Server B vidarebefordra meddelandet till sina egna anslutna klienter.
Servern publicerar till Redis
Här är ett förenklat Node.js-exempel på en WebSocket-server som publicerar meddelanden till en Redis-kanal. Vi använder biblioteket ws för WebSockets och ioredis för Redis.
Se till att Redis körs och att ws och ioredis är installerade (`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');Servern prenumererar och vidarebefordrar
Här är nu en annan Node.js WebSocket-server (som körs på en annan port) som prenumererar på samma Redis-kanal. När den får ett meddelande från Redis sänder den det till sina egna anslutna klienter.
Du skulle köra detta i en separat terminal från 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');Fördelar för skalning
Att använda en meddelandemäklare som Redis Pub/Sub ger betydande fördelar när WebSocket-applikationer skalas:
- Frikoppling: Servrarna behöver inte ha direkt kännedom om varandra. De kommunicerar endast med mäklaren.
- Horisontell skalbarhet: Du kan enkelt lägga till fler WebSocket-servrar när trafiken ökar, och alla ansluter till samma mäklare.
- Globala utskick: Meddelanden kan effektivt skickas till alla klienter, oavsett vilken server de är anslutna till.
Bortom utskick: närvaro
Meddelandemäklare används inte bara för att sända chattmeddelanden. De är viktiga för att synkronisera andra typer av distribuerat tillstånd, till exempel användarnärvaro.
När en användare till exempel loggar in kan den server som användaren är ansluten till publicera statusen ”online” till en Redis-kanal. Andra servrar prenumererar på denna kanal för att hålla sina listor över användare online uppdaterade.
Kontroll av meddelandemäklare
Föreställ dig ett scenario där du har flera WebSocket-servrar och ett meddelande som skickas till en server måste nå en klient som är ansluten till en annan server. Vilket mönster löser detta bäst?
Sammanfattning: distribuerat tillstånd
Vi har lärt oss att skalning av WebSocket-applikationer kräver hantering av distribuerat tillstånd. Meddelandeförmedlare som Redis, som använder Pub/Sub-mönstret, är avgörande för att flera WebSocket-servrar ska kunna kommunicera och synkronisera data. På så sätt får alla klienter relevanta uppdateringar, oavsett vilken server de är anslutna till.
Det gör applikationen mer motståndskraftig och skalbar när Ni lägger till fler serverinstanser.
Lär dig Programmering av WebSockets och system i realtid med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 47
Vanliga frågor
Är lektionen ”Distribuerad tillståndshantering” gratis?
Ja – hela texten till ”Distribuerad tillståndshantering” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Programmering av WebSockets och system i realtid, kan Ni uppgradera till CoddyKit PRO. Kursen i Programmering av WebSockets och system i realtid innehåller totalt 4 lektioner.
Vad lär jag mig i ”Distribuerad tillståndshantering”?
Utforska hur externa meddelandeförmedlare (t.ex. Redis Pub/Sub, Kafka) kan användas för att synkronisera tillstånd mellan flera WebSocket-servrar. Ni övar på Programmering av WebSockets och system i realtid med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Programmering av WebSockets och system i realtid?
Du behöver inga förkunskaper. Utbildningen i Programmering av WebSockets och system i realtid på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Distribuerad tillståndshantering”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Programmering av WebSockets och system i realtid-lektionen?
Ja. Varje Programmering av WebSockets och system i realtid-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Strategier för horisontell skalning
- Lastbalansering av WebSockets
- Distribuerad tillståndshantering
- Pub/Sub-backplane med Redis