Нагрузочное тестирование и chaos engineering: k6, Gatling, Locust

Восемь генераторов нагрузки против сервиса, который сам знает правду о своих задержках: закрытая модель прячет паузу сервиса в p99, открытая показывает; spike-тест без запаса VU не создаёт всплеска, soak ловит утечку, которую короткий тест пропускает; хаос-эксперимент с Toxiproxy проверяет гипотезу стабильного состояния, а повтор запроса клиентом прячет потерю реплики от встроенной метрики k6

«Прогнали нагрузочный тест, p99 — 16 мс, всё держит». За такой фразой может стоять сервис, который каждые десять секунд замирает на секунду, и генератор, который этого не заметил. Генератор нагрузки — тоже измерительный прибор, и у него есть своя модель того, как приходят запросы. Если она не совпадает с реальным трафиком, прибор врёт, причём ровно в той части распределения, ради которой тест и затевали.

В этой статье — опыт на стенде, где правду знает не генератор, а сервис. Восемь генераторов в тринадцати режимах получают одну и ту же задачу, и их отчёты сверяются с расчётом. Затем — виды нагрузочных тестов, потолок самих генераторов и chaos engineering с внесением сбоев через Toxiproxy.

Стенд: digital-cookbook/performance/load-testing.

Ретрофутуристский инженерный лист: в центре — одна машина с вращающимся барабаном, к ней двумя кабелями подключены два прибора. Слева — генератор с метрономом: шлёт по кабелю ровные оранжевые импульсы по своему расписанию, и на его ленте самописца видны регулярные глубокие провалы. Справа — прибор со звонком и рычагом, который срабатывает только после ответа машины: по его кабелю идут редкие импульсы, а лента почти ровная, с единственным тонким пиком. Во врезке внизу справа та же машина, на её кабель надет зажим с подписью «сбой».

В статье

Стенд: сервис-эталон

Целевой сервис на Go устроен так, чтобы его поведение можно было посчитать заранее:

  • обслуживание запроса занимает S = 10 мс;
  • одновременно обслуживается не больше C = 8 запросов (семафор с очередью), значит ёмкость — C/S = 800 запросов в секунду;
  • по расписанию сервис замирает: P секунд из каждых T он не начинает обслуживание новых запросов. Это аналог паузы stop-the-world у сборщика мусора или зависшего диска.

Сервис сам считает принятые запросы по секундам, время обслуживания каждого и окна пауз. А для открытой модели нагрузки — запросы приходят по расписанию, независимо от ответов — истину можно посчитать до прогона: scripts/truth.py детерминированно симулирует тот же сервис. При 200 запросах в секунду, 60 с и паузе 1 с каждые 10 с истина такая: p50 — 10 мс, p90 — 255 мс, p99 — 930 мс, максимум — 1010 мс. Каждый десятый запрос попадает в паузу и ждёт её конца, ещё часть ждёт, пока разберётся очередь, накопленная за паузу.

Все генераторы запускаются одноразовыми контейнерами с одинаковым лимитом — 2 ЦП и 1 ГБ памяти (Gatling — 2 ГБ: в контейнере JVM и Maven). Всё стоит в одной VM Docker Desktop, это важно для выводов о потолках, но не для выводов о модели нагрузки.

Открытая и закрытая модель: что видит генератор

Закрытая модель: фиксированное число «пользователей» (соединений, VU), каждый отправляет следующий запрос только после ответа на предыдущий. Так работают wrk, hey, constant-vus в k6, constantConcurrentUsers в Gatling и Locust — у него другой модели нет. Открытая модель: запросы приходят с заданным темпом, независимо от того, ответил ли сервис на предыдущие. Так работают wrk2 с -R, vegeta, oha с -q, constant-arrival-rate в k6 и constantUsersPerSec в Gatling.

