load-tester Все курсы

✻ Урок 10.1 · Тема 10: k6

Минимум JavaScript и первый скрипт k6

⏱ 3.5 ч

Как работать с кодом и когда идти дальше

Команды не нужно писать по памяти. Пользуйся примерами из урока и справкой. Ориентируйся на цель задания:

  • Запусти готовое. Код приложения и вспомогательных скриптов можно скопировать. Пойми, зачем они нужны, что запускают или меняют и как проверить результат. Разбирать каждую функцию внутри готового инструмента не требуется.
  • Измени по образцу. Разбери новые конструкции, объяснённые в уроке. Измени указанный параметр или часть кода, предскажи результат и проверь запуском.
  • Напиши сам. Собери свой вариант под условия задания. Образцы и справка разрешены: важно объяснить своё решение и проверить его работу.

Можно идти дальше, если ты выполнил практику, получил ожидаемый результат и понимаешь, что проверил. Если задание просит изменить код, проверь и своё изменение.

Непонятные детали готового инструмента можно оставить на потом. При ошибке запуска вернись к разбору вывода и типичным ошибкам в уроке.

Зачем это нужно

Ты на первой работе в команде интернет-магазина. Скоро распродажа, и перед каждым релизом команда хочет знать: сайт стал быстрее или медленнее. Руками это проверять можно, но результат выглядит так:

Открыл каталог в браузере: 0,4 с
Открыл ещё раз: 2,9 с
Открыл в третий раз: 0,6 с

Так «быстрее или медленнее» не понять: числа прыгают, сегодня ты, завтра коллега, а после релиза уже и не вспомнить, с чем сравнивать. Нужен тест, который запускается сам, делает сотни таких «открытий» подряд и сам говорит «прошёл» или «упал». Для этого берут k6 (читается «кей-шесть»). Его итоговый отчёт мы разберём построчно в практике, после первого запуска, там же будет короткая таблица типов метрик.

В теме 9 ты писал нагрузку на Python и Locust. Но k6 встретится тебе в вакансиях, так что второй инструмент стоит знать. Он умеет держать заданную скорость запросов (например, 200 в секунду), а не заданное число «пользователей». Сценарий (файл с шагами теста) для него пишут на JavaScript.

Новичка пугает не k6, а JavaScript: «я же не программист». Но тебе нужен крошечный кусок языка: переменные, функции, объекты, массивы, формат данных JSON и подключение файлов. Ты знаешь Python, поэтому я буду сравнивать. К концу урока ты прочтёшь итоговый отчёт k6: на собеседовании просят объяснить его строки.

Шаг проекта: ты ставишь k6 и пишешь ~/perf-lab/10-k6/shop.js (тот же путь покупателя, что в Locust: вход, каталог, карточка товара, корзина, заказ). Запускаешь его на пять пользователей на 30 секунд и сохраняешь результат в ~/perf-lab/results/. В следующем уроке этот же скрипт получит сценарии и пороги (условия «прошёл или упал»), в последнем его метрики улетят в Grafana.

Что нужно знать

  • Стенд «Магазин» запущен, curl -s localhost:8000/readyz отвечает: урок 2.1 и тема 5. Для 10.3 понадобится профиль мониторинга из темы 7.
  • Что такое HTTP-запрос, статус ответа, заголовки и JSON: урок 2.1.
  • Python на уровне «функции, словари, списки»: тема 4. Мы будем сравнивать с ним.
  • Locust и путь покупателя «логин, каталог, корзина, заказ»: урок 9.2. Здесь ты повторишь тот же путь на другом инструменте.
  • Задержка, перцентили p50/p95/p99, доля ошибок: урок 8.1. Без них итоговый отчёт k6 не прочитать.

Картина целиком

Твой файл на JavaScript это сценарий. k6 читает его и запускает виртуальных пользователей (VU, virtual users). Виртуальный пользователь не человек и не браузер, а маленькая программа, которая проходит сценарий по кругу без отдыха, пока ты не вставил паузу.

flowchart TD
    A["shop.js<br>сценарий на JavaScript"] --> B["k6<br>движок на Go"]
    B --> C["VU 1"]
    B --> D["VU 2"]
    B --> E["VU N"]
    C --> F["Магазин<br>localhost:8000"]
    D --> F
    E --> F
    B --> G["Итог в конце теста:<br>метрики и пороги"]

Здесь видно: один процесс k6 читает файл и запускает столько VU, сколько ты разрешил. Каждый VU сам ходит в магазин, а замеры стекаются обратно в отчёт.

Сам k6 написан на языке Go (на нём пишут быстрые серверные программы), поэтому он экономный: один процесс тянет тысячи VU на ноутбуке. Твой JavaScript k6 запускает сам, не в браузере: окна и страницы тут нет, чужие пакеты подключить нельзя. Зато есть свои встроенные модули (наборы готовых функций), например k6/http.

У сценария четыре стадии жизни, две из них необязательные:

flowchart TD
    A["1. init<br>читается файл,<br>один раз на VU"] --> B["2. setup()<br>один раз на весь тест<br>(необязательно)"]
    B --> C["3. default()<br>тело сценария,<br>VU повторяет в цикле"]
    C --> D["4. teardown()<br>один раз в конце<br>(необязательно)"]
    D --> E["Итоговый отчёт"]
    C -->|"следующая итерация"| C

Основная работа идёт на третьей стадии: функция default выполняется снова и снова, пока не кончится время теста. Всё остальное вокруг неё: подготовиться до, прибраться после. Пример с setup() будет в разделе про запуск сценария, а пока запомни порядок.

Теория

Переменные и типы: const, let и подвох с плюсом

Загадка для начала: что напечатает JavaScript для '5' + 1 и для '5' - 1? Если ты из Python, ответ удивит: 51 и 4. Разберёмся, почему.

Сценарию нужно хранить токен, адрес магазина, номер пользователя. Для этого есть переменные: имя, за которым лежит значение. В JavaScript они двух видов. const (от constant, «постоянная»): значение кладут при создании, и переназначить его нельзя. let («пусть будет»): значение можно заменить. Мой совет: пиши const, а let только там, где значение придётся менять (счётчик, токен после входа).

const base = 'http://localhost:8000';   // адрес магазина, не меняется
let counter = 0;                         // счётчик, будем увеличивать
counter = counter + 1;                   // теперь counter равен 1
counter++;                               // сокращение: counter стал 2

Комментарий начинается с // (в Python это #). Типы значений почти те же, что в Python:

В JavaScript Пример Аналог в Python
строка (string) 'привет', "привет" str
число (number), одно на целые и дробные 42, 0.5 int и float
логическое (boolean) true, false True, False
«ничего» намеренно null None
«значение не задано» undefined ближайшее: ошибка «нет такой переменной»
объект (object) { a: 1 } dict
массив (array) [1, 2, 3] list

