Files
mtusi2026lab3/REPORT.md
T

68 KiB
Raw Blame History

Отчёт — лабораторная 3

  • Автор, группа: заполните перед сдачей
  • Целевая оценка: 5 (уровни 3 и 4 целиком + трек 1 «Цена масштабирования»)
  • Commit/PR: ветка lab3; коммиты: e9cd28d (идентичность реплики, LB-проверка, идемпотентность), 917ed1a (стенд HAProxy + реплики, лимиты, хуки), 410e1ea (харнесс экспериментов), 5a5a8fe (оптимизация пути записи, C2), 2950b77 (evidence, этот отчёт, документация, C5), eabb1d2 (проверка из чистого clone), 06431d8, 1802ca1, e38795d (доказательства уровня 4 и трека 1 на финальной сборке, уточнение статуса гипотез), b7cf7b2 (догоняющие серии трека 1 по замечаниям ревью: abdiag, блок «почему», колено, LB) и этот коммит с актуализацией списка хешей. PR — после пуша ветки в origin оператором (нужны его credentials).
  • Источники, библиотеки и помощь ИИ: контракт contracts/openapi.json, contracts/README.md, tests/README.md, документация HAProxy 3.2, Docker Compose, k6 0.54, докуменация NestJS/Fastify/pg/redis. Код и эксперименты подготовлены с использованием ИИ-ассистента; все числа в отчёте получены прогонами на описанном стенде и лежат в evidence/.

Запуск из чистого clone

Версии: Docker 29.9.0, Docker Compose v5.6.0, Node.js 25.7.0, Python 3.14 (для проверок и харнесса; публичные тесты требуют 3.9+), образы postgres:16.4-alpine, redis:7.4.2-alpine, haproxy:3.2-alpine, grafana/k6:0.54.0, node:25.7.0-slim (сборка API). Хост — Fedora, 8 логических CPU, 16 GiB RAM.

git clone <origin> lab3 && cd lab3
cp .env.example .env
password=$(openssl rand -hex 32)
sed -i "s/^POSTGRES_PASSWORD=.*/POSTGRES_PASSWORD=$password/" .env
sed -i "s|^DATABASE_URL=.*|DATABASE_URL=postgresql://messenger:$password@postgres:5432/messenger|" .env
sed -i "s/^METRICS_TOKEN=.*/METRICS_TOKEN=$(openssl rand -hex 16)/" .env

make stand-up          # docker compose up -d --build --wait: postgres, redis, migrate, api x API_REPLICAS, haproxy
make wait-ready        # GET /health/ready через LB
make test              # публичный smoke lab3 (через LB, BASE_URL=http://localhost:8080)
make test-e2e          # black-box набор приложения (нужны loopback-порты PG/Redis из compose.yaml)

Проверки отказов и сохранности (требуют управления контейнерами):

make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && scripts/start-replica.sh
make test-dependencies

Эксперименты трека 1 (останавливают посторонние контейнеры хоста и возвращают их):

docker pull haproxy:3.2-alpine grafana/k6:0.54.0 postgres:16.4-alpine redis:7.4.2-alpine
python3 scripts/lab3/lab3.py track1          # серия A/B/C и рост ресурсов; фон хоста глушится сам
python3 scripts/lab3/lab3.py analyze         # таблицы и графики из raw

Безопасная остановка стенда: make stand-down (docker compose down) — тома postgres-data и redis-data сохраняются, поэтому данные и сессии остаются на месте. Намеренное удаление учебных данных: docker compose down -v (удаляет оба тома; после этого следующий make stand-up создаёт пустую схему и применяет миграции заново).

Архитектура и решения

клиент ──► HAProxy :8080 ──► api-1 ─┐
                 (проба /internal/lb-check)  ├──► PostgreSQL (источник истины)
                            api-2 ─┘           └──► Redis (сессии, кэш истории)
                            api-N
Роль Service Образ Готовность Тома/порты
Балансировщик haproxy haproxy:3.2-alpine проба backend GET /internal/lb-check 8080, статистика 127.0.0.1:8404
API ×N api сборка Dockerfile (${API_IMAGE}) /health/ready (healthcheck контейнера) портов нет
Миграции migrate тот же образ service_completed_successfully —
PostgreSQL postgres postgres:16.4-alpine pg_isready postgres-data, loopback:5432
Redis redis redis:7.4.2-alpine redis-cli ping redis-data, loopback:6379

Источник истины и транзакционные границы. Пользователи, чаты, членство, сообщения и журнал идемпотентности живут в PostgreSQL. Redis хранит сессии (durability обеспечена AOF, поэтому сессии переживают рестарт) и кэш страниц истории — производное состояние, которое всегда восстанавливается из БД: кэш версионирован (chats.message_version, растёт в той же транзакции, что и вставка сообщения), поэтому устаревшая страница не отдаётся. Локального состояния, влияющего на корректность, у реплики нет — только счётчики метрик, они не являются источником истины.

Что перенесено из lab2 и что изменено. Из lab2 без изменений: регистрация с Argon2id, Basic→Bearer-сессии в общем Redis, чаты, keyset-пагинация (created_at, id), версионированный кэш истории с lock'ом на страницу, X-Request-Id, /health/live, /health/ready, /internal/metrics, ограниченные 503 при отказе зависимостей, миграции отдельным сервисом. Изменено: (1) X-Instance-Id больше не случайный UUID, а INSTANCE_ID/hostname — по нему реплика сопоставляется контейнеру; он же ставится в ответах об ошибках, которые формируются фильтром раньше интерсептора; (2) появилась проба LB /internal/lb-check, не зависящая от БД и Redis; (3) добавлена общая идемпотентность отправки сообщения (таблица idempotency_keys, миграция 003); (4) порядок остановки по SIGTERM вынесен в main.ts: дрейн → закрытие сервера и пулов (стандартный порядок Nest закрывает пулы раньше дрейна); (5) транзиентные коды PostgreSQL (57014, 40001, 40P01) отдаются как 503 unavailable, чтобы клиент мог безопасно повторить запрос с тем же ключом; (6) metrics отдаёт instance_id и build_id. Деление суммарного бюджета API на реплики выполняет харнесс (render_stand_env в scripts/lab3/lab3.py): он пишет .env.stand с готовыми API_CPUS_PER_REPLICA/API_MEMORY_PER_REPLICA, которые читает compose.yaml; при ручном docker compose up правка API_TOTAL_* в .env ни на что не влияет — задавайте лимиты на реплику напрямую.