Какая модель верна, зависит от клиентов. Поток независимых операций — новые пользователи, запросы от множества устройств — приходит открыто: тысяча пользователей не перестаёт нажимать кнопку оттого, что у сервиса пауза сборщика мусора. Последовательная сессия одного клиента — следующий шаг после ответа на предыдущий — закрытая по природе. Ошибка не в закрытой модели, а в её выборе для задачи «удержать темп и увидеть хвост». В такой задаче закрытый генератор в паузу ждёт вместе с сервисом и не отправляет запросы, которые пришли бы при заданном темпе. Медленными оказываются только те немногие, что уже были в полёте. Это и есть coordinated omission: генератор согласованно с сервисом пропускает замеры именно тогда, когда сервису плохо.

sequenceDiagram participant C as Закрытый генератор, 3 соединения participant S as Сервис participant O as Открытый генератор, 200/с Note over S: пауза 1 с C->>S: 3 запроса уже в полёте Note over C: ждёт ответов, новых запросов не шлёт O->>S: запрос каждые 5 мс, по расписанию Note over O: за паузу ушло ≈200 запросов S-->>C: 3 ответа, каждый ≈1 с S-->>O: ≈200 ответов, задержка от ≈1 с до нуля Note over C: в гистограмме — 3 медленных замера Note over O: в гистограмме — ≈200 медленных замеров

sequenceDiagram
    participant C as Закрытый генератор, 3 соединения
    participant S as Сервис
    participant O as Открытый генератор, 200/с
    Note over S: пауза 1 с
    C->>S: 3 запроса уже в полёте
    Note over C: ждёт ответов, новых запросов не шлёт
    O->>S: запрос каждые 5 мс, по расписанию
    Note over O: за паузу ушло ≈200 запросов
    S-->>C: 3 ответа, каждый ≈1 с
    S-->>O: ≈200 ответов, задержка от ≈1 с до нуля
    Note over C: в гистограмме — 3 медленных замера
    Note over O: в гистограмме — ≈200 медленных замеров
Одна пауза сервиса глазами двух генераторов: закрытый замеряет три медленных запроса, открытый — все, что должны были прийти за паузу

Постановка. Задача одна: /work 60 с, сервис замирает на 1 с каждые 10 с. Открытые режимы — 200 запросов в секунду, закрытые — три соединения или пользователя (это до ≈ 250 запросов в секунду без пауз). Перед прогоном каждый генератор проверяется без пауз 20 с: p99 у всех — меньше трёх S, счёт генератора сходится со счётом сервиса.

генератор модель отправлено p90, мс p99, мс max, мс паузу
wrk, 3 соединения закрытая 14079 14 907 1014 показал
hey, 3 соединения закрытая 10707 11 12 1015 спрятал
k6 constant-vus, 3 VU закрытая 14715 11 12 1013 спрятал
Gatling constantConcurrentUsers(3) закрытая 14637 11 12 1011 спрятал
Locust, 3 пользователя закрытая 12892 13 15 1000 спрятал
Locust constant_throughput, 3 пользователя закрытая 10767 13 14 1000 спрятал
wrk2 -R200 открытая 12003 318 950 1018 показал
vegeta -rate=200 открытая 12000 270 931 1008 показал
oha -q 200 открытая 12002 21 24 1015 спрятал
oha -q 200 --latency-correction открытая 12002 278 936 1011 показал
k6 constant-arrival-rate, 300 VU открытая 12001 275 932 1011 показал
k6 constant-arrival-rate, 20 VU открытая 10904 (не отправлено 1097) 11 944 1013 показал
Gatling constantUsersPerSec(200) открытая 11998 276 932 1012 показал

Истина для сравнения — те самые 255 / 930 / 1010 мс, с поправкой на сдвиг первого запроса относительно расписания пауз (в фикстуре — для каждой строки своя). «Показал» — p99 в пределах 10% от истины и максимум в пределах 5%; «спрятал» — p99 меньше трёх S.

