Programmering av WebSockets og sanntidssystemer · leksjon

Ytelsesmåling av WebSocket

Bruk verktøy og teknikker til å måle ytelse, forsinkelse og gjennomstrømming for WebSocket-serverne Deres.

Leksjon 1 av 411 trinn

Ytelsesmåling av WebSocket er en gratis leksjon i Programmering av WebSockets og sanntidssystemer på CoddyKit. Dette er leksjon 1 av 4. Du kan lese hele leksjonen gratis nedenfor – og deretter øve praktisk i nettleseren med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Programmering av WebSockets og sanntidssystemer, og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Programmering av WebSockets og sanntidssystemer inneholder totalt 4 leksjoner.

Hvorfor referansetest WebSockets?

Når du bygger sanntidsapplikasjoner med WebSockets, er ytelse avgjørende. Referansetesting hjelper oss med å forstå hvordan serveren oppfører seg under ulik belastning.

Det er som å stressteste systemet før det settes i produksjon. Du vil kjenne grensene, finne flaskehalser og sikre at det kan håndtere forventet brukertrafikk uten problemer.

Kapasitetsplanlegging: Hvor mange brukere kan serveren håndtere?
Ytelsesjustering: Finn de langsomme delene av koden.
Regresjonstesting: Sørg for at nye endringer ikke forringer ytelsen.

Viktige WebSocket-måltall

For å evaluere ytelsen ser vi på bestemte måltall:

Forsinkelse: Tiden det tar for en melding å reise fra klienten til serveren og tilbake (Round-Trip Time). Lavere er bedre.
Gjennomstrømming: Antallet meldinger eller byte som behandles per sekund. Høyere er bedre.
Samtidighet: Det maksimale antallet aktive forbindelser eller klienter samtidig som serveren kan håndtere. Høyere er bedre.
Feilrate: Prosentandelen mislykkede operasjoner. Lavere er bedre.

Verktøy for referansetesting

Flere verktøy kan hjelpe deg med å referanseteste WebSocket-applikasjoner. De varierer fra enkle skript til dedikerte plattformer for belastningstesting.

Egendefinerte skript: Bruk biblioteker som ws (Node.js) til å skrive egne klientsimulatorer.
Verktøy for belastningstesting: Verktøy som Apache JMeter, k6 (Grafana Labs) eller Gatling kan simulere tusenvis av samtidige brukere og forbindelser.
Overvåkingsverktøy: Er ofte integrert med referansetesting for å følge med på serverens ressursbruk (CPU, minne) under testene.

Enkel WebSocket-echo-server

Før vi kan utføre referansetesting, trenger vi en WebSocket-server å teste mot. Her er en enkel Node.js-«echo»-server som sender tilbake alt den mottar.