Теперь про загадку. JavaScript молча преобразует типы. Плюс, если рядом строка, склеивает: '5' + 1 даёт строку '51'. Минус склеивать не умеет, поэтому превращает '5' в число и вычитает: получается 4. Вот почему для сравнения я всегда ставлю три знака равенства ===: он требует, чтобы совпали и значение, и тип. Двойное == приведёт типы само, и 5 == '5' окажется true.

Прикинь сам: что напечатает console.log('10' + 5, '10' - 5)?

105 5. Плюс склеил строку '10' с числом 5 и получил строку '105'. Минус превратил '10' в число 10 и вычел 5. console.log с несколькими аргументами печатает их через пробел.

Осторожно: переменные окружения (__ENV, они появятся в сценарии ниже) всегда строки. __ENV.RATE равно '20', а не 20, поэтому пиши Number(__ENV.RATE). И поле, которого в объекте нет, даёт undefined, а не ошибку: токена нет, а скрипт пошёл дальше с пустым заголовком.

Главное: JavaScript сам склеивает и преобразует типы, поэтому пиши const, сравнивай через ===, а числа из текста превращай в числа через Number.

Типы мы разобрали. Теперь научимся давать кускам кода имена и работать со сложными данными.

Функции, объекты, массивы

Ответ магазина приходит набором полей, а сценарий состоит из шагов вроде «войти» и «положить в корзину». Для шагов есть функции («возьми это, сделай так, верни результат»), для данных объекты (набор полей вроде «название», «цена», «остаток») и массивы (нумерованный список).

Функцию пишут двумя способами, оба тебе встретятся:

function pad(n, width) {                  // обычная функция
  return String(n).padStart(width, '0');
}
const email = (n) => `user${pad(n, 4)}@shop.lab`;   // стрелочная: параметры => результат

String(n) превращает число в строку, а .padStart(4, '0') дополняет её слева нулями до длины 4: из 7 получится '0007'. Стрелочная запись (n) => ... короче, и её удобно передавать другой функции: в check() ты будешь писать (r) => r.status === 200, то есть «по ответу r верни: статус равен 200?».

В Python ты написал бы f"user{n:04d}@shop.lab". В JavaScript формата :04d нет, поэтому два шага: число в строку, потом нули слева. Для n = 7 выйдет user0007@shop.lab, для n = 1000 дополнять нечего, и выйдет user1000@shop.lab. Так номер VU превращается в пользователя стенда (user0001@shop.lab…user1000@shop.lab). Строка в обратных кавычках с ${...} внутри называется шаблонной, это аналог f-строки. Обратные кавычки это клавиша слева от единицы.

Объект записывают в фигурных скобках как ключ: значение, к полю обращаются через точку. Массив это список в квадратных скобках, нумерация с нуля:

const user = { email: 'user0001@shop.lab', password: 'password' };
console.log(user.email);          // user0001@shop.lab
user.password = 'qwerty';         // поле можно поменять, хотя user объявлен через const
console.log(user.name);           // undefined: такого поля нет, ошибки не будет

const ids = [1, 2, 3];
console.log(ids[0], ids.length);   // 1 3
ids.push(4);                       // добавить в конец
for (const id of ids) {            // пройти по каждому элементу (в Python: for id in ids)
  console.log(id * 2);
}

Условие пишут как if (условие) { ... } else { ... }, скобки вокруг условия обязательны. «И» это &&, «или» это ||, «не» это !. Выражение a || b вернёт a, если оно не пустое, иначе b: так делают значения по умолчанию. В __ENV.BASE_URL || 'http://localhost:8000' читай «возьми адрес из окружения, а если его нет, локальный».

Сводка: что в JavaScript называется иначе, чем в Python
Python JavaScript
x = 5 let x = 5; или const x = 5;
f"{a} и {b}" `${a} и ${b}`
def f(a): return a * 2 function f(a) { return a * 2; } или (a) => a * 2
d = {"a": 1}; d["a"] const d = { a: 1 }; d.a или d['a']
xs.append(3), len(xs) xs.push(3), xs.length
for x in xs: for (const x of xs) { }
if a and not b: if (a && !b) { }
None, True null (и undefined), true
a == b a === b
блоки по отступам блоки в { }, строки кончаются ;

Прикинь сам: функция const f = (x) => x + 1;. Что вернёт f('1')?

Строку '11': плюс снова склеил. Нужно число? Пиши Number(x) + 1 и получишь 2.

Осторожно: user.email и user['email'] одно и то же, скобки нужны, когда имя поля лежит в переменной. А в обычной функции без return результат молча станет undefined.

Главное: функция даёт имя шагу, объект хранит поля, массив хранит список; обращение к полю идёт через точку, к элементу по номеру с нуля.

Данные мы хранить умеем. Но магазин присылает их не объектами, а текстом, и его надо превратить в объект.

JSON: на каком языке говорят скрипт и магазин

Магазин принимает и отдаёт данные текстом. Ему на вход нужно {"email":"user0001@shop.lab","password":"password"}, а в ответ он присылает {"token":"...","expires_in":3600}. Это JSON (JavaScript Object Notation, «запись объектов JavaScript»): текст, внешне почти совпадающий с объектом. Ты видел его в теме 2. Два действия, обратные друг другу: JSON.stringify(объект) делает строку JSON, она нужна перед отправкой (тело запроса в k6 это строка). JSON.parse(строка) делает из строки объект, чтобы вытащить поле из ответа. У ответа k6 для этого есть короткая запись res.json().

const text = '{"token":"abc123","expires_in":3600}';
const data = JSON.parse(text);          // теперь data.token равно 'abc123'
console.log(data.expires_in + 1);       // 3601: число осталось числом
console.log(JSON.stringify({ product_id: 5, qty: 1 }));   // {"product_id":5,"qty":1}

В ответе входа токен это длинная случайная строка, а expires_in сколько секунд он живёт (по умолчанию SESSION_TTL равно 3600, час). Строка const token = res.json('token'); положит в token только токен. Параметр 'token' это путь к полю, он заходит и в глубину: 'items.0.id'. Если поля нет, получишь undefined: проверяй результат.

Прикинь сам: сервер вернул {"items":[{"id":5},{"id":9}],"total":2}. Как достать id второго товара из data = JSON.parse(text)?

data.items[1].id: items это массив, нумерация с нуля, поэтому второй элемент имеет индекс 1. Результат 9. Через путь это res.json('items.1.id').

Осторожно: в JSON ключи всегда в двойных кавычках. Напишешь тело руками как "{'email': 'a'}", и магазин ответит ошибкой разбора (422), поэтому собирай тело через JSON.stringify.

Главное: JSON.stringify делает из объекта текст для отправки, JSON.parse и res.json() делают из текста ответа объект; тело руками не печатай.

Скрипт научился говорить с магазином на одном языке. Теперь посмотрим, как k6 его запускает.

Как k6 запускает сценарий: init, default, VU и итерации

Ты запустил пять VU, а магазин получил совсем не пять запросов в секунду. Почему?