Закрытые генераторы без коррекции — hey, k6 с constant-vus, Gatling с constantConcurrentUsers, Locust в обоих режимах — дают p99 от 12 до 15 мс, как будто пауз нет. Пауза видна у них только в максимуме: около секунды. Если в отчёте смотреть p99 и не смотреть максимум, сервис с секундной паузой каждые десять секунд выглядит здоровым.

$ python3 scripts/run-model.py hey
{"variant": "hey", "outcome": "hides", "detail": "p90/p99/max 11/12/1015 мс против истины 253/928/1008; отправлено 10707, сервис принял 10707"}
$ python3 scripts/run-model.py vegeta
{"variant": "vegeta", "outcome": "matches", "detail": "p90/p99/max 270/931/1008 мс против истины 254/929/1009; отправлено 12000, сервис принял 12000"}

Три наблюдения, которых не было в исходной гипотезе.

wrk корректирует, но не всё. wrk — закрытый генератор, но он досчитывает пропущенные замеры. Ожидаемый интервал он берёт из собственного прогона — длительность, делённая на число ответов одного соединения; каждый замер длиннее двух интервалов дополняется синтетическими значениями с шагом в этот интервал (stats_correct в исходниках). Хвост восстанавливается — p99 сошёлся с истиной, а середина нет: p90 у wrk — 14 мс против 252 мс. Синтетических замеров добавляется по числу запросов, которые этот закрытый цикл не отправил, а не по числу запросов, пришедших бы при реальном темпе. wrk2 эту задачу решает иначе: у него есть расписание отправки, и задержка считается от запланированного момента, а не от фактического.

oha прячет паузу без флага. Без --latency-correction oha считает задержку от фактической отправки, и при 16 соединениях застрявших в паузе запросов меньше 1% — p99 24 мс. С флагом — 936 мс, как у остальных открытых. Флаг стоит включать всегда, когда задан темп.

Открытая модель в k6 упирается в VU. constant-arrival-rate отправляет итерацию по расписанию, но каждой нужен свободный VU. При 20 VU в паузу они все заняты, и k6 не отправил 1097 запросов — это видно только по метрике dropped_iterations. p99 при этом в допуске, а p90 — 11 мс: часть хвоста просто не была измерена. Число VU для открытой модели — не «сколько пользователей», а «сколько запросов может быть в полёте одновременно»: темп умножить на худшую задержку, которую тест должен увидеть.

Отдельно о сервере. Счётчик сервиса тоже не видит coordinated omission: его часы начинают отсчёт, когда запрос пришёл. У wrk2 и oha с 16 соединениями сервис насчитал p99 25 мс — запросы, которые генератор задержал у себя, сервер видит быстрыми. Серверный p99 совпал с истиной только у генераторов, которые открывают соединения по мере надобности (vegeta, k6, Gatling в открытом режиме). Серверные гистограммы — не замена правильному генератору.

Виды нагрузочных тестов

Все тесты этого раздела — k6 в открытой модели.

  • Load — ожидаемая нагрузка: выполняется ли SLO (здесь — p99 меньше 50 мс, ошибок меньше 1%).
  • Stress — темп растёт за пределы ёмкости: где колено и как система отказывает.
  • Spike — резкий всплеск: сколько система разгружается после него.
  • Soak — долго под умеренной нагрузкой: утечки и медленная деградация.
тест задано вышло расчёт
load 400/с, 60 с p99 11,5 мс, SLO выполнен p99 10 мс
stress 200 → 1000/с за 60 с обслужено до 745/с, задержка растёт с 764/с C/S = 800/с
spike 400/с, 1200/с на 5 с разгрузка 7,2 с 5,3 с по номиналу S, 6,7 с по факту
spike, 200 VU то же сервис принимал 931/с, не отправлено 1363 1200/с
soak, 30 с 100/с, утечка 4 КБ на запрос OOM нет, куча +13,9 МБ, SLO выполнен —
soak, 300 с то же OOM на 152-й секунде, ошибок 13256 из 28200 лимит 96 МБ