Идемпотентность. Ключ обязателен, область — пользователь + метод + путь чата

  • ключ; заявка и тело ответа записываются одной транзакцией, повтор возвращает сохранённый ответ, другое тело — 409, отсутствие/неверный ключ — 400, просроченные записи (> IDEMPOTENCY_TTL_SECONDS, по умолчанию 24 ч) удаляются фоновым проходом под advisory-локом и вручную (npm run idempotency:gc). Семантика и ветки описаны в app/README.md.

Соответствие .env.example ↔ фактическая конфигурация. Приложение читает APP_*, SESSION_TTL_SECONDS, DATABASE_*, REDIS_URL, CACHE_*, METRICS_TOKEN, DRAIN_DELAY_MS, INSTANCE_ID, IDEMPOTENCY_TTL_SECONDS (app/src/config/app-config.schema.ts); стенд читает API_TOTAL_CPUS, API_TOTAL_MEMORY_MB (делятся на API_REPLICAS → API_CPUS_PER_REPLICA / API_MEMORY_PER_REPLICA), PG_*, REDIS_*, LB_*, LOADGEN_*, API_IMAGE, BUILD_ID, APP_PUBLIC_PORT, LB_STATS_PORT, POSTGRES_PUBLISHED_PORT, REDIS_PUBLISHED_PORT, POSTGRES_DB/USER/PASSWORD. Из скелетного .env.example удалены неиспользуемые SESSION_STORE и CACHE_URL_FILE: в lab3 источник сессий один (Redis по REDIS_URL), выбор хранилища сессий больше не конфигурируется, а секреты передаются через DATABASE_URL/REDIS_URL или *_FILE (docker secrets). Публикуются только 8080 (LB), 127.0.0.1:8404 (статистика LB) и loopback-порты PostgreSQL/Redis — исключительно для операторских проверок с хоста (make test-e2e, psql); у реплик API портов нет, container_name не задан нигде (evidence/level4/limits-and-ports.txt).