Представь кассира. Утром он один раз надевает форму и открывает кассу, потом по кругу обслуживает покупателей. Кассир это VU: независимый исполнитель сценария со своей копией кода и своими переменными (его номер лежит в __VU, с единицы). Покупатель это итерация: один проход функции по умолчанию от начала до конца (вход, каталог, корзина, заказ, пауза). Утренняя подготовка это init-код: всё, что написано в файле вне функций, то есть импорты, const и export const options. Он выполняется один раз на каждый VU до начала теста. Аналогия ломается там, что виртуальный кассир не устаёт: без паузы он сразу берёт следующего покупателя.

Функция, которую k6 вызывает на каждой итерации, называется default: export default function () { ... }. Рядом можно описать необязательные export function setup() (один раз до теста) и export function teardown() (один раз после). Настройки теста (сколько VU, как долго, какие пороги) лежат в export const options = { ... }. Каждый VU делает запросы по одному: пока нет ответа, он ждёт.

Переменная вне функций принадлежит конкретному VU и сохраняется между его итерациями. Поэтому токен после входа можно сохранить там и больше не логиниться. Вход в «Магазине» самая дорогая операция: пароль на сервере хранят не как есть, а «перемолотым» специальной медленной функцией (bcrypt). Так злоумышленнику дольше подбирать пароль, но и серверу каждый вход стоит около 0,25 с процессора, а стенд по умолчанию работает одним рабочим процессом на весь магазин. Логинься на каждой итерации, и ты нагрузишь не каталог и заказы, а проверку паролей.

У каждого VU своя дорожка: синее это идущий запрос, серое это пауза. Одна итерация это пара «синее плюс серое».

Пауза нужна ради реализма. Живой человек между кликами думает (think time, «время на раздумье»). Функция sleep(секунды) из модуля k6 останавливает только текущий VU. Без неё VU мгновенно шлёт следующий запрос, и нагрузка в десятки раз выше, чем создали бы люди. Пауза бывает и случайной, sleep(1 + Math.random()) (от 1 до 2 секунд), но для первого скрипта хватит sleep(1).

Посчитаем для трёх VU, запроса в 300 мс и sleep(1). Одна итерация длится 0,3 + 1 = 1,3 секунды. За 30 секунд один VU успеет 30 / 1,3 ≈ 23 итерации, три VU около 69. Магазин получит 3 / 1,3 ≈ 2,3 запроса в секунду, а не «3 пользователя, 3 запроса»: большую часть времени VU думает. Убери sleep, и те же три VU дадут 3 / 0,3 = 10 запросов в секунду. Это связь из урока 8.2 (закон Литтла) в деле.

Прикинь сам: запрос длится 100 мс, пауза 0, VU 5. Сколько запросов в секунду получит сервер, если он отвечает ровно за 100 мс при любой нагрузке?

Одна итерация 0,1 с, у одного VU 10 итераций в секунду, у пяти 50 запросов в секунду. На практике чуть меньше: k6 тратит доли миллисекунды на каждую итерацию.

Если нужно один раз подготовить данные для всех VU, их возвращают из setup(), и k6 передаёт результат в default первым аргументом:

export function setup() {
  const res = http.post(`${BASE}/api/login`, JSON.stringify({ email: userEmail(1), password: 'password' }),
    { headers: JSON_HEADERS });
  if (res.status !== 200) throw new Error(`setup: вход вернул ${res.status}`);   // тест не начнётся
  return { token: res.json('token') };
}

export default function (data) {
  http.get(`${BASE}/api/products`, { headers: { Authorization: `Bearer ${data.token}` } });
}

Если setup() бросит исключение, тест не стартует, и это лучше, чем гонять 5 VU с пустым токеном. teardown(data) получает те же данные после теста. В нашем shop.js каждый VU входит сам под своим пользователем, поэтому setup там не нужен.

Осторожно: итерация не запрос, их в ней может быть пять (вход делается один раз на VU, так что обычная итерация это четыре запроса). И init не default: console.log('привет') вне функции напечатается по разу на каждый VU, а не на каждую итерацию.

Главное: запросов в секунду столько, сколько VU делённое на время итерации, а переменные вне функций живут у VU между итерациями.

Мы знаем, кто гоняет сценарий. Теперь посмотрим на сам запрос.

HTTP-запросы и ответ

Весь сценарий это набор запросов к API. Модуль k6/http их делает и сам замеряет время. Основные функции: http.get(url, params) и http.post(url, body, params), дальше по аналогии http.put и http.del. Последний аргумент params это настройки: headers (заголовки), tags (метки для метрик), timeout (сколько ждать, по умолчанию 60 секунд).

const res = http.post(`${base}/api/login`,
  JSON.stringify({ email: 'user0001@shop.lab', password: 'password' }),
  { headers: { 'Content-Type': 'application/json' } });

Заголовок Content-Type: application/json говорит серверу, что в теле JSON. Для строкового тела k6 его сам не ставит, поэтому пиши руками.

Функция возвращает объект ответа. Вот поля, которыми ты будешь пользоваться чаще всего:

Поле Что в нём
res.status код ответа (200, 201, 404…); 0, если ответа не было вообще (сервер недоступен)
res.body тело ответа строкой
res.json() тело, разобранное как JSON; res.json('token') вернёт одно поле по пути
res.headers заголовки ответа
res.timings.duration сколько мс длился запрос (то же значение уходит в http_req_duration)
res.error текст сетевой ошибки, если она была (например, соединение отклонено)

Теперь главная особенность k6: он не бросает исключение при ответе 404 или 500. Для него это обычный ответ, он честно запишет задержку и статус. Если сервера нет совсем, k6 тоже не падает: res.status равен 0, причина в res.error, а в консоли будет предупреждение WARN Request Failed. Хорош ли ответ, решает твоя проверка.

Полный путь покупателя в «Магазине» состоит из пяти запросов (но вход делается один раз на VU, а дальше идут четыре): POST /api/login (получить токен), GET /api/products (каталог), GET /api/products/{id} (карточка), POST /api/cart/items с телом {"product_id": N, "qty": 1} (корзина) и POST /api/orders (заказ). Последние два требуют заголовок Authorization: Bearer <токен>: он доказывает серверу, что ты это ты. Вход возвращает 200, корзина и заказ возвращают 201.

Прикинь сам: в консоли res.status равен 0. Что это значит?

Ответа не было: сервер недоступен, соединение отклонено или запрос не уложился в таймаут. Причину ищи в res.error. Настоящих HTTP-ответов с кодом 0 не бывает.

Главное: k6 не считает плохой ответ ошибкой скрипта: он записывает код и время, а оценивать ответ должен ты.

Как именно оценивать? Для этого есть функция check.

check(): проверка, которая не останавливает тест

Представь: тест зелёный, ошибок 0%, задержки в норме, релиз выложен, а через час поддержка пишет: заказы не оформляются. Магазин отвечал кодом 200, но в теле лежала ошибка, а тест смотрел только на код. Поэтому в каждом сценарии нужна проверка содержимого, а не только статуса.

Функция check(значение, { 'название': функция }) вызывает каждую функцию с ответом и записывает результат в метрику checks (доля успешных). Она возвращает true, только если все проверки прошли.