Stress. Ёмкость по построению — 800 запросов в секунду, а сервис обслуживал не больше 745 в секунду: сон в Go длится чуть дольше заказанного, плюс HTTP. Задержка уходит вверх с темпа 764 в секунду — колено там же, где фактическая ёмкость, а не номинальная. Номинал в капасити-плане — оптимистичная оценка; меряется фактическая.

Spike. План k6 — 20 с по 400 в секунду, за 1 с рост до 1200, 5 с на 1200, за 1 с спад до 400 и дальше 400; расчёт учитывает и переходы, а не только плато. После всплеска очередь разгружалась 7,2 с. Расчёт по номиналу S даёт 5,3 с, по средней занятости слота — сервис меряет её отдельно, от конца ожидания в очереди до освобождения слота семафора, то есть ровно то, что в формуле ёмкости стоит на месте S (10,6 мс) — 6,7 с. Разница в 7% ёмкости превращается в разницу в 1,4 с разгрузки: очередь разбирается избытком ёмкости над входящим темпом, а он маленький.

Первый прогон spike дал другую картину — и это отдельный урок.

$ python3 scripts/run-types.py spike-few-vus
{"variant": "spike-few-vus", "outcome": "match", "detail": "во время всплеска сервис принимал 931/с из 1200/с; k6 не отправил 1363"}
$ python3 scripts/run-types.py spike
{"variant": "spike", "outcome": "match", "detail": "очередь разгружена через 7.2 с после всплеска; расчёт: 5.3 с по номиналу S, 6.7 с по факту; k6 не отправил 69"}

С 200 заранее созданными VU k6 во время всплеска отправлял около 931 запросов в секунду вместо 1200 и не отправил 1363. В очереди всплеска одновременно до двух тысяч запросов, каждому нужен свой VU, а k6 создаёт новые VU медленнее, чем растёт очередь. Spike-тест без запаса VU не создаёт всплеска — и отчитывается о том, что система его пережила.

Soak. Сервис с утечкой — каждый запрос оставляет в памяти 4 КБ — и лимитом памяти контейнера 96 МБ. Тридцать секунд при 100 запросах в секунду проходят чисто: SLO выполнен, куча выросла на 13,9 МБ, что легко принять за прогрев. Пять минут — сервис убит OOM на 152-й секунде, дальше ошибки. Короткий тест может пропустить медленную утечку, и смотреть в soak нужно не на латентность, а на тренд памяти, дескрипторов и соединений.

Потолок генератора

Генератор — такая же программа, и у неё есть свой предел. Если он ниже нагрузки, которую вы хотите подать, тест измеряет генератор, а не систему.

Постановка. /fast — ответ без работы. Открытые генераторы — заданный темп 1000, 4000, 8000 и 16 000 в секунду, 10 с; «держит» — сервис принял не меньше 95%. Лимит каждого генератора — 2 ЦП.

генератор 1000/с 4000/с 8000/с 16 000/с
wrk2 999 3993 7986 15971
vegeta 1000 4000 8000 16000
oha 1000 4000 7999 15998
k6 1000 4000 8000 15946
Gatling 1000 4000 8000 5267 — не держит

Сервис здесь не ограничение: закрытый wrk с 64 соединениями выжимает из него больше ста тысяч запросов в секунду.

закрытый генератор, 64 соединения запросов в секунду
wrk 109191
hey 68305
Locust, один процесс 4148
Locust, два процесса 9986

ЦП генератора снимается отдельными прогонами того же сценария по 30 с: опрос docker stats сам нагружает ту же VM и сбивает генератор у его предела — Gatling на 16 000 под опросом выдал 3063 запроса в секунду против 5267 без опроса, а в ранней сессии под опросом не удержали темп и k6. Поэтому темп выше — без опроса, ЦП — здесь. В таблице — медиана замеров внутри интервала нагрузки: от первого прихода на сервис до последнего, без крайних секунд, так что старт JVM и Maven у Gatling в неё не попадает.