Доказательства критериев

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab3 public API scenario (через LB; повтор с тем же ключом → тот же JSON, другое тело → 409, без ключа → 400) evidence/level3/smoke.txt
≥2 реплики, одна точка входа, разные реплики с одной сессией python3 scripts/lab3/lab3.py check spread --requests 40 40 запросов с одним токеном → 2 разных X-Instance-Id (20/20), каждый сопоставлен контейнеру evidence/level4/spread.json
Остановка любой одной реплики; записи продолжаются make test-failover ACTION_SCRIPT=scripts/stop-one.sh (по разу на реплику) observed_instances_before=2, 130 успешных записей во время отказа, 0 потерянных подтверждений, first_recovery_seconds≈3.3, остановленный контейнер виден в docker ps до/после, HAProxy помечает слот DOWN (L7STS) через ≈1 s evidence/level3/failover-mtusi-lab3-api-1.txt, …-api-2.txt
Сохранность данных и сессии при рестарте make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS; перезапущены postgres, redis, api ×2, haproxy (StartedAt до/после), токен и подтверждённые сообщения живы evidence/level3/persistence.txt
Идемпотентность, в том числе конкурентная python3 scripts/lab3/lab3.py check idempotency 4/4 теста: неверный/отсутствующий ключ → 400; повтор → тот же JSON; другое тело → 409; 8 параллельных POST с одним ключом → ровно одно сообщение; ключ не конфликтует между пользователями и чатами evidence/level4/idempotency-concurrency.txt
Health/readiness, LB исключает недоступный backend python3 scripts/lab3/lab3.py watch во время failover HAProxy: apiN UP → UP 1/2 (L7STS) → DOWN → MAINT (resolution); период проверки 500 ms, fall 2 ⇒ обнаружение 1–2 s (api-1 — 1 s, api-2 — 2 s) ≪ дрейн 3 s evidence/level3/failover-*.txt
Последовательная остановка каждой реплики под нагрузкой: RPS, ошибки, восстановление python3 scripts/lab3/lab3.py failover --replicas all --rate 200 --duration 60 по каждой реплике: 0 ошибок у клиента и 0 ошибок уровня LB (ereq/dresp), 0 дублей и 0 потерь, реплика возвращается за ≈3 s; k6 держит 200 req/s без dropped. Оговорка: ereq — это ошибки обработки запроса балансировщиком, они не считают ответы 5xx приложения; чтобы такие ответы были видны, сэмплер теперь пишет hrsp_2xx/4xx/5xx и dresp по каждому слоту, а профиль k6 — классы ответов по каждому шагу (summary-mechanism.md) evidence/level4/failover-sweep.json, .md
Лимиты CPU/RAM, отсутствие портов API, отсутствие container_name, секреты docker inspect, docker compose ps/config у api NanoCpus/Memory = лимитам конфигурации, bindings=map[]; суммарные лимиты стенда 2304 MiB; container_name отсутствует; пароль БД и токен метрик в трекаемых файлах не встречаются evidence/level4/limits-and-ports.txt
Rolling update под нагрузкой, миграции однократно (совместимость DDL с работающей версией — ограничение в разделе «Ограничения») python3 scripts/lab3/lab3.py rolling-update --under-load --rate 200 --build-id … реплики заменяются по одной, BUILD_ID и image id меняются, 0 ответов 5xx из 889 попыток, migrate не перезапускался evidence/level4/rolling-update.json, .md
Идемпотентность: удаление просроченных ключей docker compose --env-file .env exec -T api node dist/messages/idempotency/idempotency-gc.cli.js (или npm run idempotency:gc) GC удаляет ровно просроченную запись (created_at = now() − 2 суток): Purged 1, expired_left=0, свежая запись не тронута (fresh_left=1) evidence/level4/idempotency-gc.txt
Отказы зависимостей make test-dependencies 2/2: bounded 503 unavailable с request_id для Redis и PostgreSQL, запрос без сессии остаётся 401, после возврата зависимости данные и сессия целы evidence/level4/dependency-faults.txt
Трек 1: цена масштабирования python3 scripts/lab3/lab3.py sweep/growth/ab/analyze серия 1/2/4 реплики, точки сатурации, серия роста ресурсов, подтверждённое улучшение evidence/track1/summary-*.md, evidence/track1/graphs/*.png, evidence/track1/raw/
Воспроизводимость с чистого clone git clone -b lab3 … /tmp/lab3-clean → cp .env.example .env → docker compose down -v → make stand-up && make test && make test-persistence && make test-failover PASS: миграции применяются с пустого тома, smoke, сохранность и отказ реплики проходят без правок репозитория evidence/level3/clean-clone.txt

Эксперименты и отказы

Гипотезы (зафиксированы до прогонов)

  • H1. При фиксированном суммарном бюджете API (3.0 CPU / 1.5 GiB) пропускная способность растёт с числом реплик сублинейно и упирается в общий PostgreSQL (1.5 CPU): серия A показывает knee, серия роста ресурсов подтверждает, что именно БД, а не API, является ограничителем.
  • H2. Запись в один «горячий» чат сериализуется на строке chats (UPDATE chats SET message_version = message_version + 1 держит блокировку до COMMIT — это якорь инвалидации кэша), поэтому добавление реплик в этом профиле не помогает: p-b упирается раньше p-a и не растёт с N.
  • H3. Балансировщик (0.25 CPU) ограничивает путь чтения: два диагностических прогона p-c при LB_CPUS=0.25 и LB_CPUS=1.0 показывают, что потолок сдвигается вверх вместе с лимитом LB.
  • H4. Число соединений с БД растёт как N × DATABASE_POOL_MAX, поэтому размер пула влияет на потолок и на ожидания в БД (свип пула 5/10/20).
  • H5 (улучшение). Сокращение пути записи с 8 SQL-обращений (проверка чата, BEGIN, claim, проверка членства, INSERT, UPDATE версии, store, COMMIT) до одного оператора уменьшает время удержания блокировки строки чата и число round trip'ов и поднимает потолок при тех же лимитах. Проверяется A/B по правилу «медиана ≥5 % и диапазоны min/max повторов не перекрываются».

Методика

Метрики снимаются генератором k6 (constant-arrival-rate, плоские полки) и сэмплером харнесса: docker stats (CPU/RAM контейнеров, 1.5 s), статистика HAProxy (0.5 s), /internal/metrics каждой реплики (2 s), pg_stat_database/pg_stat_activity/pg_stat_statements (2 s / 10 s) и фон хоста. Профили: p-a (spread, POST) 100…1100 req/s, p-b (hot, один чат) 50…400 req/s, p-c (read, GET истории limit=50) 200…3000 req/s; шаг 15 s, прогрев — отдельный прогон 30 s на первом темпе (в анализ не входит). Перед серией посторонние контейнеры хоста останавливаются (scripts/quiesce.sh, состояние фиксируется в манифестах), после — возвращаются. Конфигурации интерливятся по повторам, чтобы дрейф частот и фоновой нагрузки ложился на все точки одинаково.

Бюджет серии одинаков для всех конфигураций: API total 3.0 CPU / 1536 MiB (⇒ 3/N CPU и 1536/N MiB на реплику), PostgreSQL 1.5 CPU / 512 MiB, Redis 0.25 CPU / 128 MiB, HAProxy 0.25 CPU / 128 MiB, генератор 1.5 CPU / 256 MiB. Суммарный лимит RAM стенда — 2304 MiB постоянно (бюджет API 1536 MiB делится между репликами, PostgreSQL 512, Redis 128, LB 128); запущенный генератор добавляет 256 MiB, host на момент серии — 8 логических CPU, ≈6.6 GiB доступной памяти, background остановлен.

Серия A: 1 / 2 / 4 реплики

Бюджет серии одинаков для всех конфигураций (API total 3.0 CPU / 1536 MiB, PostgreSQL 1.5 CPU, LB 0.25 CPU, генератор 1.5 CPU), поэтому реплика получает 3/N CPU и 1536/N MiB. Профиль p-a (24 чата, POST), 7 прогонов: N=1 и N=4 по два повтора, N=2 — три.

темп, req/s N=1: достигнуто (2 повтора) N=2: достигнуто (3 повтора) N=4: достигнуто (2 повтора)
100 100 / 100 100 / 100 / 100 100 / 100
200 200 / 200 200 / 200 / 200 200 / 200
300 300 / 300 300 / 300 / 300 300 / 300
400 400 / 400 400 / 400 / 400 399 / 400
550 550 / 550 550 / 550 / 550 541 / 550
700 700 / 700 700 / 690 / 692 696 / 653
900 754 / 807 (p95 432 / 360 ms) 650 / 538 / 614 (p95 474 / 693 / 502 ms) 637 / 587 (p95 964 / 851 ms)
1100 761 / 680 (p95 360 / 515 ms) 532 / 578 / 590 (p95 604 / 609 / 566 ms) 610 / 567 (p95 866 / 992 ms)

Наблюдения:

  • Точка сатурации у всех конфигураций — между 700 и 900 req/s, но потолок не растёт с числом реплик: N=1 держит ≈750–800 req/s, N=2 ≈540–650, N=4 ≈570–640. При фиксированном суммарном CPU выигрыша от реплик нет, а лучший результат даёт одна реплика с полным бюджетом.
  • Общий PostgreSQL при этом насыщен во всех конфигурациях: его пиковый CPU 153–156 % при лимите 1.5 CPU (150 %), xact/s 1224–1443, ожидания блокировок до 16, hit ratio 0.95. То есть ограничитель один и тот же, и добавление API-реплик его не расширяет (H1 подтверждена).
  • Реплики добавляют собственную накладную нагрузку: при N=4 квота 0.75 CPU на реплику удерживает p95 в районе 850–990 ms там, где N=1 с квотой 3.0 CPU даёт 360–515 ms при большем достигнутом RPS. Это и есть «цена масштабирования»: сублинейный (здесь — отрицательный) эффект при неизменном бюджете.
  • Генератор в серии A загружен умеренно (средняя 26–31 % ядра, пики 45–123 % при квоте 150 %), но на верхних шагах упирается в свой пул VU (200, Insufficient VUs на 900/1100 req/s), поэтому приведённые потолки — нижние оценки; VU-своп ниже показывает, меняется ли вывод.

Оговорка к серии A (по замечаниям ревью)

Серия A снята на сборке C1 (путь записи из 8 обращений), на датасете, который рос от 0.3 до 1.5 млн сообщений, и с MAX_VUS=200 — на верхних шагах k6 упирался в пул VU. Поэтому её абсолютные значения — нижние оценки для той конфигурации, а сравнивать их с прогонами на сборке C2 и другом объёме данных нельзя. Что из серии A остаётся в силе: (а) форма кривой и knee (100–700 req/s держатся ровно, дальше рост прекращается), (б) PostgreSQL во всех конфигурациях у квоты при неполной загрузке API, (в) направление «N реплик при фиксированном бюджете не быстрее одной» — оно воспроизведено ниже на сборке C2 с достаточным пулом VU.

VU-своп: потолок сервера или потолок генератора?

Замечание ревью: во всех прогонах серии A на верхних шагах k6 упирался в свой пул VU (200, Insufficient VUs), поэтому «потолки» 754–807 / 538–650 / 587–637 req/s могли быть потолком генератора. Чистый VU-своп — одна и та же конфигурация (API 3.0 CPU всего, PG 1.5, пул 10, LB 0.25, генератор 1.5 CPU), меняется только MAX_VUS; лестница 700/900/1100 req/s, по одному прогону на точку:

MAX_VUS N=1: достигнуто при 900 / 1100 N=4: достигнуто при 900 / 1100
200 888 / 1059 862 / 911
900 885 / 1067 889 / 1009
2000 888 / 1074 887 / 972

Выводы:

  • Потолок не зависит от пула VU при N=1 (1059 → 1067 → 1074, разброс 1.4 %) — измеренные значения серверные, а не генератора; при N=4 пул VU даёт до +11 % (911 → 1009), то есть там часть разброса действительно была ограничением k6.
  • Порядок «одна реплика с полным бюджетом не хуже четырёх с четвертью» на текущей сборке сохраняется и при достаточном пуле VU: 1074 против 972–1009 при 1100 req/s.
  • Абсолютные числа несравнимы с серией A: та серия снята на сборке C1 (до оптимизации пути записи), на датасете 0.46–1.5 млн сообщений и с MAX_VUS=200; VU-своп и блоки ниже — на сборке C2, на меньшем датасете и с MAX_VUS≥900. Сравнивать корректно внутри одной серии/блока (это и сделано везде ниже), а направление эффекта (реплики при фиксированном бюджете не увеличивают пропускную способность) воспроизводится на обеих сборках.

Диагностика: горячий чат и путь чтения

Горячий чат (p-b, N=4, все записи в один чат). Потолок наступает раньше и падает: до 200 req/s достигнутый темп равен предложенному (p95 9–14 ms), на 250 — 189 req/s (p95 2.2 s), на 300–400 — 79–104 req/s при p95 3.3–4.3 s, генератор упирается в свои 200 VU, а сервер стоит в очереди за строкой чата. PostgreSQL в этом прогоне: 39 ожидающих блокировку сессий (в серии A пик 2–18 в зависимости от конфигурации и шага), 41 активная сессия, 356 xact/s (против 1224), hit ratio 0.85 (против 0.95), CPU БД 156 % (квота исчерпана), при этом API-реплики загружены на 29–40 % — они ждут блокировку, а не работают. Причина — якорь инвалидации кэша: UPDATE chats SET message_version = message_version + 1 в той же транзакции, что и вставка сообщения, сериализует всех писателей одного чата до COMMIT. Поэтому в профиле «один чат» добавление реплик не помогает вообще: H2 подтверждена, и именно этот профиль выбран для A/B улучшения.

Путь чтения (p-c, N=4, GET истории limit=50). Потолок ≈1300–1400 req/s, knee на 1500 req/s, p95 растёт с 24 ms (1000 req/s) до 241–379 ms. Два прогона с разным лимитом LB (LB_CPUS=0.25 и 1.0) дали одинаковый потолок (1419 против 1397 на 1500 req/s, 1268 против 1329 на 3000 req/s), а сам HAProxy за прогон использовал 8.3 % CPU в среднем и 13 % в пике, то есть около половины своей квоты 0.25 CPU: H3 отклонена — балансировщик в этом стенде не является ограничителем пути чтения. Оговорка ревью принята: прогоны p-c снимались с MAX_VUS=200 и на шагах ≥1500 req/s упирались в пул VU, поэтому равенство потолков при разных лимитах LB ограничено сверху потолком генератора, а вывод про LB опирается на его загрузку (≈половина квоты 0.25 CPU). Ограничителями оказались общие компоненты: CPU PostgreSQL 155 % (квота 150 %) и генератор, чей пик 144 % при квоте 1.5 CPU (контингенция плана: p-c#gen2.0 — повтор с поднятой квотой генератора).

Серия роста ресурсов

Каждая точка отличается от базовой конфигурации (N=4: API total 3.0 CPU — 0.75 CPU на реплику, PostgreSQL 1.5 CPU, пул 10, LB 0.25 CPU) ровно одним ресурсом; темп — 560 req/s (80 % от колена) и 900 req/s. Точки — одиночные прогоны по 60 s (кроме блока 900 ниже, где по два повтора): на разнице 2–15 % при разбросе ±5–8 % одиночные точки не доказывают предпочтение одного рычага, поэтому основной вывод о «почему» строится на блоках с повторами.

Оговорки по данным таблицы (по замечаниям ревью):

  • точка API ×2 при 560 req/s была переснята: первый прогон унаследовал от предыдущей серии LB_CPUS=1.0 (баг раннего харнесса — baseline не прибивался), поэтому в таблице стоит новое значение 559.0 / p95 8.8 при LB 0.25, как и у остальных точек; манифест нового прогона это подтверждает;
  • базовая строка «550 (лестница)» взята из серии A — другого времени, другого объёма данных и другой сборки, поэтому она приведена как ориентир, а не как строгий контроль; строгий контроль — блок 900/1500 ниже (одно время, интерливинг, повторы).
Точка темп, req/s достигнуто, req/s p95, ms dropped PG CPU пик, %
базовая 550 (лестница) 545.5 117 — 154
API ×2 (6.0 CPU) 560 559.0 8.8 63 151
PostgreSQL ×2 (3.0 CPU) 560 559.4 94 35 144
пул 5 (20 соединений) 560 559.3 98 45 145
пул 20 (80 соединений) 560 559.3 122 50 149
базовая (серия A) 900 (лестница) 611.8 908 — 156
API ×2 900 530.5 899 22 173 156
PostgreSQL ×2 900 597.7 921 18 142 151
API ×2 + PostgreSQL ×2 900 581.0 658 19 142 153
пул 5 900 521.4 1143 22 725 156
пул 20 900 572.1 712 19 676 154

Выводы:

  • При 80 % от колена ни один из проверенных ресурсов не является ограничителем: все точки держат 99.6–99.9 % предложенного темпа при p95 94–122 ms. Разница с базовой строкой объясняется разным предложенным темпом (550 в лестнице против 560 в фиксированном прогоне), а не эффектом ресурса.
  • За плато ни один рычаг не поднимает потолок: удвоение CPU API (530), CPU PostgreSQL (598), обоих сразу (581) и пула до 20 (572) остаются в диапазоне разброса базовой конфигурации 587..637, а p95 держится на 658–1143 ms. Система в этом режиме перегружена: генератор фиксирует 18–23 тыс. отброшенных итераций, а PostgreSQL во всех точках стоит у квоты (151–156 %).
  • H4 (пул) отклонена в проверенном диапазоне: 20/40/80 соединений (5/10/20 на реплику) не меняют ни потолок, ни p95 значимо.
  • Калибровочные прогоны p-a#n1-vu900 и p-a#n4-vu900 (900 VU, генератор 2.0 CPU) показывают, что измеренный потолок — серверный, а не потолок генератора: достигнуто 680 req/s при N=1 против 616 при N=4 при том же предложенном темпе 900. Порядок «одна реплика с полным бюджетом лучше четырёх с четвертью» сохраняется.

Почему рост реплик перестаёт помогать: разрез по времени выполнения

Замечание ревью: knee найден, LB и пул отклонены, но «почему» закрыто рассуждением. Ниже — измерение на одном темпе, в одном временном блоке, с интерливингом повторов и одинаковым пулом VU (900): конфигурации различаются только распределением ресурсов. Сэмплер в этих прогонах дополнительно пишет распределение ожиданий сессий PostgreSQL (wait_event_type:wait_event), дельты pg_stat_statements по операторам, коды ответов LB (hrsp_2xx..5xx, dresp) и классы ответов клиента (2xx/4xx/5xx); подробные таблицы — в evidence/track1/summary-mechanism.md.

Блок 900 req/s (2 повтора на конфигурацию, интерливинг). Все пять конфигураций держат 94.8–99.6 % предложенного темпа, 0 ответов 5xx:

конфигурация RPS медиана (min..max) p95, ms (min..max) лимиты
N=1 876.4 (863.0..889.9) 267..1121 3.0 CPU / 1536m одной реплике
N=4 893.0 (892.0..893.9) 240..339 4 × 0.75 CPU / 384m
N=4, API ×2 869.9 (853.1..886.7) 664..1223 4 × 1.5 CPU
N=4, PG ×2 894.1 (892.0..896.2) 171..312 PG 3.0 CPU
N=4, пул 20 889.7 (887.0..892.4) 388..594 80 соединений

Пропускная способность одинакова в пределах разброса повторов (у N=1 повторы дали 863 и 890, то есть ±1.5 %), а p95 гуляет от 171 до 1223 ms при одной и той же конфигурации: на этом темпе ни одна конфигурация не насыщена, поэтому блок — это отрицательный контроль. Он показывает, что перераспределение того же бюджета потолок не двигает, и что искать ограничитель нужно выше по темпу.

Блок 1500 req/s (за коленом, 2 повтора на конфигурацию, интерливинг). Здесь система насыщена: предложено 1500 req/s, достигнуто 821–854 при p95 1.4–1.6 s и 0 ответов 5xx. Все пять конфигураций дают один и тот же результат, и выделяется только «одна реплика с полным бюджетом»:

конфигурация RPS медиана (min..max) p95, ms Lock-ожиданий пик время горячего оператора, ms CPU API пик, % квоты CPU PG пик
N=1 852.7 1468 3 1.56 78 % от 3.0 156 % (квота 1.5 → упёрлась)
N=4 821.4 (788.8..854.0) 1479..1510 17 17.5 63 % от 3.0 157 %
N=4, API ×2 820.1 (812.1..828.2) 1398..1479 21 17.9 61 % от 6.0 155 %
N=4, PG ×2 823.6 (806.7..840.5) 1409..1597 20 17.7 66 % от 3.0 156 % (квота 3.0 → половина)
N=4, пул 20 839.2 (824.0..854.5) 1397..1534 20 17.3 54 % от 3.0 156 %

Что здесь видно:

  • Разделение бюджета делает работу дороже. Один и тот же составной оператор при той же достигнутой пропускной способности выполняется 1.56 ms на одной реплике и 17.3–17.9 ms на четырёх — разница целиком в ожидании строки: пик сессий в Lock:transactionid равен 3 против 16–21.
  • Ни один рычаг потолок не поднимает. Удвоение CPU API, CPU PostgreSQL и пула оставляет 820–839 req/s (одна реплика — 852.7). При этом PostgreSQL с квотой 3.0 CPU использует ≈1.56 ядра (156 %), то есть половину новой квоты: на квоте 1.5 он в неё упирается, но добавление ядер ничего не меняет — время уходит не на счёт, а на ожидание.
  • Ожидания общие для всех реплик: пики LWLock:WALWrite 18–21, Lock:transactionid 16–18, LWLock:BufferContent 9–15, IO:DataFileRead 3–6, IO:WALSync. Это очередь на запись/фиксацию WAL и на строку чата — общий последовательный ресурс, а не дефицит CPU у отдельной реплики.

Итог: «почему» закрыто измерением — потолок задаёт общий последовательный путь записи (строка чата + WAL), а не распределение бюджета между репликами; отсюда и статус H1/H2 «подтверждена», и отсутствие эффекта у всех рычагов роста.

Отдельно проверен балансировщик (последний вопрос к блоку 1500). HAProxy при квоте 0.25 CPU в этом блоке показывает пик 22–26 %, то есть стоит у своей квоты, поэтому к блоку добавлена пара прогонов, отличающихся только квотой LB: при LB_CPUS=1.0 HAProxy использует те же 25 % (≈0.25 ядра) и даёт 834.0 req/s (p95 1385 ms, время горячего оператора 17.6 ms), при LB_CPUS=0.25 — 818.8 req/s (p95 1389 ms, 18.3 ms). Разница внутри разброса блока (±4 %), то есть 0.25 ядра — это ровно столько, сколько нужно HAProxy на ≈850 req/s этого профиля, а не искусственное ограничение: четырёхкратная квота не меняет ни загрузку, ни результат. Это и есть прямой ответ на H3 на пути записи (в серии чтения p-c прогоны упирались в пул VU, поэтому там вывод опирался только на загрузку LB).

Колено на текущей сборке. Тот же профиль p-a, но лестница 900→2200 req/s (900 VU, генератор 1 GiB, knee#n1 / knee#n4): N=1 — 890 / 1106 / 1036 / 1004 / 991 req/s (p95 74 / 471 / 1285 / 1196 / 1248 ms), N=4 — 887 / 1055 / 903 / 929 / 965 req/s (p95 125 / 873 / 1420 / 1302 / 1235 ms). Колено сместилось с ≈700 req/s (серия A на сборке C1) до ≈1200 req/s, а за коленом пропускная способность снова перестаёт зависеть от числа реплик: одна реплика с полным бюджетом держит даже немного больше (991–1036 против 903–965). То есть вывод «реплики не поднимают потолок, пока путь записи упирается в общую строку» воспроизводится и на улучшенной сборке.

A/B улучшения

Профиль p-b (все записи в один чат), N=4; A — сборка из коммита C1 = e9cd28d (8 SQL-обращений на путь записи, явная транзакция), B — C2 = 5a5a8fe (один оператор). Прогоны интерливились: A,B,A,B,A,B — по три повтора на сторону; между сторонами менялся только образ API.

Бюджет серии (по манифестам прогонов, evidence/track1/raw/ab#*.manifest.json): API total 6.0 CPU на 4 реплики, PostgreSQL 3.0 CPU, пул 20, LB 0.25 CPU, генератор 2.0 CPU и 512 MiB (повторы 1–2) / 1024 MiB (повтор 3), MAX_VUS=1200; датасет 1.38–1.52 млн сообщений. Это не бюджет по умолчанию (3.0/1.5/пул 10): он унаследовался от последней точки серии роста, потому что ранняя версия cmd_ab переопределяла только образ и число реплик. Поэтому числа ab#* сравнимы внутри серии (обе стороны в идентичных условиях) и не сравнимы напрямую с p-b#n4 (потолок ≈200 req/s на бюджете по умолчанию). В харнессе это исправлено (cmd_ab прибивает бюджет явно, как cmd_growth, и печатает его в лог и в ab-verdict.json), а контрольная серия abdiag ниже повторяет сравнение на бюджете по умолчанию. Память генератора пришлось поднять с 512 MiB до 1 GiB: на стороне A очередь за строкой чата раздувает число одновременных запросов, и k6 убивался OOM (exit 137) — это зафиксировано в манифестах. Образ «до» собирается одной командой: make lab3-before-image (архив дерева e9cd28d + тот же Dockerfile, тег mtusi-messenger:lab3-before).

темп, req/s A: RPS (min..max) p95 A, ms B: RPS (min..max) p95 B, ms Δ, % вывод
50 50.0 (50.0..50.07) 9.5 50.07 (50.0..50.07) 7.9 +0.1 не подтверждено
100 100.07 (100.0..100.07) 9.4 100.0 (100.0..100.07) 6.7 −0.1 не подтверждено
150 150.07 (150.07..150.07) 10.1 150.07 (150.0..150.07) 7.1 0.0 не подтверждено
200 200.07 (200.07..200.07) 9.7 200.0 (198.93..200.07) 7.8 −0.0 не подтверждено
250 250.07 (250.07..250.07) 11.2 250.07 (250.0..250.07) 7.5 0.0 не подтверждено
300 257.8 (243.87..261.87) 5200.9 300.07 (300.07..300.07) 8.2 +16.4 подтверждено
350 188.33 (187.93..210.07) 10 991.9 348.6 (348.13..350.07) 29.3 +85.1 подтверждено
400 171.73 (167.07..226.73) 10 816.3 400.07 (399.93..400.07) 24.4 +133.0 подтверждено

Потолок: A ≈ 258 req/s, B ≥ 400 req/s (правило подтверждения: медиана меняется ≥5 % и диапазоны min/max повторов не перекрываются; ниже 300 req/s обе стороны работают без насыщения, поэтому различие там и не должно было проявиться).

Уровень SQL подтверждает механизм. Среднее время горячего оператора в pg_stat_statements при одном и том же предложенном темпе: у A UPDATE chats — 95.0 ms (это и есть ожидание строки чата; в тот же момент 38 сессий стояли в Lock:transactionid), у B составной оператор — 2.34–3.16 ms. Разница в 30–40 раз и есть цена «8 обращений + явная транзакция» против «одного оператора».

До насыщения обе версии одинаковы (различие ≤0.1 %): один оператор не меняет семантику, он меняет только время удержания блокировки строки чата и число круглых поездок. После насыщения разница радикальна: у A очередь за строкой чата даёт p95 5–11 секунд и падение пропускной способности до 172 req/s на 400 req/s предложенных, у B на 400 req/s p95 равен 24 ms, а отброшенных итераций 29 на 18 000. Это и есть подтверждённое улучшение трека 1: сокращение критической секции (вместо проверки чата, BEGIN, claim, проверки членства, INSERT, UPDATE версии, store и COMMIT — один оператор, который делает всё то же самое атомарно).

Расширенная лестница для стороны B (400, 500, 600, 800 req/s, прогрев 30 s) показывает новый потолок горячего чата: 400→400 (p95 65 ms), 500→495 (p95 276 ms), 600→559 (p95 1205 ms), 800→529 (p95 3113 ms), то есть ≈560–600 req/s против ≈258 req/s у A — рост более чем в 2 раза при том же бюджете ресурсов (evidence/track1/raw/p-b#after-ext.*).

Контрольная серия abdiag (бюджет по умолчанию, 3+3 повтора, 900 VU). Замечания ревью: у первой серии A/B бюджет был унаследован (6.0 CPU API, PG 3.0, пул 20, генератор 2.0), поэтому её числа несравнимы с p-b#n4; кроме того, «не 201» у стороны A не разобраны. Серия abdiag снимает оба: cmd_ab теперь прибивает бюджет явно и печатает его в лог и вердикт, прогоны шли на лимитах по умолчанию (API 3.0 CPU на 4 реплики, PG 1.5, пул 10, LB 0.25, генератор 1.5 CPU / 1 GiB), профиль тот же (p-b, горячий чат), и профиль k6 пишет классы ответов, а сэмплер — hrsp_*/dresp каждого backend-слота.

