Programmeren van WebSockets en realtime-systemen · Les

WebSocket-prestaties benchmarken

Gebruik tools en technieken om de prestaties, latentie en doorvoer van uw WebSocket-servers te meten.

Les 1 van 411 stappen

WebSocket-prestaties benchmarken 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 benchmarken?

Bij het bouwen van realtime-toepassingen met WebSockets zijn prestaties essentieel. Benchmarken helpt ons te begrijpen hoe onze server zich onder verschillende belastingen gedraagt.

Het is alsof je je systeem aan een stresstest onderwerpt voordat het live gaat. Je wilt de grenzen ervan kennen, knelpunten identificeren en zeker weten dat het de verwachte gebruikersbelasting aankan zonder problemen.

Capaciteitsplanning: Hoeveel gebruikers kan je server aan?
Prestatieoptimalisatie: Identificeer trage delen van je code.
Regressietests: Zorg ervoor dat nieuwe wijzigingen de prestaties niet verslechteren.

Belangrijke WebSocket-metrieken

Om prestaties te beoordelen kijken we naar specifieke metrieken:

Latentie: De tijd die een bericht nodig heeft om van client naar server en terug te reizen (Round-Trip Time). Lager is beter.
Verwerkingscapaciteit: Het aantal berichten of bytes dat per seconde wordt verwerkt. Hoger is beter.
Gelijktijdigheid: Het maximale aantal gelijktijdig actieve verbindingen of clients dat de server aankan. Hoger is beter.
Foutpercentage: Het percentage mislukte bewerkingen. Lager is beter.

Hulpmiddelen voor benchmarken

Verschillende hulpmiddelen kunnen je helpen WebSocket-toepassingen te benchmarken. Dit varieert van eenvoudige scripts tot speciale platforms voor belastingtests.

Aangepaste scripts: Bibliotheken zoals ws (Node.js) gebruiken om je eigen clientsimulatoren te schrijven.
Hulpmiddelen voor belastingtests: Hulpmiddelen zoals Apache JMeter, k6 (Grafana Labs) of Gatling kunnen duizenden gelijktijdige gebruikers en verbindingen simuleren.
Hulpmiddelen voor monitoring: Deze zijn vaak geïntegreerd met benchmarken om het gebruik van serverbronnen (CPU, geheugen) tijdens tests te observeren.

Eenvoudige echo-WebSocket-server

Voordat we kunnen benchmarken, hebben we een WebSocket-server nodig om tegen te testen. Hier is een eenvoudige Node.js-"echo"-server die alles wat hij ontvangt terugstuurt.

Sla dit op als server.js en voer het uit met node server.js (zorg ervoor dat ws is geïnstalleerd: npm install ws).

const WebSocket = require('ws');

const wss = new WebSocket.Server({ port: 8080 });

wss.on('connection', ws => {
  console.log('Client connected');
  ws.on('message', message => {
    // Echo back the received message
    ws.send(message.toString());
  });
  ws.on('close', () => console.log('Client disconnected'));
  ws.on('error', error => console.error('WS Error:', error));
});

console.log('WebSocket server started on port 8080');

Eén testclient maken

Laten we nu een client maken die verbinding maakt met onze echo-server, een bericht verstuurt en het weer ontvangt. Dit vormt de basis voor onze prestatietests.

Sla dit op als client.js en voer het uit met node client.js nadat je de server hebt gestart.

const WebSocket = require('ws');

const ws = new WebSocket('ws://localhost:8080');

ws.onopen = () => {
  console.log('Connected to server');
  ws.send('Hello WebSocket!');
};

ws.onmessage = event => {
  console.log('Received:', event.data);
  ws.close(); // Close after receiving the echo
};

ws.onerror = error => console.error('WS Error:', error.message);
ws.onclose = () => console.log('Disconnected');

Meerdere clients simuleren

Voor benchmarking moet je veel gelijktijdige clients simuleren. We kunnen ons clientscript aanpassen om meerdere WebSocket-verbindingen te maken.

Elke client maakt verbinding, verstuurt een bericht en meet zijn eigen prestaties. Door deze resultaten samen te voegen, krijgen we een beeld van het hele systeem.

Gebruik een lus om veel WebSocket-instanties te maken.
Beheer de verbindingsstatus en het aantal berichten voor elke client.
Verzamel prestatiegegevens, zoals latentie, van elke client.