генератор, нагрузка ЦП контейнера, %, медиана за интервал нагрузки (лимит — 200)
Gatling, 8000/с 53
Gatling, 16 000/с 199
k6, 16 000/с 107
wrk2, 16 000/с 25
Locust, один процесс 100
Locust, два процесса 199

wrk2, vegeta, oha и k6 держат все четыре темпа. Эта конфигурация Gatling — новая JVM, 10 с без прогрева, constantUsersPerSec — держит 8000 в секунду и не держит 16 000. ЦП её контейнера на 16 000 — 199% из 200%, на 8000 — 53%. Недобор совпадает с полной занятостью ЦП, это указывает на ЦП как причину, но не доказывает её: сборку мусора, троттлинг контейнера и задержку запуска пользователей стенд не мерит, а прогретая JVM в длинном тесте может дать больше. Прежний способ отбора замеров — медиана верхней половины за всю жизнь контейнера, около p75, — завышал оценку и на 8000 показывал почти полную занятость ЦП; новый результат получен в отдельном 30-секундном прогоне за интервал нагрузки.

Locust одним процессом даёт 4148 запросов в секунду при 100% ЦП — ровно одно ядро: Python исполняет код пользователей в одном потоке. Двумя процессами — 9986 при 199%. Для Locust распределённый режим (--processes или master и workers) — не опция для больших тестов, а условие использовать ЦП машины.

Практический вывод: перед тестом прогоните генератор против заглушки на целевом темпе и посмотрите две вещи — держит ли он темп по счёту сервиса и не упёрся ли его ЦП в лимит. Если упёрся, тест меряет генератор.

Chaos engineering: гипотеза против сбоя

Нагрузочный тест отвечает на вопрос «сколько выдержит». Chaos engineering — на вопрос «что будет, когда что-то сломается». Метод — эксперимент:

  1. Стабильное состояние — наблюдаемая величина, по которой видно, что система работает: здесь ошибок меньше 1% и p99 меньше 300 мс.
  2. Гипотеза — стабильное состояние сохранится при таком-то сбое.
  3. Сбой — вносится в контролируемом объёме (blast radius).
  4. Вывод — гипотеза устояла или нет, и почему.

Постановка. Две реплики сервиса за HAProxy; сервис ходит в зависимость через Toxiproxy. Нагрузка — k6, 200 запросов в секунду 60 с; сбой — с 20-й по 40-ю секунду, 4000 запросов в окне. Сервис в двух вариантах: наивный (ждёт зависимость сколько угодно, ошибка зависимости — его ошибка) и устойчивый (таймаут 100 мс, одна повторная попытка, затем запасной ответ — последняя полученная от зависимости цена с её возрастом в заголовке). Пороги k6 — это и есть гипотеза.

// scenarios/k6/chaos.js
  thresholds: {
    http_req_failed: [{ threshold: 'rate<0.01', abortOnFail: abort, delayAbortEval: '1s' }],
    http_req_duration: ['p(99)<300'],
    op_duration: ['p(99)<300'],
  },

Порогов по задержке два. http_req_duration — встроенная метрика k6, и у неё есть граница: она меряет одну HTTP-попытку без установления соединения, а если клиент повторил запрос на новом соединении, k6 перезаписывает отметки замера, и время прежней попытки из метрики выпадает (так устроен Tracer в исходниках k6). op_duration — полная операция пользователя: время вокруг всего http.get, со всеми повторами.

// scenarios/k6/chaos.js
  const t0 = Date.now();
  const r = http.get(__ENV.TARGET || 'http://lb:8080/order', { timeout: '10s' });
  op.add(Date.now() - t0, { failed: String(r.status !== 200) });

Сбои вносятся через API Toxiproxy (latency на ответы зависимости, выключение прокси) и docker kill реплики.