темп, req/s A: RPS (min..max) p95 A, ms 5xx A за 3 повтора B: RPS (min..max) p95 B, ms 5xx B Δ, % вывод
50 50.07 (50.07..50.07) 9.3 0 50.07 (50.07..50.07) 7.2 0 0.0 не подтверждено
100 100.07 (100.07..100.07) 7.9 0 100.07 (100.07..100.07) 6.6 0 0.0 не подтверждено
150 150.07 (150.07..150.07) 11.0 0 150.07 (150.07..150.07) 5.5 0 0.0 не подтверждено
200 200.07 (200.07..200.07) 9.2 0 200.07 (200.07..200.07) 6.6 0 0.0 не подтверждено
250 250.0 (249.2..250.07) 11.0 0 250.07 (250.07..250.07) 7.0 0 0.03 не подтверждено
300 231.5 (228.3..244.7) 7272.7 4 300.0 (299.4..300.07) 7.6 0 +29.6 подтверждено
350 108.5 (107.4..108.7) 12 121.9 894 349.8 (348.7..350.07) 21.8 0 +222.3 подтверждено
400 132.7 (131.9..148.5) 12 234.0 2813 398.7 (397.6..400.07) 59.7 0 +200.4 подтверждено

Потолок: A 250 req/s (249.2..250.07), B 398.7 req/s (397.6..400.07) — на бюджете по умолчанию разрыв ещё больше, чем в первой серии (там A доходил до 258 при удвоенных ресурсах). Разбор отказов: у A на 300/350/400 req/s клиент получил (суммарно по трём повторам) 4, 894 и 2813 ответов класса 5xx (все — 503 unavailable: срабатывает statement_timeout 5 s, код 57014 переводится фильтром в ограниченный 503, а не в 500), у B — ни одного 5xx и ни одного 4xx. То есть выигрыш C2 не только в пропускной способности: при том же бюджете версия C1 под затором на строке чата начинает отказывать, а C2 держит темп. Сводка и вердикт — evidence/track1/summary-ab-abdiag.md, ab-verdict-abdiag.json; классы ответов по каждому шагу — в evidence/track1/raw/abdiag#*.k6.json и в summary-mechanism.md.

