0Pricing
Load Testing & Performance Benchmarking (JMeter & k6) · Урок

Сценарии виртуальных пользователей (VUs)

Определяйте и управляйте различными сценариями виртуальных пользователей, эффективно имитируя разнообразные профили нагрузки

«Сценарии виртуальных пользователей (VUs)» — бесплатный урок Load Testing & Performance Benchmarking (JMeter & k6) на CoddyKit. Это урок 1 из 4. Ты можешь прочитать весь урок бесплатно ниже — а потом практиковать его прямо в браузере с встроенным редактором кода и ИИ-репетитором 24/7. Это часть пути обучения Load Testing & Performance Benchmarking (JMeter & k6), и твой прогресс синхронизируется между веб-версией и приложением CoddyKit. Курс Load Testing & Performance Benchmarking (JMeter & k6) содержит 4 уроков всего.

Части этого урока еще не переведены и отображаются на английском.

Beyond Simple Load: k6 Scenarios

When performance testing, a simple 'run 10 VUs for 30 seconds' might not capture real user behavior. Real users often have different patterns: some log in, some browse, some make purchases. This is where k6 scenarios come in!

Scenarios allow you to define complex load profiles and simulate diverse user groups, each with its own specific behavior and load pattern, all within a single test script.

Defining Your Test Scenarios

In k6, you define scenarios within the options object of your test script. The scenarios block is a JavaScript object where each key represents a unique scenario name.

Each scenario specifies an executor, which dictates how virtual users (VUs) and iterations are managed. It also links to a specific function in your script that defines what those VUs will do.

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

Basic Scenario: Shared Iterations

The default k6 executor, shared-iterations, distributes a fixed number of iterations among a pool of VUs. Each VU will execute as many iterations as it can until the total specified iterations are complete or the test duration ends.

It's good for tests where you want to complete a specific amount of work.

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

Constant Load with `constant-VUs`

The constant-VUs executor maintains a fixed number of virtual users throughout the test's duration. VUs are started at the beginning and kept active until the duration is met.

This is useful for simulating a steady, continuous load on your system.

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

Gradual Load with `ramping-VUs`

The ramping-VUs executor allows you to gradually increase or decrease the number of virtual users over time. This simulates a more realistic load curve, like users slowly joining a website or leaving it.

It uses stages to define these changes in VU count.

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

Structuring Load with Stages

Within ramping-VUs, stages are an array of objects, each with a duration and a target VU count.

  • duration: How long this stage lasts (e.g., '1m', '30s').
  • target: The number of VUs to reach by the end of this stage. k6 will linearly ramp VUs from the current stage's end target to the next stage's target.

Stages are powerful for modeling complex load patterns like peak hours or sudden traffic spikes.

Controlling Request Rate: `ramping-arrival-rate`

Unlike VU-based executors, ramping-arrival-rate is an open model executor. It controls the rate at which new iterations (or 'arrivals') are started, rather than the number of VUs.

This is ideal for testing systems where you care about requests per second (RPS) or transactions per second (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
}

Combining Different User Behaviors

You can define multiple, independent scenarios within a single k6 script. Each scenario can have its own executor, VUs, duration, and even call a different function that defines its specific user journey.

This allows you to simulate a mix of user types (e.g., admin users, regular users, guests) in one comprehensive 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);
}

Fine-Tuning Scenario Execution

Beyond basic executor settings, scenarios offer additional options for precise control:

  • startTime: Delay the start of a specific scenario (e.g., '10s' after test start). Useful for staggered tests.
  • gracefulStop: How long k6 should wait for active VUs to finish their current iteration before forcefully stopping them (e.g., '5s').
  • env: Environment variables specific to this scenario.

These options help orchestrate complex test flows.

Scenario Challenge

You need to simulate a load test where:

  • 5 virtual users (VUs) constantly browse the homepage for 1 minute.
  • At the same time, another group of users gradually ramps up from 0 to 10 VUs over 30 seconds, then holds at 10 VUs for 30 seconds, performing a login action.

Which two k6 executors would be most appropriate for these two distinct user behaviors?

Scenarios: Your Load Orchestrator

In this lesson, you've learned how k6 scenarios enable you to model diverse and realistic load patterns. We explored key executors:

  • shared-iterations for fixed work.
  • constant-VUs for steady load.
  • ramping-VUs for gradual load changes with stages.
  • ramping-arrival-rate for open-model testing based on request rate.

You also saw how to combine multiple scenarios and use options like startTime for advanced control. Mastering scenarios is crucial for sophisticated performance testing!

Часто задаваемые вопросы

Урок «Сценарии виртуальных пользователей (VUs)» бесплатный?

Да — полный текст урока «Сценарии виртуальных пользователей (VUs)» бесплатно доступен здесь в веб-версии. Чтобы практиковать его интерактивно (встроенный редактор кода и ИИ-репетитор 24/7) и разблокировать остальной курс Load Testing & Performance Benchmarking (JMeter & k6), подпишись на CoddyKit PRO. Курс Load Testing & Performance Benchmarking (JMeter & k6) содержит 4 уроков всего.

Чему я научусь в уроке «Сценарии виртуальных пользователей (VUs)»?

Определяйте и управляйте различными сценариями виртуальных пользователей, эффективно имитируя разнообразные профили нагрузки Ты практикуешь Load Testing & Performance Benchmarking (JMeter & k6) с помощью реального кода, который запускаешь прямо в браузере, и ИИ-репетитор 24/7 отвечает на твои вопросы во время урока.

Нужен ли мне опыт, чтобы начать Load Testing & Performance Benchmarking (JMeter & k6)?

Предыдущий опыт не требуется. Load Testing & Performance Benchmarking (JMeter & k6) на CoddyKit структурирован для всех уровней — от новичков до продвинутых, поэтому ты можешь начать отсюда или с самого начала и учиться в своем темпе. Это урок 1 из 4.

Сколько времени занимает урок «Сценарии виртуальных пользователей (VUs)»?

Большинство уроков CoddyKit занимают около 5–10 минут. Каждый из них компактный и интерактивный, поэтому ты постоянно делаешь прогресс и продолжаешь с того же места в веб-версии и приложении.

Можно ли писать и запускать код в этом уроке Load Testing & Performance Benchmarking (JMeter & k6)?

Да. Каждый урок Load Testing & Performance Benchmarking (JMeter & k6) включает встроенный редактор кода, поэтому ты пишешь и запускаешь реальный код прямо в браузере и получаешь моментальную обратную связь от AI — локальная установка не требуется.

Все уроки этого курса

  1. Сценарии виртуальных пользователей (VUs)
  2. Параметризация данных в k6
  3. Выполнение в облаке с k6
  4. Пользовательские метрики и тренды в k6
← Назад к Load Testing & Performance Benchmarking (JMeter & k6)