const ok = check(res, {
  'вход: 200': (r) => r.status === 200,
  'токен получен': (r) => typeof r.json('token') === 'string',
});
if (!ok) { sleep(1); return; }   // неудачный вход: дальше нет смысла, но паузу держим

Паузу перед return не забывай: без неё VU при каждом отказе мгновенно начинает новую итерацию (подробнее в «Типичных ошибках» практики).

Ещё одна ловушка: res.json() бросит исключение, если пришёл не JSON, например HTML-страница от прокси с ошибкой 502 (под нагрузкой так бывает). Исключение внутри check оборвёт итерацию, поэтому статус проверяй до разбора тела:

const ok = check(res, { 'вход: 200': (r) => r.status === 200 });
const token = ok ? res.json('token') : undefined;   // json() вызываем, только если статус 200

Название проверки появится в отчёте, поэтому пиши его так, чтобы по красной строке было понятно, что сломалось: 'вход: 200', а не 'check1'.

Главное, что нужно усвоить: check не останавливает тест и не решает, «прошёл» он или «упал». Упавшая проверка просто уменьшает долю в метрике checks и ставит красный крестик. Чтобы тест упал (особенно в CI, то есть в автоматической проверке перед релизом), нужен порог (threshold): условие на метрику, о нём урок 10.2. Получается пара: check фиксирует факты, порог выносит приговор.

А что k6 считает «ошибкой запроса» для метрики http_req_failed? По умолчанию любой ответ вне диапазона 200–399 и все сетевые ошибки. Значит, 401, 404 и 500 попадут в http_req_failed, а 301 и 302 нет. Список «хороших» кодов можно поменять функцией http.setResponseCallback, но в нашем сценарии менять ничего не нужно.

Осторожно: check не прерывает итерацию, остановиться должен ты сам строкой if (!ok) { sleep(1); return; } (паузу оставляем, зачем, объяснено ниже в «Типичных ошибках» практики). И он не то же самое, что http_req_failed: проверка может упасть при коде 200 (в теле не то), а запрос при этом не «failed». Смотри обе метрики.

Главное: check записывает факты и не останавливает тест; решает «прошёл или упал» порог, а код 200 без проверки тела ничего не доказывает.

Проверки отвечают на вопрос «правильно ли». А как не получить тысячи одинаковых строк в метриках?

Метки name: чтобы 10 000 товаров не стали 10 000 строк

У каждого запроса есть метка (tag) url. Адреса /api/products/17 и /api/products/4213 для k6 разные, значит, на каждый товар будет своя строка. В отчёте это не видно, зато в мониторинге из урока 10.3 тысячи значений метки перегрузят Prometheus. Это высокая кардинальность (число уникальных комбинаций меток): на каждую тратится память. Решение: задать запросу метку name с одним общим значением.

http.get(`${base}/api/products/${id}`, { tags: { name: '/api/products/[id]' } });

Так все карточки соберутся под одним именем. Locust решал ту же задачу параметром name, ты делал это в теме 9.

Главное: запрос с меняющимся адресом помечай меткой name с одним общим значением, иначе метрики разрастутся.

Запросы мы отправили и проверили. Остался последний кусочек языка: как разнести код по файлам.

Модули: как разнести сценарий по файлам

Сценарий растёт, и функцию «собрать email» не хочется копировать по пяти файлам. Код делят на модули: файлы, из которых можно вынести нужное и подключить в другом месте. Модуль отдаёт наружу словом export, другой файл забирает словом import:

// lib/util.js
export function userEmail(n) {
  return `user${String(n).padStart(4, '0')}@shop.lab`;
}
// shop.js
import { userEmail } from './lib/util.js';   // путь начинается с ./ : файл рядом с этим
import http from 'k6/http';                  // встроенный модуль k6: адрес без ./
import { check, sleep } from 'k6';           // из встроенного модуля берём две функции

Фигурные скобки в import значат «взять вот эти имена». Без скобок берут то, что модуль объявил главным (export default): у k6/http это объект http. Пути к своим файлам пишутся с ./ и обязательно с расширением .js: k6 не угадывает его. Осторожно: готовые пакеты из npm (общий каталог JavaScript-библиотек) подключить нельзя, только встроенные модули k6, свои файлы и файлы по ссылке https://. require() в k6 урезанный, require('fs') не работает, поэтому пиши import.

Главное: общий код живёт в своих файлах, export его отдаёт, import забирает; путь к своему файлу пишется с ./ и с .js.

Что k6 напечатает в конце, мы разберём построчно в практике.

Вернёмся в магазин: перед распродажей у тебя есть инструмент, который сам скажет «прошёл» или «упал». Первый запуск ты сделаешь в практике.

Практика

Все файлы лежат в ~/perf-lab/10-k6/. Стенд «Магазин» должен быть запущен: curl -s localhost:8000/readyz отвечает {"status":"ready"}.

1. Поставь k6

Команды по мотивам официальной инструкции k6 для Ubuntu:

sudo apt-get update && sudo apt-get install -y ca-certificates curl gpg
curl -fsSL https://dl.k6.io/key.gpg | sudo gpg --dearmor -o /usr/share/keyrings/k6-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/k6-archive-keyring.gpg] https://dl.k6.io/deb stable main" | sudo tee /etc/apt/sources.list.d/k6.list
sudo apt-get update
sudo apt-get install -y k6
k6 version

Первые три строки подключают репозиторий k6 и его ключ подписи, четвёртая и пятая ставят пакет, последняя печатает версию.

Разбор флагов

Первая строка ставит утилиты для скачивания и проверки подписей (curl и gpg могли уже стоять, повторная установка безвредна). Вторая скачивает ключ, которым Grafana подписывает пакеты: -fsSL значит «упасть при ошибке, молчать, показать ошибку, идти по перенаправлениям», gpg --dearmor переводит ключ в бинарный вид. Третья добавляет адрес репозитория в список источников apt: signed-by доверяет только этому ключу, а tee нужен, чтобы записать файл под sudo (обычное > прав не получит).

Ожидаемый вывод последней команды:

k6 v2.3.0 (commit/3f9a2b1c4d, go1.26.0, linux/amd64)

Как читать вывод: первое число версии 2 важно. Много статей в интернете написано про k6 версий 0.x и 1.x. Остальное из статей (k6/http, check, sleep, options) работает так же.

Что убрали в версии 2.x

По заметкам к выпуску k6 2.0 убрали команды k6 pause, k6 resume, k6 scale, k6 status и один из исполнителей нагрузки (externally-controlled), а флаг --no-summary заменён на --summary-mode=disabled. Увидишь такое в старой инструкции, значит, она устарела.

Типичные ошибки:

  • E: Unable to locate package k6: репозиторий не добавлен или не выполнен apt-get update после добавления. Повтори третью и четвёртую команды.
  • NO_PUBKEY при apt-get update: ключ не скачался или записан не туда. Повтори вторую команду и убедись, что файл /usr/share/keyrings/k6-archive-keyring.gpg существует.