Lagre dette som server.js og kjør med node server.js (sørg for at ws er installert: 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');

Opprette én testklient

La oss nå opprette en klient som kobler til ekkoserveren vår, sender en melding og mottar den tilbake. Dette danner grunnlaget for ytelsestestene våre.

Lagre dette som client.js, og kjør det med node client.js etter at serveren er startet.

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');

Simulering av flere klienter

Ytelsesmåling krever simulering av mange samtidige klienter. Vi kan endre klientskriptet vårt slik at det oppretter flere WebSocket-tilkoblinger.

Hver klient kobler til, sender en melding og måler sin egen ytelse. Når vi samler disse resultatene, får vi et helhetlig bilde av systemet.

Bruk en løkke til å opprette mange WebSocket-instanser.
Administrer tilkoblingstilstander og meldingstellinger for hver klient.
Samle inn ytelsesdata (for eksempel ventetid) fra hver klient.

Måling av meldingsventetid

For å måle ventetid sender klienten en melding som inneholder et tidsstempel. Når serveren ekker den tilbake, beregner klienten tidsforskjellen.

Dette eksempelet utvider klienten vår slik at den måler rundturtiden for én enkelt melding.

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');

Måling av meldingsgjennomstrømning

Gjennomstrømning måles ofte som antall meldinger per sekund. En klient kan sende meldinger kontinuerlig og telle hvor mange svar den mottar innenfor et bestemt tidsrom.

Dette skriptet sender 1000 meldinger og rapporterer total tid og antall meldinger per sekund.

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');

Tolkning av resultatene

Rå tall fra ytelsesmålinger er bare begynnelsen. Den virkelige verdien kommer når de tolkes i riktig sammenheng:

Sammenlign med referanseverdier: Hvordan er de nåværende resultatene sammenlignet med tidligere tester eller forventet ytelse?
Se etter trender: Øker ventetiden kraftig når antallet samtidige brukere øker? Flater gjennomstrømningen ut?
Finn flaskehalser: Høy CPU-bruk på serveren, overbelastning i nettverket eller konkurranse om databaseressurser er vanlige årsaker.
Gjenta og forbedre: Bruk dataene til å gjøre endringer, og mål ytelsen på nytt for å se effekten.

Rask kontroll av måleverdier

De tester en WebSocket-server og observerer at tiden det tar å sende en melding og motta den tilbake, øker betydelig når flere klienter kobler til. Hvilken ytelsesverdi blir hovedsakelig dårligere?

Besvar den i den interaktive leksjonen

Oppsummering: Ytelsesmåling av WebSockets

I denne leksjonen utforsket vi betydningen av å måle ytelsen til WebSocket-applikasjoner. Vi lærte om viktige måleverdier som ventetid, gjennomstrømning og samtidighet.

De så hvordan man setter opp en enkel ekkoserver og skriver skript på klientsiden for å måle disse verdiene. Det er avgjørende å tolke resultatene for å optimalisere sanntidssystemer og sikre at de tåler belastningen i produksjon.

Gratis å komme i gang

Lær deg Programmering av WebSockets og sanntidssystemer med en AI-veileder – gratis

Skriv og kjør ekte kode i nettleseren, få umiddelbar hjelp fra en AI-veileder som er tilgjengelig døgnet rundt, og fortsett der du slapp – på nettet eller i appen.

Kurs: 12
Leksjoner: 47

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Ytelsesmåling av WebSocket» gratis?

Ja – hele teksten i «Ytelsesmåling av WebSocket» er gratis å lese her på nettet. For å øve interaktivt med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt, og for å låse opp resten av Programmering av WebSockets og sanntidssystemer-kurset, kan du oppgradere til CoddyKit PRO. Kurset i Programmering av WebSockets og sanntidssystemer inneholder totalt 4 leksjoner.

Hva lærer jeg i «Ytelsesmåling av WebSocket»?

Bruk verktøy og teknikker til å måle ytelse, forsinkelse og gjennomstrømming for WebSocket-serverne Deres. Du øver på Programmering av WebSockets og sanntidssystemer med praktisk kode som du kjører direkte i nettleseren, mens en AI-veileder som er tilgjengelig døgnet rundt, svarer på spørsmålene dine mens du jobber deg gjennom leksjonen.

Trenger jeg erfaring for å begynne med Programmering av WebSockets og sanntidssystemer?

Ingen tidligere erfaring er nødvendig. Programmering av WebSockets og sanntidssystemer på CoddyKit er lagt opp for både nybegynnere og viderekomne, så De kan begynne her eller helt fra start og lære i Deres eget tempo. Dette er leksjon 1 av 4.

Hvor lang tid tar leksjonen «Ytelsesmåling av WebSocket»?

De fleste CoddyKit-leksjoner tar omtrent 5–10 minutter. Hver leksjon er kort og interaktiv, slik at De gjør jevne fremskritt og kan fortsette akkurat der De slapp – både på nettet og i appen.

Kan jeg skrive og kjøre kode i denne Programmering av WebSockets og sanntidssystemer-leksjonen?

Ja. Alle Programmering av WebSockets og sanntidssystemer-leksjoner har en innebygd kodeeditor, slik at De kan skrive og kjøre ekte kode direkte i nettleseren og få umiddelbar tilbakemelding fra AI – uten lokal konfigurering.

Alle leksjonene i dette kurset

Ytelsesmåling av WebSocket
Profilering og feilsøking av sanntidsproblemer
Sanntidsovervåking og varsling
Lasttesting og kapasitetsplanlegging for WebSockets

← Tilbake til Programmering av WebSockets og sanntidssystemer