Пороги k6 считаются за весь прогон, вместе со здоровыми 40 секундами. Поэтому «гипотеза устояла» по k6 значит «выполнен общий порог», а не «стабильное состояние сохранилось во время сбоя». Второе раннер проверяет отдельно: по сырым точкам k6 (--out json) считает долю ошибок и p99 полных операций в окне сбоя и в 5 с после его снятия, а также худшую секунду прогона. Операция относится к окну по своему началу. Моменты сбоя отмечаются по часам той же VM, по которым k6 ставит метки, — до и после каждой команды: окно сбоя — от «сбой внесён» до «начали снимать», а внесение и снятие — отдельные переходные интервалы. На переключении реплик ошибки как раз там: у остановки реплики все ошибки приходятся на интервал, пока выполнялся docker kill. В самом k6 то же делается тегом окна и порогами по метрикам с тегом. Запись сырых точек сама нагружает k6, поэтому p99 в этих прогонах может быть на несколько миллисекунд выше, чем без неё.

эксперимент сервис ошибок запасных ответов p99 HTTP, мс p99 операции, мс порог по HTTP порог по операции
без сбоя наивный 0 из 12001 0 7 8 выполнен выполнен
без сбоя устойчивый 0 из 12001 0 7 8 выполнен выполнен
задержка зависимости +500 мс наивный 0 из 12001 0 508 508 не выполнен не выполнен
задержка зависимости +500 мс устойчивый 0 из 12001 4056 202 203 выполнен выполнен
отказ зависимости наивный 4094 из 12001 0 7 8 не выполнен не выполнен
отказ зависимости устойчивый 0 из 12001 4092 7 7 выполнен выполнен
отказ зависимости, abortOnFail наивный 122 из 3990 0 8 8 не выполнен не выполнен
docker kill реплики — 2 из 12001 0 8 4010 выполнен не выполнен
docker kill реплики, HAProxy retries 0 — 29 из 12001 0 7 1007 выполнен не выполнен
эксперимент сервис внесение сбоя: ошибок окно сбоя: ошибок окно сбоя: p99 операции, мс снятие сбоя: ошибок 5 с после: ошибок худшая секунда стабильное состояние в окне
задержка зависимости +500 мс наивный 0 из 35 0 из 4054 508 0 из 36 0 из 1000 0,0% нет
задержка зависимости +500 мс устойчивый 0 из 33 0 из 4059 203 0 из 36 0 из 1000 0,0% сохранилось
отказ зависимости наивный 18 из 33 4057 из 4057 2 19 из 37 0 из 1000 100,0% нет
отказ зависимости устойчивый 0 из 32 0 из 4056 2 0 из 35 0 из 1000 0,0% сохранилось
docker kill реплики — 2 из 42 0 из 4052 4012 0 из 48 0 из 1000 1,0% нет
docker kill реплики, HAProxy retries 0 — 10 из 52 19 из 4053 1008 0 из 44 0 из 1000 8,0% нет

Задержка зависимости ломает наивный сервис не ошибками, а временем: ни одной ошибки, p99 508 мс. Мониторинг ошибок такой сбой не заметит. Устойчивый сервис держит гипотезу и в окне сбоя: p99 203 мс — два таймаута по 100 мс.

Отказ зависимости. У наивного — 4094 ошибки, практически все запросы окна. Устойчивый — ноль ошибок, гипотеза устояла и в окне сбоя. Но за весь прогон 4092 ответа были запасными: последняя цена, полученная до сбоя. К концу окна ей 20 с, медиана — 10 с. Гипотеза «ошибок меньше 1%» не отличает свежую цену от двадцатисекундной. Если запасной ответ — деградация, его нужно считать отдельно и включать в стабильное состояние вместе с допустимым возрастом, иначе эксперимент подтвердит устойчивость, которой пользователь не видит.

Blast radius. Тот же отказ с abortOnFail: порог по ошибкам оборвал эксперимент на 20-й секунде — почти сразу после начала сбоя.