2. Освой JavaScript на самом k6

Отдельного JavaScript (Node.js) ты не ставил, и не надо: учебные куски запустим прямо в k6. Создай каталог и файл:

mkdir -p ~/perf-lab/10-k6/lib ~/perf-lab/results && cd ~/perf-lab/10-k6
nano js-basics.js
// js-basics.js: учебный файл, запускаем его самим k6
const base = 'http://localhost:8000';
let counter = 0;
const user = { email: 'user0001@shop.lab', password: 'password' };
const ids = [1, 2, 3];

function pad(n, width) { return String(n).padStart(width, '0'); }
const email = (n) => `user${pad(n, 4)}@shop.lab`;

export default function () {
  counter++;
  console.log(`итерация ${counter}, VU ${__VU}`);
  console.log(email(7), email(1000));
  console.log(JSON.stringify(user));
  const data = JSON.parse('{"token":"abc","expires_in":3600}');
  console.log(data.token, data.expires_in + 1);
  for (const id of ids) console.log(`${base}/api/products/${id}`);
  console.log(typeof user, Array.isArray(ids), ids.length, user.name);
  console.log(0.1 + 0.2, '5' + 1, '5' - 1, 5 === '5', 5 == '5');
}

Запуск: k6 run --iterations 2 --summary-mode=disabled js-basics.js. Разбор: k6 run файл запускает сценарий; --iterations 2 говорит «две итерации, потом стоп» (VU по умолчанию один); --summary-mode=disabled выключает итоговый отчёт, он нам сейчас не нужен.

INFO[0000] итерация 1, VU 1                              source=console
INFO[0000] user0007@shop.lab user1000@shop.lab           source=console
INFO[0000] {"email":"user0001@shop.lab","password":"password"}  source=console
INFO[0000] abc 3601                                      source=console
INFO[0000] http://localhost:8000/api/products/1          source=console
INFO[0000] http://localhost:8000/api/products/2          source=console
INFO[0000] http://localhost:8000/api/products/3          source=console
INFO[0000] object true 3 undefined                       source=console
INFO[0000] 0.30000000000000004 51 4 false true           source=console
INFO[0000] итерация 2, VU 1                              source=console
...

Строка 0.30000000000000004 не ошибка: дробные числа в компьютере хранятся неточно, так бывает в любом языке (в Python 0.1 + 0.2 даёт то же самое). Вывод второй итерации повторяет первую, кроме строки про счётчик. Ещё typeof user печатает object, Array.isArray(ids) отвечает true, а user.name даёт undefined: такого поля нет. Как читать вывод: INFO это уровень сообщения, [0000] секунды от старта теста, source=console значит «напечатано твоим console.log». Строка «итерация 2» показывает главное: counter из init не сбросился между итерациями, потому что принадлежит VU. Попробуй --vus 2 --iterations 4: у каждого VU будет свой счётчик.

Типичные ошибки:

  • SyntaxError: ... Unexpected token: чаще всего пропущена скобка или запятая. k6 называет строку и столбец.
  • ReferenceError: ... is not defined: имя написано с опечаткой или переменной нет в этой области.

3. Первый запрос

// hello.js
import http from 'k6/http';
import { check } from 'k6';

export default function () {
  const res = http.get('http://localhost:8000/healthz');
  check(res, { 'healthz: 200': (r) => r.status === 200 });
}

Запусти: k6 run hello.js. Без опций k6 делает одну итерацию одним VU: удобно для проверки, что скрипт вообще работает.

         execution: local
            script: hello.js
            output: -

         scenarios: (100.00%) 1 scenario, 1 max VUs, 10m30s max duration (incl. graceful stop):
                  * default: 1 iterations for each of 1 VUs (maxDuration: 10m0s, gracefulStop: 30s)


  █ TOTAL RESULTS

    checks_total.......................: 1       151.2/s
    checks_succeeded...................: 100.00% 1 out of 1
    checks_failed......................: 0.00%   0 out of 1

    ✓ healthz: 200

    HTTP
    http_req_duration.......................................................: avg=4.62ms min=4.62ms med=4.62ms max=4.62ms p(90)=4.62ms p(95)=4.62ms
      { expected_response:true }............................................: avg=4.62ms min=4.62ms med=4.62ms max=4.62ms p(90)=4.62ms p(95)=4.62ms
    http_req_failed.........................................................: 0.00%  0 out of 1
    http_reqs...............................................................: 1      151.2/s

    EXECUTION
    iteration_duration......................................................: avg=6.18ms min=6.18ms med=6.18ms max=6.18ms p(90)=6.18ms p(95)=6.18ms
    iterations..............................................................: 1      151.2/s

    NETWORK
    data_received...........................................................: 142 B  21 kB/s
    data_sent...............................................................: 80 B   12 kB/s

У тебя числа будут другие, формат тот же (строки vus и vus_max для одного VU я убрал, чтобы не загромождать). Как читать вывод: блок scenarios сверху пересказывает, что k6 собирался сделать: «1 итерация на 1 VU». Одна проверка прошла (✓), один запрос (http_reqs 1), на запрос ушло 4,62 мс, а итерация длилась 6,18 мс (разница это накладные расходы k6). Скорость в секунду (151/s) на одной итерации ничего не значит: это «1 запрос / 6,6 мс», не нагрузка.

Типичные ошибки:

  • WARN ... Request Failed ... dial tcp 127.0.0.1:8000: connect: connection refused: стенд не запущен. Подними его (cd ~/learning/load-tester/project/shop && cp -n .env.example .env && docker compose up -d --wait) и проверь readyz.
  • GoError: ... open ... no such file: неверный путь к файлу сценария, запускай из каталога ~/perf-lab/10-k6.

4. Сценарий покупателя

Вынеси помощник в модуль lib/util.js:

// lib/util.js
export function userEmail(n) {
  return `user${String(n).padStart(4, '0')}@shop.lab`;
}

Запусти готовый пример. Создай shop.js из кода ниже. Это первый полный сценарий покупателя в k6: его можно скопировать, затем разобрать по пояснениям после блока. Нужно понимать, что выполняется до теста, что повторяет каждый пользователь, как передаётся авторизация и что проверяет check. Писать весь файл по памяти не нужно.

// shop.js: путь покупателя «Магазина»: вход, каталог, карточка, корзина, заказ
import http from 'k6/http';
import { check, sleep } from 'k6';
import { userEmail } from './lib/util.js';

const BASE = (__ENV.BASE_URL || 'http://localhost:8000').replace(/\/$/, '');
const JSON_HEADERS = { 'Content-Type': 'application/json' };

export const options = {
  vus: 5,
  duration: '30s',
  thresholds: { http_req_failed: ['rate<0.01'] },
};

// Эти переменные свои у каждого VU и живут между итерациями.
let token;
let tokenExpiresAt = 0;

