Lasttesting og ytelsesreferansetesting (JMeter og k6) · leksjon

Scenarier for virtuelle brukere (VUs)

Definer og administrer ulike scenarier for virtuelle brukere for å simulere forskjellige belastningsmønstre effektivt.

Leksjon 1 av 411 trinn

Scenarier for virtuelle brukere (VUs) er en gratis leksjon i Lasttesting og ytelsesreferansetesting (JMeter og k6) på CoddyKit. Dette er leksjon 1 av 4. Du kan lese valgfritt 3 leksjoner fra denne læringsstien gratis i sin helhet – deretter låser CoddyKit PRO opp alle leksjoner, samt praktisk øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Den er en del av læringsløpet i Lasttesting og ytelsesreferansetesting (JMeter og k6), og fremdriften din synkroniseres mellom nettet og CoddyKit-appen. Kurset i Lasttesting og ytelsesreferansetesting (JMeter og k6) inneholder totalt 4 leksjoner.

Mer enn enkel belastning: k6-scenarioer

Ved ytelsestesting er det ikke sikkert at en enkel test som «kjør 10 VU-er i 30 sekunder» gjenspeiler ekte brukeradferd. Ekte brukere har ofte ulike mønstre: Noen logger inn, noen navigerer, og noen gjennomfører kjøp. Det er her k6-scenarioer kommer inn!

Scenarioer lar deg definere komplekse belastningsprofiler og simulere ulike brukergrupper, hver med sin egen spesifikke adferd og sitt eget belastningsmønster, i ett og samme testskript.

Definer testscenarioene dine

I k6 definerer du scenarioer i options-objektet i testskriptet. Blokken scenarios er et JavaScript-objekt der hver nøkkel representerer et unikt scenarionavn.

Hvert scenario angir en executor, som bestemmer hvordan virtuelle brukere (VU-er) og iterasjoner administreres. Det kobler også scenarioet til en bestemt funksjon i skriptet som definerer hva disse VU-ene skal gjøre.

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

Grunnleggende scenario: Delte iterasjoner

Den innebygde k6-kjøreren shared-iterations fordeler et fast antall iterasjoner mellom en gruppe VU-er. Hver VU utfører så mange iterasjoner som mulig, frem til alle angitte iterasjoner er fullført eller testens varighet utløper.

Dette passer godt for tester der du vil fullføre en bestemt arbeidsmengde.

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

Konstant belastning med `constant-VUs`

Kjøreren constant-VUs opprettholder et fast antall virtuelle brukere gjennom hele testens varighet. VU-ene startes ved begynnelsen og forblir aktive til duration er nådd.

Dette er nyttig for å simulere en jevn, kontinuerlig belastning på systemet.

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

Gradvis belastning med `ramping-VUs`

Kjøreren ramping-VUs lar deg gradvis øke eller redusere antallet virtuelle brukere over tid. Dette simulerer en mer realistisk belastningskurve, for eksempel når brukere sakte kommer inn på eller forlater et nettsted.

Den bruker stages til å definere disse endringene i antallet VU-er.

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

Strukturer belastningen med trinn

I ramping-VUs er stages en rekke objekter, der hvert objekt har en duration og et target-antall VU-er.

duration: Hvor lenge dette trinnet varer, for eksempel «1m» eller «30s».
target: Antallet VU-er som skal nås ved slutten av dette trinnet. k6 øker eller reduserer antallet VU-er lineært fra sluttmålet i det gjeldende trinnet til målet for det neste trinnet.

Trinn er nyttige for å modellere komplekse belastningsmønstre, for eksempel rushtid eller plutselige trafikktopper.

Kontroller forespørselsraten: `ramping-arrival-rate`

I motsetning til VU-baserte kjørere er ramping-arrival-rate en kjører med en åpen modell. Den styrer hvor raskt nye iterasjoner (eller «ankomster») startes, i stedet for antallet VU-er.

