Strategieën voor horizontale schaling
Begrijp hoe u WebSocket-verbindingen over meerdere serverinstanties verdeelt voor betere prestaties.
Strategieën voor horizontale schaling is een gratis Programmeren van WebSockets en realtime-systemen-les op CoddyKit. Dit is les 1 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.
Waarom WebSockets schalen?
Stel je voor dat je geweldige app plotseling enorm populair wordt! Duizenden, misschien zelfs miljoenen gebruikers willen tegelijk verbinding maken.
Een enkele server kan maar een beperkt aantal actieve WebSocket-verbindingen verwerken voordat die overbelast raakt. Het is alsof een snelweg met één rijstrook het verkeer tijdens de spits moet verwerken!
Om je app snel en betrouwbaar te houden, hebben we strategieën nodig om dit grote verkeersvolume te verwerken.
Opschalen of uitbreiden?
Wanneer één server niet genoeg is, heb je twee belangrijke opties om te schalen:
- Verticaal schalen: upgrade je bestaande server met meer CPU, RAM of snellere opslag. Zie het als het breder maken van je ene rijstrook.
- Horizontaal schalen: voeg meer servers toe om de belasting te verdelen. Dit is alsof je meer rijstroken aanlegt, of zelfs parallelle snelwegen bouwt!
Voor WebSockets heeft horizontaal schalen vaak de voorkeur. Het biedt meer veerkracht en flexibiliteit.
De uitdaging van status
WebSockets verschillen van traditionele HTTP-verzoeken. HTTP is vaak stateless, waarbij elk verzoek onafhankelijk is, terwijl WebSockets een stateful, permanente verbinding tot stand brengen.
Dat betekent dat een client en server een open communicatielijn onderhouden. Als je een client midden in een gesprek zomaar naar een andere server stuurt, weet die server niet wat er aan de hand is!
Deze 'status' maakt horizontaal schalen wat lastiger dan bij stateless API's.
Maak kennis met de load balancer
Om verkeer over meerdere servers te verdelen, gebruiken we een load balancer. Zie het als een slimme verkeersagent bij de ingang van je serverpark.
Het is zijn taak om binnenkomende clientverbindingen efficiënt door te sturen naar een van je beschikbare WebSocket-backendservers. Zo voorkom je dat één server een knelpunt wordt.
WebSocket-handshake en load balancer
Onthoud dat een WebSocket-verbinding begint als een HTTP-verzoek en vervolgens wordt 'geüpgraded' naar een WebSocket. Je load balancer moet dit proces begrijpen.
De load balancer moet zo worden geconfigureerd dat die de header Upgrade in het HTTP-verzoek correct verwerkt en vervolgens de TCP-verbinding voor het WebSocket-verkeer in stand houdt. Zonder dit komt de verbinding niet tot stand!
Het 'sticky' houden: sticky sessions
Omdat WebSockets stateful zijn, is het vaak belangrijk dat een client blijft communiceren met dezelfde backendserver waarmee die aanvankelijk verbinding heeft gemaakt.
Dit wordt bereikt met een techniek die sticky sessions of sessie-affiniteit wordt genoemd. De load balancer onthoudt welke server een client heeft gebruikt en stuurt alle volgende verzoeken van die client naar dezelfde server.
Veelgebruikte methoden zijn het IP-adres van de client of een speciale cookie.
Voorbeeld van een sticky session
Laten we een eenvoudige Node.js-WebSocketserver bekijken. Stel dat er meerdere exemplaren van deze server actief zijn. Met sticky sessions zou je client steeds verbinding maken met dezelfde server en dezelfde 'Server ID' krijgen.
Voer het volgende uit: npm install ws en daarna node server.js
const WebSocket = require('ws');
const http = require('http');
const serverId = `Server-${Math.floor(Math.random() * 100) + 1}`;
const server = http.createServer((req, res) => {
res.writeHead(200, { 'Content-Type': 'text/plain' });
res.end(`Hello from HTTP on ${serverId}\n`);
});
const wss = new WebSocket.Server({ server });
wss.on('connection', ws => {
console.log(`Client connected to ${serverId}`);
ws.send(`Welcome from ${serverId}!`);
ws.on('message', message => {
console.log(`Received on ${serverId}: ${message}`);
ws.send(`Echo from ${serverId}: ${message}`);
});
ws.on('close', () => {
console.log(`Client disconnected from ${serverId}`);
});
});
server.listen(8080, () => {
console.log(`${serverId} listening on port 8080`);
});Beperkingen van sticky sessions
Hoewel sticky sessions uitstekend werken om de verbinding van een client met één server te behouden, hebben ze ook nadelen:
- Serverstoring: Als de server waaraan de client is gekoppeld crasht, verliest de client zijn verbinding en moet de status mogelijk opnieuw worden opgebouwd op een nieuwe server.
- Communicatie tussen servers: Als een client op server A een bericht moet sturen naar een client op server B, lossen sticky sessions dat op zichzelf niet op.
Voor complexere scenario's heb je geavanceerdere strategieën nodig. Die behandelen we later!
Methoden voor load balancing
Load balancers gebruiken verschillende algoritmen om te bepalen waar ze nieuwe verbindingen naartoe sturen:
- Round-robin: Stuurt verbindingen in een roulerende volgorde naar servers (server A, daarna B, daarna C, daarna A...).
- Minste aantal verbindingen: Stuurt verbindingen naar de server met de minste actieve verbindingen.
- IP-hash: Gebruikt het IP-adres van de client om deze steeds naar dezelfde server te sturen (ideaal voor sticky sessions).
De keuze hangt af van de behoeften van je applicatie.
Korte controle: WebSockets schalen
Je hebt geleerd over horizontaal schalen en over de rol van load balancers en sticky sessions. Laten we testen of je het begrijpt!
Samenvatting: opschalen!
Goed gedaan! In deze les heb je geleerd waarom horizontaal schalen belangrijk is voor WebSocketapplicaties met veel verkeer.
- Horizontaal schalen voegt meer servers toe om een hogere belasting te verwerken.
- Load balancers verdelen binnenkomende verbindingen over deze servers.
- Ze moeten het proces voor de WebSocket-upgrade ondersteunen.
- Sticky sessions zorgen ervoor dat een client steeds verbinding maakt met dezelfde backendserver, zodat de status behouden blijft.
Vervolgens bekijken we hoe je deze load balancers effectief configureert!
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
Veelgestelde vragen
Is de les “Strategieën voor horizontale schaling” gratis?
Ja — de volledige tekst van “Strategieën voor horizontale schaling” 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 “Strategieën voor horizontale schaling”?
Begrijp hoe u WebSocket-verbindingen over meerdere serverinstanties verdeelt voor betere prestaties. 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 1 van 4.
Hoe lang duurt de les “Strategieën voor horizontale schaling”?
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
- Strategieën voor horizontale schaling
- WebSockets loadbalancen
- Gedistribueerd statusbeheer
- Pub/sub-backplane met Redis