function login() {
  const number = ((__VU - 1) % 1000) + 1;            // VU 1 это user0001, VU 1001 снова user0001
  const res = http.post(`${BASE}/api/login`,
    JSON.stringify({ email: userEmail(number), password: 'password' }),
    { headers: JSON_HEADERS });
  if (!check(res, { 'вход: 200': (r) => r.status === 200 })) return false;
  token = res.json('token');
  tokenExpiresAt = Date.now() + (res.json('expires_in') - 5) * 1000;   // с запасом в 5 секунд
  return true;
}

export default function () {
  if (!token || Date.now() >= tokenExpiresAt) {
    if (!login()) { sleep(1); return; }   // без паузы отказ превращается в молоток
  }
  const auth = { headers: { ...JSON_HEADERS, Authorization: `Bearer ${token}` } };

  check(http.get(`${BASE}/api/products`), { 'каталог: 200': (r) => r.status === 200 });

  const productId = 1 + Math.floor(Math.random() * 10000);
  check(http.get(`${BASE}/api/products/${productId}`, { tags: { name: '/api/products/[id]' } }),
    { 'карточка: 200': (r) => r.status === 200 });

  check(http.post(`${BASE}/api/cart/items`, JSON.stringify({ product_id: productId, qty: 1 }), auth),
    { 'корзина: 201': (r) => r.status === 201 });

  check(http.post(`${BASE}/api/orders`, null, auth), { 'заказ: 201': (r) => r.status === 201 });

  sleep(1);
}

Разбор незнакомых мест. (__ENV.BASE_URL || '...') значение из переменной окружения или локальный адрес; .replace(/\/$/, '') убирает слэш в конце, если он есть. { ...JSON_HEADERS, Authorization: ... } копирует поля объекта и добавляет ещё одно (три точки называют «spread», разворот). Date.now() текущее время в миллисекундах, поэтому expires_in (секунды) умножается на 1000. Math.floor(Math.random() * 10000) случайное целое от 0 до 9999, плюс 1 даёт id товара от 1 до 10 000. http.post(url, null, auth) запрос без тела. В if (!login()) { sleep(1); return; } неудачный вход завершает итерацию (VU начнёт следующую), но сначала спит секунду. Без этой паузы VU сразу вернулся бы в начало и, пока магазин отвечает отказом за миллисекунды, молотил бы его тысячами итераций в секунду.

Сначала запусти «на пробу» (один VU, одна итерация), чтобы убедиться, что сценарий вообще работает: k6 run --vus 1 --iterations 1 shop.js. Все пять проверок должны быть зелёными. Если красная, смотри, какая: по названию видно шаг. Включи показ запросов и ответов --http-debug=full (он печатает каждый запрос и ответ целиком, поэтому с ним запускай только один раз и на одной итерации).

Теперь основной запуск, с сохранением отчёта в файл (tee пишет в файл и одновременно на экран):

k6 run shop.js | tee ~/perf-lab/results/k6-first.txt
         execution: local
            script: shop.js
            output: -

         scenarios: (100.00%) 1 scenario, 5 max VUs, 1m0s max duration (incl. graceful stop):
                  * default: 5 looping VUs for 30s (gracefulStop: 30s)


  █ THRESHOLDS

    http_req_failed
    ✓ 'rate<0.01' rate=0.00%


  █ TOTAL RESULTS

    checks_total.......................: 521     17.31/s
    checks_succeeded...................: 100.00% 521 out of 521
    checks_failed......................: 0.00%   0 out of 521

    ✓ вход: 200
    ✓ каталог: 200
    ✓ карточка: 200
    ✓ корзина: 201
    ✓ заказ: 201

    HTTP
    http_req_duration..................: avg=29.7ms  min=4.9ms  med=14.2ms  max=291ms   p(90)=76.3ms  p(95)=82.4ms
      { expected_response:true }.......: avg=29.7ms  min=4.9ms  med=14.2ms  max=291ms   p(90)=76.3ms  p(95)=82.4ms
    http_req_failed....................: 0.00%  0 out of 521
    http_reqs..........................: 521    17.31/s

    EXECUTION
    iteration_duration.................: avg=1.16s   min=1.08s  med=1.15s   max=1.41s   p(90)=1.2s    p(95)=1.24s
    iterations.........................: 129    4.29/s
    vus................................: 5      min=5      max=5
    vus_max............................: 5      min=5      max=5

    NETWORK
    data_received......................: 731 kB 24 kB/s
    data_sent..........................: 161 kB 5.3 kB/s

Цифры условные, у тебя будут другие: на стенде задержки зависят от машины. Как читать вывод. Идём сверху вниз.

  1. scenarios: «5 looping VUs for 30s»: пять пользователей по кругу в течение 30 секунд. Максимальная длительность 1m0s включает 30 секунд на мягкое завершение (gracefulStop): k6 дожидается итераций, начатых к концу времени.
  2. THRESHOLDS: порог rate<0.01 на http_req_failed выполнен: ошибок 0,00% (меньше 1%).
  3. checks: 521 проверка, все успешны. 129 итераций × 4 проверки (каталог, карточка, корзина, заказ) = 516, плюс 5 проверок входа, по одной на каждый из пяти VU, итого 521.
  4. http_req_duration: среднее 29,7 мс, медиана 14,2 мс, p(95) = 82,4 мс. Разрыв между медианой и средним означает «хвост»: это заказы (~75 мс: заказ обращается к сервису оплаты, заглушке с задержкой около 50 мс) и пять входов (до 291 мс).
  5. iterations: 129 за 30 с, 4,29 в секунду. Проверим формулой из теории: пять VU и итерация примерно 1,16 с дают 5 / 1,16 ≈ 4,3. Совпало, значит, сценарий ведёт себя как задумано.
  6. http_reqs: 521 запрос, 17,31 в секунду. 4 запроса на итерацию умножить на 4,29 = 17,2, плюс пять входов.
  7. vus: все пять VU работали весь тест. iteration_duration чуть больше 1 секунды, потому что включает sleep(1).

У метрик k6 четыре типа, и от типа зависит, как их показывают в отчёте:

Тип Что хранит Пример из отчёта
Counter (счётчик) сумма, которая только растёт http_reqs, iterations, data_sent
Gauge (датчик) последнее значение, оно идёт вверх и вниз vus
Rate (доля) доля случаев «да»: сколько из всех замеров были «да» http_req_failed (1 запрос упал, 0 нет), checks
Trend (распределение) все замеры, из них считают avg, med, p(95) http_req_duration, iteration_duration

Закоммить результат, как в предыдущих темах:

cd ~/perf-lab && git add 10-k6 results/k6-first.txt && git commit -m "k6: первый сценарий покупателя" && git push