$ python3 scripts/run-chaos.py down-naive
{"variant": "down-naive", "outcome": "match", "detail": "порог по HTTP-метрике не выполнен, по операции не выполнен: ошибок 4094 из 12001, запасных ответов 0, p99 HTTP 7 мс, операции 8 мс"}
$ python3 scripts/run-chaos.py down-naive-abort
{"variant": "down-naive-abort", "outcome": "match", "detail": "порог по HTTP-метрике не выполнен, по операции не выполнен: ошибок 122 из 3990, запасных ответов 0, p99 HTTP 7 мс, операции 8 мс; эксперимент оборван порогом на 20.0 с"}

122 ошибки вместо 4094. В проде эксперимент без условия остановки — это просто авария, которую вы устроили сами.

Остановка реплики дала сюрприз, и первое объяснение не подтвердилось. Ожидание было — около сотни ошибок, пока проверка живости HAProxy (раз в 500 мс, две неудачи подряд) не выведет реплику. У k6 ошибок — 2. Первая догадка — «HAProxy при повторе выбрал другую реплику» — журнал HAProxy (option httplog) опроверг.

Убитый контейнер не отвергает соединение: его адрес перестаёт отвечать, и каждая попытка ждёт таймаута соединения 1 с. HAProxy трижды повторяет соединение с той же репликой (retries 3 по умолчанию; option redispatch в конфиге нет, перенаправлений в журнале — 0) и через ≈4 с фиксирует 503. Таких записей в журнале 162, и в 160 из них клиенту не отправлено ни байта: соединение закрывается без ответа. А попыток в журнале на 160 больше, чем запросов у k6. Их добавил клиент: k6 построен на net/http из Go, а он сам повторяет идемпотентный запрос без тела, если переиспользованное соединение закрылось без ответа, — по сетевой ошибке, а не по статусу 503, которого клиент так и не увидел. Повтор уходит уже на живую реплику, и пользователь получает ответ — но через ≈4 с, и, как видно ниже, встроенная метрика k6 этих 4 с не видит. С retries 0 у HAProxy ошибок у k6 — 29, клиент повторил 154 запроса.

$ python3 scripts/run-chaos.py kill-replica
{"variant": "kill-replica", "outcome": "match", "detail": "порог по HTTP-метрике выполнен, по операции не выполнен: ошибок 2 из 12001, запасных ответов 0, p99 HTTP 8 мс, операции 4010 мс"}
$ python3 scripts/run-chaos.py kill-replica-noretry
{"variant": "kill-replica-noretry", "outcome": "match", "detail": "порог по HTTP-метрике выполнен, по операции не выполнен: ошибок 29 из 12001, запасных ответов 0, p99 HTTP 7 мс, операции 1007 мс"}

По встроенной метрике k6 повторы спрятали потерю реплики: p99 http_req_duration — 8 мс, общий порог выполнен. Но метрика меряет только последнюю HTTP-попытку, а время попытки, которую повторил клиент, из неё выпадает. Полная операция пользователя — другая картина: p99 op_duration — 4010 мс с повторами HAProxy и 1007 мс без них, порог по операции не выполнен. Медленных операций больше 1%. Последовательность у каждой из ≈160 повторённых клиентом одна: HAProxy исчерпывает повторы соединения с мёртвой репликой и фиксирует 503, соединение закрывается без ответа, клиент получает сетевую ошибку и повторяет запрос — уже на живую реплику.

Это главный инженерный вывод раздела: проверять нужно не только порог, но и то, какую часть пользовательской операции меряет выбранная метрика. Встроенная метрика генератора меряет то, что удобно замерить генератору, а не то, что видит пользователь. Худшая секунда показывает то же со стороны ошибок: 1,0% ошибок с повторами и 8,0% без повторов HAProxy при норме за весь прогон.

