Loadtesten en prestatiebenchmarking (JMeter en k6) · Les

Scenario's met virtuele gebruikers (VUs)

Definieer en beheer verschillende scenario's met virtuele gebruikers om uiteenlopende belastingspatronen effectief te simuleren.

Les 1 van 411 stappen

Scenario's met virtuele gebruikers (VUs) is een gratis Loadtesten en prestatiebenchmarking (JMeter en k6)-les op CoddyKit. Dit is les 1 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Loadtesten en prestatiebenchmarking (JMeter en k6). Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Loadtesten en prestatiebenchmarking (JMeter en k6) bevat in totaal 4 lessen.

Verder dan eenvoudige belasting: k6-scenario's

Bij prestatietests legt een eenvoudige test als '10 VU's gedurende 30 seconden uitvoeren' mogelijk niet het gedrag van echte gebruikers vast. Echte gebruikers hebben vaak verschillende patronen: sommigen melden zich aan, sommigen bladeren rond en sommigen doen aankopen. Daar komen k6-scenario's van pas!

Met scenario's kun je complexe belastingprofielen definiëren en diverse gebruikersgroepen simuleren, elk met hun eigen specifieke gedrag en belastingspatroon, allemaal binnen één testscript.

Je testscenario's definiëren

In k6 definieer je scenario's binnen het object options van je testscript. Het blok scenarios is een JavaScript-object waarin elke sleutel een unieke scenarionaam vertegenwoordigt.

Elk scenario specificeert een uitvoerder, die bepaalt hoe virtuele gebruikers (VU's) en iteraties worden beheerd. Het scenario verwijst ook naar een specifieke functie in je script die bepaalt wat die VU's doen.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    // Scenario definitions go here
  },
};

export default function () {
  http.get('https://test.k6.io');
  sleep(1);
}

Basisscenario: gedeelde iteraties

De standaarduitvoerder van k6, shared-iterations, verdeelt een vast aantal iteraties over een groep VU's. Elke VU voert zoveel iteraties uit als mogelijk is totdat alle opgegeven iteraties zijn voltooid of de testduur is verstreken.

Dit is geschikt voor tests waarin je een specifieke hoeveelheid werk wilt voltooien.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    my_scenario: {
      executor: 'shared-iterations',
      vus: 5,
      iterations: 20,
      maxDuration: '30s',
    },
  },
};

export default function () {
  http.get('https://test.k6.io');
  sleep(1);
}

Constante belasting met `constant-VUs`

De uitvoerder constant-VUs houdt gedurende de volledige testduur een vast aantal virtuele gebruikers actief. VU's worden aan het begin gestart en blijven actief totdat de duration is verstreken.

Dit is handig om een gelijkmatige, voortdurende belasting op je systeem te simuleren.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    constant_load: {
      executor: 'constant-VUs',
      vus: 10,
      duration: '1m', // Run 10 VUs for 1 minute
    },
  },
};

export default function () {
  http.get('https://test.k6.io/news.php');
  sleep(2);
}

Geleidelijke belasting met `ramping-VUs`

Met de uitvoerder ramping-VUs kun je het aantal virtuele gebruikers geleidelijk verhogen of verlagen. Hiermee simuleer je een realistischer belastingverloop, bijvoorbeeld wanneer gebruikers langzaam een website bezoeken of verlaten.

De uitvoerder gebruikt fasen om deze veranderingen in het aantal VU's te definiëren.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    gradual_load: {
      executor: 'ramping-VUs',
      startVUs: 0,
      stages: [
        { duration: '30s', target: 20 }, // Ramp up to 20 VUs over 30s
        { duration: '1m', target: 20 },  // Stay at 20 VUs for 1 minute
        { duration: '20s', target: 0 },  // Ramp down to 0 VUs over 20s
      ],
    },
  },
};

export default function () {
  http.get('https://test.k6.io/contacts.php');
  sleep(1);
}

Belasting structureren met fasen

Binnen ramping-VUs zijn fasen een array van objecten, elk met een duration en een doelwaarde voor het aantal VU's.

duration: Hoe lang deze fase duurt, bijvoorbeeld '1m' of '30s'.
target: Het aantal VU's dat aan het einde van deze fase moet zijn bereikt. k6 verhoogt of verlaagt het aantal VU's lineair van de einddoelwaarde van de huidige fase naar de doelwaarde van de volgende fase.

Fasen zijn krachtig voor het modelleren van complexe belastingspatronen, zoals piekuren of plotselinge verkeerspieken.

Aanvraagsnelheid regelen: `ramping-arrival-rate`

In tegenstelling tot uitvoerders op basis van VU's is ramping-arrival-rate een uitvoerder met een open model. Deze bepaalt de snelheid waarmee nieuwe iteraties (of 'aankomsten') worden gestart, in plaats van het aantal VU's.