Типичные ошибки:

  • could not initialize ... The moduleSpecifier "./lib/util" couldn't be found on local disk: забыто расширение .js в импорте или неверный путь. ReferenceError: userEmail is not defined: имя не импортировано.
  • GoError: the body is null so we can't transform it to JSON: магазин недоступен, ответа нет, а res.json() вызван на пустом теле. Если магазин ответил ошибкой (например 401), res.json('token') не падает, а возвращает undefined, и токен молча превращается в Bearer undefined: все следующие запросы вернут 401. Поэтому у входа стоит проверка и ранний return.
  • Тысячи итераций в секунду, в выводе can't assign requested address, красный вход: 200: в сценарии return после неудачного входа стоит без sleep. Отказ приходит за миллисекунды, VU сразу начинает новую итерацию, и тест молотит по самому себе, а не нагружает магазин. Верни sleep(1) перед return.
  • Все проверки красные ✗ вход: 200, http_req_failed близко к 100%: магазин не запущен или логин 401. Выполни вручную curl -s localhost:8000/api/login -H 'Content-Type: application/json' -d '{"email":"user0001@shop.lab","password":"password"}'.

Застрял на ошибке k6 или JavaScript, которой нет в «Типичных ошибках»? Скопируй весь вывод вместе с номером строки скрипта и спроси нейросеть, что значит каждая строка. Ответ проверь: запусти исправленный скрипт с --vus 1 --iterations 1 и убедись, что ошибка ушла.

Измени сам. В конце функции export default замени паузу sleep(1) на sleep(2). До запуска предскажи, как изменятся время итерации и RPS при тех же пяти пользователях. Повтори основной запуск и сравни iteration_duration и http_reqs с первым отчётом. Объясни изменение: важно связать код с поведением нагрузки, а не переписать JavaScript по памяти. После проверки верни паузу в одну секунду, чтобы следующие примеры совпадали с твоим сценарием.

Сломай и почини

Поломка. Измени пароль в login() на 'passw0rd' (опечатка вместо 'password') и запусти k6 run shop.js; echo "код выхода: $?".

Задача. Прежде чем читать разбор, ответь себе: что покажет отчёт и почему? Ты видишь только этот отчёт, как дежурный, которому прислали красный пайплайн. Порядок рассуждения:

Разбор
  1. В THRESHOLDS стоит ✗ 'rate<0.01' rate=100.00%: порог по http_req_failed нарушен, все запросы «неудачные». Код выхода равен 99 (так k6 сообщает, что порог нарушен, это основа работы в CI, подробно в 10.2).
  2. В проверках красный только вход: 200, а остальных четырёх нет вовсе: их не запускали, потому что при неудачном входе итерация завершается раньше (return). Вывод: «ломается самый первый шаг».
  3. Итераций примерно столько же (около 120 за 30 с, как в обычном прогоне), а iteration_duration около 1,25 с. Откуда это:
    • Итерация это вход (около 0,25 с, неверный пароль тоже проверяется через bcrypt) плюс sleep(1) перед return. Вместе около 1,25 с, пять VU дают около 4 итераций в секунду.
    • Четыре входа в секунду это потолок bcrypt на одном воркере, и пять VU упираются в него почти вплотную, так что иногда они чуть ждут друг друга.
    • Нагрузка красная, но бесполезная: итерация это один отказ 401, остальные четыре шага не выполняются. Красная нагрузка не равна «тяжёлой». Без sleep(1) VU вернулся бы мгновенно и превратился в молоток (см. «Типичные ошибки»).
  4. Одна итерация с --http-debug=full покажет: HTTP/1.1 401 Unauthorized и тело {"detail":"invalid credentials"} или подобное сообщение об ошибке входа.
  5. Верни 'password', запусти ещё раз: порог ✓, код выхода 0.

ИИ в помощь

Нейросеть быстро объясняет незнакомый JavaScript и читает сводку k6, но знание k6 у неё часто устарелое: она путает версии 0.x и 2.x. Общие правила: ИИ-помощник.

Задача: разобрать сводку прогона построчно.

Я запустил k6 2.3 против своего стенда «Магазин» (localhost:8000), 5 VU, 30 секунд. Вот сводка:
<вставь блок от THRESHOLDS до конца>
Объясни простыми словами каждую строку: что значат checks, http_req_duration (avg, p(95)), http_req_failed,
iterations и vus. Скажи, на какую строку смотреть первой и почему. Не выдумывай числа, которых нет в выводе.

Проверь ответ: сверь объяснение с разделом про сводку в теме урока и с самой сводкой: каждое число должно быть в твоём выводе. Типичная ошибка: нейросеть описывает формат k6 0.x или советует команды, которых в версии 2 нет (список выше, в разделе про версию 2.x).

Задача: набросать проверку поля ответа.

У меня сценарий k6 2.3 на JavaScript. Запрос res = http.get('http://localhost:8000/api/products?size=5').
Ответ - JSON с товарами. Напиши check, который проверяет: статус 200, ответ разбирается как JSON,
и в нём есть непустой список товаров. Объясни каждую строку, отдельно скажи, почему проваленный check
не останавливает тест.

Проверь ответ: запусти кусок с --vus 1 --iterations 1 и посмотри на строку checks. Типичные ошибки: res.json вызван как свойство без скобок, поле названо наугад (сверь с реальным curl -s localhost:8000/api/products?size=1), import из несуществующего модуля вместо k6/http и k6.

В запрос не вставляй настоящие токены и пароли: замени их на <TOKEN>.

Словарик урока

Термин Простыми словами
k6 Инструмент нагрузочного тестирования: движок на Go, сценарии на JavaScript
VU (virtual user) Виртуальный пользователь: независимый исполнитель сценария, делает запросы по одному
Итерация (iteration) Один проход функции по умолчанию от начала до конца
Init-код Всё вне функций в файле: выполняется один раз на VU до начала теста
default-функция Тело сценария: VU вызывает её в цикле, пока идёт тест
setup / teardown Необязательные функции: один раз до теста и один раз после
options Настройки теста: VU, длительность, пороги
const / let Переменная, которую нельзя переназначить, и которую можно
Стрелочная функция Короткая запись функции: (r) => r.status === 200
Шаблонная строка Строка в обратных кавычках со вставками ${значение}
JSON Текстовый формат данных; JSON.stringify создаёт его, JSON.parse разбирает
Модуль (module) Файл, из которого export отдаёт код, а import забирает его
check Проверка ответа: считает долю успехов, тест не останавливает
Порог (threshold) Условие на метрику, нарушение которого роняет тест (подробно в 10.2)
Think time Пауза между действиями пользователя: sleep()
Counter / Gauge / Rate / Trend Типы метрик: счётчик, датчик, доля, распределение с перцентилями
http_req_duration Время запроса: отправка плюс ожидание плюс получение
http_req_failed Доля запросов с кодом вне 200–399 или без ответа
Метка name Общее имя для запросов с разными URL, чтобы не плодить строки в метриках
Кардинальность Число уникальных комбинаций значений меток; слишком большое вредит мониторингу

Вопросы с собеседований

Раздел для повторения: ответь вслух, потом открой ответ. Короткие вопросы тренируй на скорость: ответ за 30 секунд.

1. [junior] [часто] Что такое VU и чем он отличается от итерации?

Ответ