Что именно изменилось в SQL — по снятым данным, а не по коду. Сэмплер пишет pg_stat_statements каждые 10 s, поэтому по прогонам A и B считаются дельта вызовов и времени по каждому оператору (evidence/track1/statement-deltas.md):

сторона оператор (начало) вызовов суммарно, ms среднее
A (C1) UPDATE chats SET message_version = … 18 629 1 773 086 95.2 ms
A (C1) SELECT … chats … (проверка чата) 18 629 73 121 3.9 ms
A (C1) INSERT INTO messages … 18 629 59 479 3.2 ms
B (C2) WITH claim AS (INSERT INTO idempotency_keys … 28 515 66 939 2.35 ms

У C1 три видимых оператора выполняются ровно по разу на запись (18 629 = число подтверждённых записей), и только они дают ≈102 ms SQL на запись, из которых 95 ms — ожидание в UPDATE chats под блокировкой строки чата; у C2 путь записи — один оператор со средним 2.35 ms, отдельных SELECT/INSERT/UPDATE в статистике нет (они вошли в составной оператор). Остальные обращения C1 (BEGIN, claim, проверка членства, store, COMMIT) в выборку top-10 по суммарному времени не попали — они дешевле перечисленных, поэтому «8 обращений» подтверждается кодом (diff 410e1ea→5a5a8fe) и структурой статистики, а измеримая разница — это 102 ms против 2.35 ms на запись. Ранняя формулировка этого абзаца ссылалась на существование отдельных SQL-метрик messages.* в /internal/metrics — таких счётчиков у C1 не было (это были имена prepared statements драйвера); формулировка исправлена по замечанию ревью.

Ответы стороны A, а не только их количество. На 350/400 req/s клиент A насчитал 2671 и 3485 ответов «не 201»; в первых прогонах коды не сохранялись (k6 писал только «не 201», сэмплер не читал hrsp_*). Теперь профиль k6 считает 2xx/4xx/5xx/other по каждому шагу, а сэмплер пишет hrsp_1xx..5xx и dresp каждого backend-слота; контрольные прогоны abdiag (тот же профиль, бюджет по умолчанию, 3+3 повтора) показывают распределение кодов (раздел ниже).

Воспроизводимость прогонов трека

Все серии воспроизводятся из репозитория (все параметры — в манифестах raw/*.manifest.json):

# базовая серия: 1/2/4 реплики, профиль p-a (7 прогонов)
python3 scripts/lab3/lab3.py track1 --reps 2            # серии A/B/C и рост ресурсов + analyze
# догоняющие серии (VU-своп, блоки «почему», контрольный A/B на бюджете по умолчанию)
python3 scripts/lab3/lab3.py track1-extras --part all --reps 2 --rate 1500 --max-vus 900 \
        --loadgen-memory 1024m --ab-reps 3
# отдельные блоки (если нужен только один)
python3 scripts/lab3/lab3.py track1-extras --part vuswap
python3 scripts/lab3/lab3.py track1-extras --part why --rate 900  --prefix block --max-vus 900 --loadgen-memory 1024m
python3 scripts/lab3/lab3.py track1-extras --part abdiag --ab-reps 3 --loadgen-memory 1024m
# колено на текущей сборке и точки роста
python3 scripts/lab3/lab3.py run --no-warmup --profile p-a --replicas 1 --ladder 900,1200,1500,1800,2200 \
        --label knee#n1 --max-vus 900 --loadgen-memory 1024m
python3 scripts/lab3/lab3.py growth --series pg --rate 900 --suffix=-900 --duration 60
# агрегаты и графики
python3 scripts/lab3/lab3.py analyze

Образ «до» для A/B собирается make lab3-before-image (дерево коммита C1 = e9cd28d плюс тот же Dockerfile), образ «после» — обычная сборка текущего дерева.

Таблица отказов

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
SIGTERM одной API-реплике (scripts/stop-one.sh, docker stop --time 10) LB исключает узел, клиент продолжает работать; подтверждённые записи целы HAProxy: UP → 1/2 → DOWN (L7STS) → MAINT (resolution) ≈1 s после начала остановки; k6 держит 200 req/s без dropped и ошибок; проба клиента: 0 ошибок, 0 дублей, 0 потерь (293/293 и 288/288 подтверждены); в окне остановки и дрейна (3.3–3.5 s) клиент держал ≈4.9–5.0 req/s и не получил ни одной ошибки реплика возвращается за ≈3 s (scripts/start-replica.sh); потерь нет
Рестарт всего стенда (scripts/restart.sh) данные и сессии сохраняются, повторный вход не нужен make test-persistence PASS; StartedAt всех контейнеровобновились, токен и сообщения живы ≈8 s до /health/ready; потерь нет
Rolling update под нагрузкой (замена реплик по одной) нет 5xx, миграции не перезапускаются 0 ответов 5xx из 889 попыток при 200 req/s; BUILD_ID меняется по шагам; migrate StartedAt не изменился замена реплики занимает 9.4–9.5 s (docker stop → rm → создание → healthy, измерено харнессом), стенд не теряет запросы
Отказ Redis (docker compose stop redis) ограниченный 503, без 500 и без утечки деталей драйвера; анонимный запрос остаётся 401 make test-dependencies PASS зависимость возвращается за ≈2 s, сессия сохраняется (AOF)
Отказ PostgreSQL (docker compose stop postgres) то же; после возврата данные целы PASS, подтверждённые сообщения и сессия на месте ≈6 s до /health/ready

Ограничения и следующие шаги

Что стенд выдерживает (проверено, evidence/level3 и evidence/level4):

  • Остановку любой одной API-реплики: LB исключает её за ≈1 s (проб 500 ms, fall 2), клиент продолжает работу без ошибок, дублей и потерь; окно дреина (3 s) длиннее обнаружения, поэтому начатые запросы успевают завершиться.
  • Рестарт всего стенда: данные PostgreSQL и сессии в Redis (AOF) сохраняются, повторный вход не нужен.
  • Rolling update: поочерёдная замена реплик под нагрузкой без ответов 5xx.
  • Отказ Redis и PostgreSQL: ограниченный 503 unavailable с request_id, без 500 и без деталей драйвера; анонимный запрос остаётся 401; после возврата зависимости подтверждённые данные и сессия целы.

Чего доказательство не покрывает: «миграции однократны» проверено (отдельный сервис migrate + service_completed_successfully, при rolling update контейнер миграций не перезапускался), но совместимость схемы с работающей версией — нет: rolling заменял сборки одного коммита, схема между ними не менялась. По устройству миграции аддитивны (CREATE TABLE IF NOT EXISTS, CREATE INDEX, DO $$ … EXCEPTION), а работающий код новых объектов не читает, поэтому старый процесс переживёт применение 003/004; но это аргумент от кода, а не изменение схемы под нагрузкой.

Что не выдерживает:

  • Отказ docker-хоста целиком: узел один (это трек 2).
  • Потерю единственного экземпляра PostgreSQL, Redis или балансировщика: они не реплицированы, у LB нет второго экземпляра — падение БД означает отказ записи и чтения истории, падение LB — потерю точки входа.
  • Потерю тома PostgreSQL: резервных копий в стенде нет.

Границы измерения:

  • Один хост (8 логических CPU, ≈6.6 GiB свободной памяти на момент серии). Конфигурации интерливятся по повторам, посторонние контейнеры остановлены (scripts/quiesce.sh), но разброс повторов на насыщении достигает ±5–8 % (в отчёте публикуются min/max). Поэтому однократные точки роста за плато не доказывают различия меньше этого разброса — это прямо отражено в выводах.
  • Путь чтения: генератор упирался в свой пул VU (200) на шагах ≥1500 req/s (Insufficient VUs), поэтому измеренный потолок 1300–1400 req/s — нижняя оценка; вопрос «кто ограничивает чтение» отдельным экспериментом не закрыт (LB проверен и отклонён как ограничитель).
  • Серверные перцентили берутся из /internal/metrics (буфер 4096 последних запросов на процесс), клиентские — из k6; при N реплик счётчики суммируются, а перцентили снимаются по репликам.
  • Redis работает с maxmemory 96mb и volatile-lru: при исчерпании памяти теоретически возможно вытеснение наименее используемой сессии (учебное упрощение); в измеренных профилях объём ключей на порядки меньше лимита.
  • Генератор нагрузки ограничен контейнером (CPU/RAM/VU). Из-за этого отдельно проведён VU-своп (одна конфигурация, меняется только MAX_VUS) и контрольные блоки с MAX_VUS=900; память генератора в них поднята до 1 GiB (при 256 MiB k6 убивался OOM на медленной стороне A — зафиксировано в журнале ядра и в манифестах).
  • Датасет растёт в течение сессии: к концу серии messages — 2.03 млн строк (525 MB), idempotency_keys — столько же строк и 1.5 GB (каждая итерация генератора пишет новый ключ). Контроль дрейфа: среднее время горячего оператора при одинаковом предложенном темпе 400 req/s за сессию не растёт (3.16 ms в 01:05 против 2.34 ms в 02:12), то есть различия между блоками не объясняются деградацией записи; внутри блока обе стороны/плеча измеряются в одном окне.
  • Серии сняты на разных сборках и объёмах данных: серия A и первая серия A/B — на сборке C1 (путь записи из 8 обращений) и датасете до 1.5 млн сообщений; VU-своп, блоки 900/1500, knee и abdiag — на сборке C2 и меньшем датасете. Абсолютные значения между этими группами несравнимы; все сравнения в отчёте делаются внутри одной серии/блока, а направление эффекта проверено на обеих сборках. Датасет монотонно растёт в течение серии (это видно в манифестах), поэтому конфигурации интерливятся по повторам.
  • Первая серия A/B шла на унаследованном бюджете (API 6.0 CPU, PG 3.0, пул 20, генератор 2.0); её числа сравнимы только внутри себя. Контрольная серия abdiag повторяет сравнение на бюджете по умолчанию — см. раздел «A/B улучшения».

Что подтверждено измерением: сокращение пути записи до одного оператора (коммит C2) поднимает потолок горячего чата с ≈258 до ≥400 req/s и снижает p95 с 5–11 s до 8–29 ms при том же бюджете ресурсов (A/B, 3+3 повтора, evidence/track1/summary-ab.md). Статус гипотез: H1 подтверждена в части «рост числа реплик при фиксированном бюджете не увеличивает пропускную способность» и не подтверждена в части «ограничитель — именно PostgreSQL» (удвоение только его CPU потолок не поднимает); H2 подтверждена (горячий чат: 39 ожидающих блокировку сессий, API-реплики простаивают); H3 отклонена с оговоркой (равенство потолков при 0.25 и 1.0 CPU ограничено пулом VU генератора; независимо — загрузка HAProxy ≈половина квоты 0.25 CPU); H4 отклонена в проверенном диапазоне (пул 5/10/20); H5 подтверждена A/B. Что подтверждено отдельным экспериментом (механизм): блок «почему» — один темп, одно временное окно, интерливинг повторов, одинаковый пул VU (900) — показал, что при том же суммарном бюджете перераспределение ресурсов (больше реплик, больше CPU API, больше CPU PostgreSQL, больше пула) не меняет ни потолок, ни классы ответов, а само разделение бюджета между репликами увеличивает среднее время горячего оператора с 1.56 до 17.3–17.9 ms и число ожидающих строку сессий с 3 до 16–21. Ожидания — LWLock:WALWrite (18–21), Lock:transactionid (16–18), LWLock:BufferContent (9–15) — общие для всех реплик. Остаётся гипотезой разделение вклада WAL/диска и строки чата внутри этого общего пути: чтобы их разъединить, PostgreSQL нужно вынести на отдельный узел (трек 2) или сменить диск.

Следующие шаги: (1) повторить серию A с ≥3 повторами и прогревом 60 s, чтобы различать эффекты меньше 8 %; (2) повторить путь чтения с большим пулом VU генератора; (3) вынести PostgreSQL и LB на отдельные узлы и проверить перенос (трек 2); (4) добавить бэкап тома PostgreSQL и проверку восстановления.