«Прогнали нагрузочный тест, p99 — 16 мс, всё держит». За такой фразой может стоять сервис, который каждые десять секунд замирает на секунду, и генератор, который этого не заметил. Генератор нагрузки — тоже измерительный прибор, и у него есть своя модель того, как приходят запросы. Если она не совпадает с реальным трафиком, прибор врёт, причём ровно в той части распределения, ради которой тест и затевали.
В этой статье — опыт на стенде, где правду знает не генератор, а сервис. Восемь генераторов в тринадцати режимах получают одну и ту же задачу, и их отчёты сверяются с расчётом. Затем — виды нагрузочных тестов, потолок самих генераторов и chaos engineering с внесением сбоев через Toxiproxy.
Стенд: digital-cookbook/performance/load-testing.
В статье
- Стенд: сервис-эталон
- Открытая и закрытая модель
- Виды нагрузочных тестов
- Потолок генератора
- Chaos engineering
- Как повторить один опыт
- Что переносится в прод
- Как выбрать генератор
Стенд: сервис-эталон
Целевой сервис на 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 медленных замеров
Постановка. Задача одна: /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% и p99 меньше 300 мс.
- Гипотеза — стабильное состояние сохранится при таком-то сбое.
- Сбой — вносится в контролируемом объёме (blast radius).
- Вывод — гипотеза устояла или нет, и почему.
Постановка. Две реплики сервиса за 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
Присоединиться →