Dette er ideelt for å teste systemer der du er opptatt av forespørsler per sekund (RPS) eller transaksjoner per sekund (TPS).

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
}

Kombiner ulike brukeradferder

Du kan definere flere, uavhengige scenarioer i ett enkelt k6-skript. Hvert scenario kan ha sin egen kjører, sine egne VU-er og sin egen varighet, og kan til og med kalle en annen funksjon som definerer den spesifikke brukerreisen.

Dette lar deg simulere en blanding av brukertyper, for eksempel administratorer, vanlige brukere og gjester, i én omfattende test.

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

Finjuster scenario-kjøringen

I tillegg til grunnleggende innstillinger for kjøreren tilbyr scenarioer flere alternativer for presis kontroll:

startTime: Forsink starten av et bestemt scenario, for eksempel «10s» etter teststart. Nyttig for forskjøvede tester.
gracefulStop: Hvor lenge k6 skal vente på at aktive VU-er fullfører den gjeldende iterasjonen før de stoppes med tvang, for eksempel «5s».
env: Miljøvariabler som gjelder spesifikt for dette scenarioet.

Disse alternativene hjelper deg med å koordinere komplekse testforløp.

Scenario-utfordring

Du må simulere en belastningstest der:

5 virtuelle brukere (VU-er) kontinuerlig navigerer på hjemmesiden i 1 minutt.
En annen brukergruppe samtidig øker gradvis fra 0 til 10 VU-er i løpet av 30 sekunder, holder seg på 10 VU-er i 30 sekunder og utfører en innlogging.

Hvilke to k6-kjørere passer best for disse to ulike brukeradferdene?

Besvar den i den interaktive leksjonen

Scenarioer: Belastningsorkestratoren din

I denne leksjonen har du lært hvordan k6-scenarioer lar deg modellere ulike og realistiske belastningsmønstre. Vi har sett på flere viktige kjørere:

shared-iterations for en fast arbeidsmengde.
constant-VUs for jevn belastning.
ramping-VUs for gradvise belastningsendringer med stages.
ramping-arrival-rate for testing med åpen modell basert på forespørselsrate.

Du har også sett hvordan du kan kombinere flere scenarioer og bruke alternativer som startTime for avansert kontroll. Det er avgjørende å beherske scenarioer for avansert ytelsestesting!

Gratis å komme i gang

Lær deg Lasttesting og ytelsesreferansetesting (JMeter og k6) 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: 48

Start læringen gratis Se hele kurset

Ofte stilte spørsmål

Er leksjonen «Scenarier for virtuelle brukere (VUs)» gratis?

Ja – du kan lese valgfritt 3 av leksjonene i læringsstien Lasttesting og ytelsesreferansetesting (JMeter og k6), inkludert «Scenarier for virtuelle brukere (VUs)», gratis i sin helhet her på nettet. Deretter låser CoddyKit PRO opp alle leksjoner, samt interaktiv øving med en innebygd kodeeditor og en AI-veileder som er tilgjengelig døgnet rundt. Kurset i Lasttesting og ytelsesreferansetesting (JMeter og k6) inneholder totalt 4 leksjoner.

Hva lærer jeg i «Scenarier for virtuelle brukere (VUs)»?

Definer og administrer ulike scenarier for virtuelle brukere for å simulere forskjellige belastningsmønstre effektivt. Du øver på Lasttesting og ytelsesreferansetesting (JMeter og k6) 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 Lasttesting og ytelsesreferansetesting (JMeter og k6)?

Ingen tidligere erfaring er nødvendig. Lasttesting og ytelsesreferansetesting (JMeter og k6) 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 «Scenarier for virtuelle brukere (VUs)»?

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 Lasttesting og ytelsesreferansetesting (JMeter og k6)-leksjonen?

Ja. Alle Lasttesting og ytelsesreferansetesting (JMeter og k6)-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

← Tilbake til Lasttesting og ytelsesreferansetesting (JMeter og k6)