Dit is ideaal voor het testen van systemen waarbij het aantal aanvragen per seconde (RPS) of transacties per seconde (TPS) belangrijk is.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    arrival_rate_test: {
      executor: 'ramping-arrival-rate',
      startRate: 0, // Initial iterations per second
      timeUnit: '1s', // How often 'rate' is applied
      stages: [
        { duration: '30s', target: 10 }, // Ramp up to 10 iterations/s over 30s
        { duration: '1m', target: 10 },  // Stay at 10 iterations/s for 1 minute
      ],
      preAllocatedVUs: 20, // Initial VUs to allocate
      maxVUs: 50,         // Max VUs to spin up if needed
    },
  },
};

export default function () {
  http.get('https://test.k6.io/login.php');
  sleep(0.5); // Simulate some user think time
}

Verschillende gebruikersgedragingen combineren

Je kunt meerdere, onafhankelijke scenario's definiëren binnen één k6-script. Elk scenario kan een eigen uitvoerder, aantal VU's en duur hebben en zelfs een andere functie aanroepen die de specifieke gebruikersroute definieert.

Zo kun je in één uitgebreide test een mix van gebruikerstypen simuleren, zoals beheerders, gewone gebruikers en gasten.

import http from 'k6/http';
import { sleep } from 'k6';

export const options = {
  scenarios: {
    anonymous_browsing: {
      executor: 'constant-VUs',
      vus: 5,
      duration: '30s',
      exec: 'anonymousBrowser', // Call this function
    },
    authenticated_user: {
      executor: 'ramping-VUs',
      startVUs: 0,
      stages: [{ duration: '20s', target: 3 }],
      exec: 'loggedInUser', // Call this function
    },
  },
};

export function anonymousBrowser() {
  http.get('https://test.k6.io/');
  sleep(2);
}

export function loggedInUser() {
  // Simulate login (not actual login, just for demo)
  http.post('https://test.k6.io/login', { username: 'user', password: 'pass' });
  sleep(1);
  http.get('https://test.k6.io/my-profile');
  sleep(2);
}

De uitvoering van scenario's verfijnen

Naast de basisinstellingen van een uitvoerder bieden scenario's extra opties voor nauwkeurige controle:

startTime: Vertraagt de start van een specifiek scenario, bijvoorbeeld met '10s' na de start van de test. Handig voor tests met verspringende starts.
gracefulStop: Bepaalt hoelang k6 wacht totdat actieve VU's hun huidige iteratie hebben voltooid voordat ze geforceerd worden gestopt, bijvoorbeeld '5s'.
env: Omgevingsvariabelen die specifiek zijn voor dit scenario.

Met deze opties kun je complexe testverlopen orkestreren.

Scenario-uitdaging

Je moet een belastingtest simuleren waarin:

5 virtuele gebruikers (VU's) gedurende 1 minuut voortdurend de homepage bekijken.
Tegelijkertijd een andere gebruikersgroep in 30 seconden geleidelijk toeneemt van 0 naar 10 VU's, vervolgens 30 seconden op 10 VU's blijft en een aanmeldactie uitvoert.

Welke twee k6-uitvoerders zijn het meest geschikt voor deze twee verschillende gebruikersgedragingen?

Beantwoord dit in de interactieve les

Scenario's: je orkestrator voor belasting

In deze les heb je geleerd hoe scenario's in k6 je in staat stellen om diverse en realistische belastingspatronen te modelleren. We hebben de belangrijkste uitvoerders besproken:

shared-iterations voor een vaste hoeveelheid werk.
constant-VUs voor een constante belasting.
ramping-VUs voor geleidelijke veranderingen in de belasting met fasen.
ramping-arrival-rate voor tests met een open model op basis van de aanvraagsnelheid.

Je hebt ook gezien hoe je meerdere scenario's combineert en opties zoals startTime gebruikt voor geavanceerde controle. Scenario's beheersen is essentieel voor geavanceerde prestatietests!

Gratis beginnen

Leer Loadtesten en prestatiebenchmarking (JMeter en k6) 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: 48

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Scenario's met virtuele gebruikers (VUs)” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Loadtesten en prestatiebenchmarking (JMeter en k6), waaronder “Scenario's met virtuele gebruikers (VUs)”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Loadtesten en prestatiebenchmarking (JMeter en k6) bevat in totaal 4 lessen.

Wat leer ik in “Scenario's met virtuele gebruikers (VUs)”?

Definieer en beheer verschillende scenario's met virtuele gebruikers om uiteenlopende belastingspatronen effectief te simuleren. Je oefent met Loadtesten en prestatiebenchmarking (JMeter en k6) 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 Loadtesten en prestatiebenchmarking (JMeter en k6) te beginnen?

Ervaring vooraf is niet nodig. Loadtesten en prestatiebenchmarking (JMeter en k6) 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 “Scenario's met virtuele gebruikers (VUs)”?

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 Loadtesten en prestatiebenchmarking (JMeter en k6)?

Ja. Elke les over Loadtesten en prestatiebenchmarking (JMeter en k6) 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

Scenario's met virtuele gebruikers (VUs)
Gegevensparametrisering in k6
Uitvoering in de cloud met k6
Custom metrics en trends in k6

← Terug naar Loadtesten en prestatiebenchmarking (JMeter en k6)