Berichtlatentie meten

Om de latentie te meten, verstuurt de client een bericht met een tijdstempel. Wanneer de server dit terugstuurt, berekent de client het tijdsverschil.

Dit voorbeeld breidt onze client uit om de rondreistijd van één bericht te meten.

const WebSocket = require('ws');

const ws = new WebSocket('ws://localhost:8080');
let startTime;

ws.onopen = () => {
  console.log('Connected for latency test');
  startTime = Date.now();
  ws.send(JSON.stringify({ timestamp: startTime, msg: 'Ping' }));
};

ws.onmessage = event => {
  const endTime = Date.now();
  const data = JSON.parse(event.data);
  const latency = endTime - data.timestamp;
  console.log(`Received echo: ${data.msg}. Latency: ${latency} ms`);
  ws.close();
};

ws.onerror = error => console.error('WS Error:', error.message);
ws.onclose = () => console.log('Latency test finished');

Berichtdoorvoer meten

Doorvoer wordt vaak gemeten in berichten per seconde. Een client kan continu berichten versturen en tellen hoeveel antwoorden hij binnen een bepaalde tijd ontvangt.

Dit script verstuurt 1000 berichten en rapporteert de totale tijd en het aantal berichten per seconde.

const WebSocket = require('ws');

const ws = new WebSocket('ws://localhost:8080');
const totalMessages = 1000;
let messagesReceived = 0;
let testStartTime;

ws.onopen = () => {
  console.log('Connected for throughput test');
  testStartTime = Date.now();
  for (let i = 0; i < totalMessages; i++) {
    ws.send(`Message ${i}`);
  }
};

ws.onmessage = event => {
  messagesReceived++;
  if (messagesReceived === totalMessages) {
    const endTime = Date.now();
    const duration = (endTime - testStartTime) / 1000; // seconds
    const throughput = totalMessages / duration;
    console.log(`Received ${totalMessages} messages in ${duration.toFixed(2)}s.`);
    console.log(`Throughput: ${throughput.toFixed(2)} messages/second.`);
    ws.close();
  }
};

ws.onerror = error => console.error('WS Error:', error.message);
ws.onclose = () => console.log('Throughput test finished');

Je resultaten interpreteren

Ruwe cijfers van benchmarking zijn slechts het begin. De echte waarde ontstaat wanneer je ze in hun context interpreteert:

Vergelijk met referentiewaarden: Hoe verhouden je huidige resultaten zich tot eerdere tests of de verwachte prestaties?
Zoek naar trends: Neemt de latentie sterk toe bij meer gelijktijdige gebruikers? Bereikt de doorvoer een plateau?
Identificeer knelpunten: Hoog CPU-gebruik op de server, netwerkverzadiging of conflicten om toegang tot de database zijn veelvoorkomende oorzaken.
Herhaal en verbeter: Gebruik de gegevens om wijzigingen aan te brengen en voer daarna opnieuw een benchmark uit om het effect te zien.

Korte controle van meetwaarden

Je test een WebSocket-server en merkt dat de tijd die nodig is om een bericht te versturen en terug te ontvangen sterk toeneemt naarmate meer clients verbinding maken. Welke prestatiemaatstaf gaat voornamelijk achteruit?

Beantwoord dit in de interactieve les

Samenvatting: WebSockets benchmarken

In deze les hebben we het belang van benchmarking van WebSocket-toepassingen onderzocht. We hebben belangrijke meetwaarden behandeld, zoals latentie, doorvoer en gelijktijdigheid.

Je hebt gezien hoe je een eenvoudige echo-server instelt en clientscripts schrijft om deze meetwaarden te meten. Het interpreteren van deze resultaten is essentieel om je realtime systemen te optimaliseren en ervoor te zorgen dat ze productieladingen aankunnen.

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 “WebSocket-prestaties benchmarken” gratis?

Ja — de volledige tekst van “WebSocket-prestaties benchmarken” 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 “WebSocket-prestaties benchmarken”?

Gebruik tools en technieken om de prestaties, latentie en doorvoer van uw WebSocket-servers te meten. 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 “WebSocket-prestaties benchmarken”?

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

WebSocket-prestaties benchmarken
Realtimeproblemen profileren en debuggen
Realtime monitoring en meldingen
Loadtesting en capaciteitsplanning voor WebSockets

← Terug naar Programmeren van WebSockets en realtime-systemen