VU (виртуальный пользователь) это исполнитель сценария: у него свой набор переменных, и он делает запросы по одному, ожидая ответа. Итерация это один проход функции по умолчанию. VU повторяет итерации одну за другой, пока идёт тест. В одной итерации может быть много запросов.

Что хотят услышать: VU это исполнитель, итерация это проход, запросов больше, чем итераций.

Красный флаг: «VU это один запрос» или «VU это реальный человек».

2. [junior] [часто] Чем k6 отличается от Locust?

Ответ

Сценарии на JavaScript против Python. k6 написан на Go и экономнее по ресурсам. В k6 есть готовые пороги с кодом выхода, удобные для CI, и можно задавать заданную скорость запросов (открытая модель); у Locust по умолчанию «столько-то пользователей» (закрытая модель) и удобный веб-интерфейс со слайдерами. У k6 тоже есть встроенный web dashboard (K6_WEB_DASHBOARD=true), но он не управляет нагрузкой на лету, а основной путь это Grafana. Подробное сравнение в уроке 10.3.

Что хотят услышать: язык, модель нагрузки, пороги для CI.

Красный флаг: «k6 быстрее, потому что лучше», без объяснения причин или «у k6 вообще нет интерфейса».

3. [junior] [часто] Что делает k6, если сервер отвечает 500: бросает исключение?

Ответ

Нет. 500 для k6 обычный ответ: он записывает задержку, считает запрос неудачным в http_req_failed (код вне 200–399) и идёт дальше. Хороший ли это ответ, решают проверки (check) и пороги.

Что хотят услышать: нет исключений, важны проверки, http_req_failed.

Красный флаг: «тест упадёт сам».

4. [junior] Чем check отличается от порога (threshold)?

Ответ

check проверяет конкретный ответ и записывает результат в метрику checks, тест не останавливает и итоговый вердикт не выносит. Порог это условие на метрику за весь тест (p(95)<500): нарушение даёт ненулевой код выхода (99) и красный CI.

Что хотят услышать: проверка фиксирует, порог выносит приговор.

Красный флаг: «проверка роняет тест».

5. [junior] Из каких стадий состоит жизненный цикл скрипта k6?

Ответ

Init (код вне функций, один раз на VU), необязательный setup() (один раз до теста), default() (тело, повторяется на каждой итерации), необязательный teardown() (один раз после). В конце итоговый отчёт.

Что хотят услышать: четыре стадии, что и сколько раз выполняется.

Красный флаг: «всё выполняется на каждой итерации».

6. [junior] Из чего складывается http_req_duration?

Ответ

Из трёх частей: http_req_sending (отправка запроса), http_req_waiting (ожидание ответа до первого байта, TTFB: в основном работа сервера, но в него входят и сеть, и очередь перед ним) и http_req_receiving (получение ответа). Время соединения (http_req_connecting, http_req_blocked) в него не входит.

Что хотят услышать: три части, waiting это в основном работа сервера.

Красный флаг: «это время всего теста» или «время до обработки на сервере».

7. [junior] Почему логин делают один раз на VU, а не на каждой итерации?

Ответ

Вход дорогая операция (проверка пароля через bcrypt нагружает процессор), и в реальной жизни пользователь входит один раз, а потом ходит по магазину с токеном. Если логиниться на каждой итерации, тест нагружает логин, а не те операции, которые мы хотели проверить. Токен хранят в переменной вне функции: она принадлежит VU и живёт между итерациями.

Что хотят услышать: реалистичность профиля и дороговизна логина.

Красный флаг: «чтобы быстрее писать код».

8. [junior] Зачем нужен sleep() в нагрузочном тесте?

Ответ

Он моделирует паузу человека между действиями (think time). Без него VU шлёт запросы без остановки, и нагрузка на сервер в десятки раз выше, чем создали бы живые люди. Паузой регулируют, сколько запросов в секунду даёт один VU: итераций в секунду на VU равно 1 / (время итерации), а запросов в секунду столько же, умножить на число запросов в итерации.

Что хотят услышать: think time и связь с RPS.

Красный флаг: «чтобы сервер успел передохнуть».

9. [middle] Что k6 по умолчанию считает неудачным запросом и как это изменить?

Ответ

Любой ответ вне 200–399 и сетевые ошибки. Поменять «ожидаемые» коды можно через http.setResponseCallback(http.expectedStatuses(200, 201, 404)) (глобально: хорошими станут ровно эти коды) или параметром responseCallback в конкретном запросе. Нужно, когда, например, 404 это нормальный ответ для данного сценария.

Что хотят услышать: коды 200–399 по умолчанию, способ переопределить.

Красный флаг: «неудачный запрос это только 500».

10. [middle] Почему URL с id товара вредит метрикам и как это решить?

Ответ

Метка url у каждого запроса разная, значит, в системе мониторинга образуются тысячи уникальных комбинаций меток (высокая кардинальность): растёт память и замедляются запросы. Решение: задать метку name одним значением, tags: { name: '/api/products/[id]' }.

Что хотят услышать: кардинальность и решение через name.

Красный флаг: «отключить метки совсем».

11. [middle] Три метрики, которые смотришь первыми в отчёте k6?

Ответ

http_req_duration (p(95)), http_req_failed (доля ошибок) и http_reqs (RPS). Потом проверки (checks) и iterations.

Что хотят услышать: http_req_duration по p(95), http_req_failed, http_reqs; сначала ошибки и задержка, потом остальное; сверка с порогами.

Красный флаг: «смотрю только среднее время ответа».

Проверено на версиях

Ubuntu 24.04, k6 2.3, стенд «Магазин» из project/shop (FastAPI, PostgreSQL 18.6, Redis 8.10). Октябрь 2026.

Итог урока: ты умеешь

  • Объяснить, что такое VU, итерация, init-код и функция по умолчанию, и в чём разница между ними.
  • Написать на JavaScript простой сценарий: переменные, функции, объекты, массивы, JSON, import и export.
  • Сделать HTTP-запросы http.get и http.post с заголовками и телом JSON и разобрать ответ.
  • Поставить проверки check и объяснить, почему они не останавливают тест.
  • Прочитать итоговый отчёт k6 построчно: http_req_duration, http_req_failed, http_reqs, iterations, vus, checks.
  • Запустить сценарий покупателя ~/perf-lab/10-k6/shop.js и сохранить результат в ~/perf-lab/results/.
  • Спросить нейросеть про непонятную строку сводки k6 с полным выводом и проверить ответ запуском с одной итерацией.

Дальше: урок 10.2. Сценарии, открытая модель и пороги, где ты зададишь фиксированную скорость запросов и научишь k6 сам решать, прошёл ли тест.

Проверь себя

Короткий тест по уроку: 5 вопросов из банка в 30. Засчитывается только полностью правильный ответ, порог 60%. Каждая новая попытка даёт другие вопросы, пока банк не закончится. Ответы видны после проверки.

Тест работает с включённым JavaScript.

тема 10 урок 10.1 3.5 ч курс 0/0 ← → уроки

Помоги улучшить курс

Что нужно изменить?