Общий вывод раздела: хаос-эксперимент проверяет ровно ту гипотезу, которую вы записали, на том окне и той метрикой, по которым её считают. Каждый «сюрприз» выше — это величина, окно или граница метрики, которых гипотеза не включала: задержка вместо ошибок, запасной ответ вместо настоящего, секунда вместо всего прогона, HTTP-попытка вместо операции. А механизм сюрприза нужно доказывать журналом — первая догадка о нём здесь оказалась неверной.

Как повторить один опыт

Главный опыт статьи — пауза сервиса глазами закрытого и открытого генератора — повторяется за пять минут, если образы уже собраны (первая сборка образа генераторов — около 10 минут: oha собирается из исходников). В каталоге стенда:

docker compose up -d --build --wait svc
docker compose exec svc curl -fsS -XPOST 'localhost:8080/admin/stall?p=1s&t=10s'
docker compose run --rm gen hey -z 60s -c 3 -q 66 http://svc:8080/work
docker compose exec svc curl -fsS -XPOST localhost:8080/admin/reset
docker compose exec svc curl -fsS -XPOST 'localhost:8080/admin/stall?p=1s&t=10s'
docker compose run --rm gen sh -c "echo 'GET http://svc:8080/work' | vegeta attack -rate=200 -duration=60s | vegeta report"
python3 scripts/truth.py 200 60 1 10

Первый генератор покажет p99 меньше 20 мс, второй — около секунды, truth.py — что должно было получиться. Сбросом (/admin/reset) обнуляется и расписание пауз, поэтому перед вторым генератором оно включается заново. То же с разбором и сверкой — python3 scripts/run-model.py hey vegeta.

Что переносится в прод, а что нет

Стенд оптимистичен по построению: одна машина, нет межмашинной сети, нет соседей, данные помещаются в кэш. Числа отсюда не переносятся. Переносятся свойства:

  • модель нагрузки определяет, увидите ли вы хвост, — и это не зависит от машины;
  • генератор нужно проверять на заглушке до теста;
  • номинальная ёмкость — оценка сверху, фактическую предсказывает измеренная занятость обработчика;
  • короткий тест может пропустить медленную утечку;
  • гипотеза хаоса проверяет только то, что в неё записано, и только на том окне и той метрикой, по которым её считают;
  • встроенная метрика генератора может не покрывать всю операцию пользователя — повтор клиента из http_req_duration выпадает.

Как выбрать генератор

генератор модель сценарии когда брать
k6 обе JavaScript CI, пороги как SLO, хаос-эксперименты; VU — с запасом под хвост
Gatling обе Java, Kotlin, Scala JVM-команда, сложные сценарии, подробный отчёт
Locust закрытая Python сложная логика пользователя на Python; несколько процессов обязательно
wrk2 открытая Lua точный замер хвоста при заданном темпе
vegeta открытая цели из файла простой замер с темпом, библиотека для Go
oha обе — быстрая проверка с темпом; всегда с --latency-correction
wrk закрытая Lua максимальная пропускная способность, не латентность
hey закрытая — быстрая проверка доступности, не латентность

Итог

  • Для задачи «удержать темп и увидеть хвост» закрытая модель прячет паузу сервиса в p99 — пять из пяти закрытых режимов без коррекции. Нужен генератор с расписанием отправки.
  • Даже открытый генератор недодаёт нагрузку, если ему не хватает ресурсов: dropped_iterations в k6 и ЦП контейнера генератора — обязательные части отчёта.
  • Spike-тест без запаса VU не создаёт всплеска; soak ловит то, что короткий тест может пропустить; колено stress-теста — у фактической ёмкости, а не номинальной.
  • Хаос-эксперимент подтверждает только записанную гипотезу. Запасные ответы с их возрастом, задержка вместо ошибок, окно сбоя вместо всего прогона и полная операция вместо HTTP-попытки должны быть в ней явно, а механизм неожиданного результата — подтверждён журналом.

Связанные темы — теория очередей и планирование ёмкостиСкоро и хвостовая латентностьСкоро.

Обсуждение в Telegram

Присоединиться →