# Отчёт — лабораторная 3 - **Автор, группа:** Илья Тюнин; группа — БВТ2303 - **Целевая оценка:** 5 + трек 1 «Цена масштабирования» - **Commit/PR:** ветка `lab3`; коммиты: `e9cd28d` (идентичность реплики, LB-проверка, идемпотентность), `917ed1a` (стенд HAProxy + реплики, лимиты, хуки), `410e1ea` (харнесс экспериментов), `5a5a8fe` (оптимизация пути записи, C2), `2950b77` (evidence, этот отчёт, документация), `eabb1d2` (проверка из чистого clone), `06431d8`, `1802ca1`, `e38795d`, `b7cf7b2` (доказательства уровня 4 и серии трека 1: `abdiag`, блок «почему», колено, LB). PR — после пуша ветки в origin. - **Источники, библиотеки и помощь ИИ:** контракт `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. ```sh git clone 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-analytics # регрессия аналитики трека 1: оффлайн, без стенда ``` Проверки отказов и сохранности (требуют управления контейнерами): ```sh 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 (останавливают посторонние контейнеры хоста и возвращают их): ```sh 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` создаёт пустую схему и применяет миграции заново). ## Архитектура и решения ```text клиент ──► HAProxy :8080 ──► api-1 ─┐ (проба /health/ready) ├──► PostgreSQL (источник истины) api-2 ─┘ └──► Redis (сессии, кэш истории) api-N ``` | Роль | Service | Образ | Готовность | Тома/порты | | ------------- | ---------- | ------------------------------------ | ------------------------------------------------ | ----------------------------------- | | Балансировщик | `haproxy` | `haproxy:3.2-alpine` | проба backend `GET /health/ready`, `timeout check 500ms` | `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 — та же `/health/ready`**, что и healthcheck контейнера: реплика, потерявшая свой путь к общей БД или Redis, выходит из ротации, а не отвечает клиенту `503`, оставаясь в ней. Проверка PostgreSQL идёт по отдельному соединению (пул из одного клиента), а не из общего пула, поэтому занятый пул не делает реплику неготовой; весь ответ ограничен общим дедлайном `HEALTH_TIMEOUT_MS=400` (меньше `timeout check 500ms`); (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`, `HEALTH_TIMEOUT_MS` (бюджет пробы зависимостей в `/health/ready`), `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)` ≈1 s после того, как дреин сделал пробу `/health/ready` неуспешной; период проверки 500 ms, `fall 2` ⇒ обнаружение 1–2 s (api-1 — 1 s, api-2 — 2 s) ≪ дрейн 3 s. Ту же ручку использует контейнерный healthcheck. Под насыщением пула слоты остаются `UP` (e2e-тест; контрольный прогон 1500 req/s — `evidence/track1/summary-probe-check.md`) | `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.4–3.9 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 из 884 попыток, `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` | 4/4: (1) отказ Redis и (2) отказ PostgreSQL — реплика отвечает ограниченным `503 unavailable` с `request_id`, неготовыми становятся все реплики, HAProxy выводит их из ротации и отвечает своим `503`, запрос без сессии остаётся `401`; (3) локальный отказ БД у одной реплики — из ротации уходит только она, здоровая обслуживает 16/16 чтений; (4) насыщение пула (60 параллельных записей в заблокированный чат) — слоты остаются `UP`, все записи `201`; после возврата зависимости данные и сессия целы | `evidence/level4/dependency-faults.txt` | | Трек 1: цена масштабирования | `python3 scripts/lab3/lab3.py sweep/track1-extras/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) и фон хоста. Профиль k6 считает классы ответов по каждому шагу, а сводка публикует две частоты: **успешную** (`successful_rps`, ответы ожидаемого класса — рабочая величина) и **частоту ответов** (`attempted_rps`, все полученные ответы — диагностика); сатурация, потолок, Δ A/B и сравнение роста считаются только по успешной. Профили: 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: успешный RPS (2 повтора) | N=2: успешный RPS (3 повтора) | N=4: успешный RPS (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 подтверждена; блок 1500 ниже показывает прямым тестом, что потолок задаёт именно квота CPU PostgreSQL). - Реплики добавляют собственную накладную нагрузку: при 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-своп ниже показывает, что на текущем датасете тот же профиль даёт 946 → 1034 req/s (N=1) при 200 → 2000 VU: измеренный потолок базовой конфигурации — ≈1030 req/s. ### Ограничения серии 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: успешный RPS при 900 / 1100 | N=4: успешный RPS при 900 / 1100 | | --------- | ------------------------------ | ------------------------------ | | 200 | 892.3 / 946.1 | 890.5 / 927.2 | | 900 | 895.1 / 1009.9 | 893.2 / 953.1 | | 2000 | 893.1 / 1034.4 | 897.1 / 971.7 | Выводы: - **На 1100 req/s пул VU всё ещё ограничивает**: N=1 растёт 946 → 1010 → 1034 (+9 %), N=4 — 927 → 953 → 972 (+5 %). То есть «потолки» серии A (754–807) были занижены генератором, и на сегодняшнем датасете потолок базовой конфигурации — ≈1030 req/s (N=1) и ≈970 (N=4), а не 750–800. - **На 900 req/s пул VU не влияет** (890–897 при всех значениях) — колено лежит между 900 и 1100, что согласуется с блоком 1500 ниже. - Порядок «одна реплика с полным бюджетом не хуже четырёх с четвертью» сохраняется при каждом пуле VU: 1034 против 972 при 1100 req/s. - **Абсолютные числа несравнимы с серией A**: та серия снята на сборке C1 (до оптимизации пути записи) и с `MAX_VUS=200`; VU-своп, серия роста и блок 1500 — на сборке C2, с `MAX_VUS≥900` и на большем объёме данных. Сравнивать корректно внутри одной серии/блока (это и сделано везде), а направление эффекта (реплики при фиксированном бюджете не увеличивают пропускную способность) воспроизводится на обеих сборках. ### Диагностика: горячий чат и путь чтения **Горячий чат (p-b, N=4, все записи в один чат).** Потолок наступает раньше и падает: до 200 req/s успешный RPS равен предложенному (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–399 ms; HAProxy за прогон использует 8.3 % CPU в среднем и 13 % в пике, то есть около половины своей квоты 0.25 CPU: **H3 отклонена — балансировщик в этом стенде не является ограничителем пути чтения**. Ограничения этого пункта: прогоны снимались с `MAX_VUS=200`, поэтому на шагах ≥1500 req/s k6 упирался в пул VU и измеренный потолок 1300–1400 req/s — нижняя оценка; вывод про LB опирается на фактическую загрузку HAProxy, а не на сравнение квот (квота LB проверяется отдельно на пути записи, блок 1500 ниже). Ограничителями по фактическим наблюдениям были общие компоненты: CPU PostgreSQL 155 % (квота 150 %) и генератор, чей пик 144 % при квоте 1.5 CPU (контингенция плана: `p-c#gen2.0` — повтор с поднятой квотой генератора). ### Серия роста ресурсов Серия роста — блок `why#` на **1500 req/s** (за коленом): одно временное окно, один коммит (`6cced49`), `MAX_VUS=900`, генератор 1.5 CPU / 1 GiB. Контроль — `why#n4` (N=4: API total 3.0 CPU — 0.75 CPU на реплику, PostgreSQL 1.5 CPU, пул 10, LB 0.25 CPU). Каждая точка отличается от контроля одним ключом бюджета; сопоставимость проверена по манифестам прогонов (темп, профиль, режим, коммит, образ, параметры генератора и остальные ключи бюджета), фактические квоты сверены с `docker inspect`. Точки — одиночные прогоны: различия меньше ±8 % не интерпретируются. Таблица построена `analyse_growth` (`evidence/track1/summary-growth.md`, `growth.png`). | Точка | Что изменено | успешный RPS | Δ к контролю, % | p95, ms | 5xx | dropped | VU пик / бюджет | CPU API: пик реплики, % её квоты | CPU PG пик, % ядра | вывод | | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | | why#n4 | контроль N=4 | 943.02 | — | 1196 | 0 | 33 420 | 900 / 900 | 74 % от 0.75 | 152 | контроль | | why#n4-api6 | API ×2 (6.0 CPU) | 891.38 | −5.5 | 1363 | 0 | 36 519 | 900 / 900 | 48 % от 1.5 | 155 | в пределах разброса | | why#n4-pg3 | PostgreSQL ×2 (3.0 CPU) | **1480.45** | **+57.0** | **291** | 0 | 1 174 | 516 / 900 | 83 % от 0.75 | **261** | рычаг поднимает потолок | | why#n4-pool20 | пул 20 | 852.68 | −9.6 | 1321 | 0 | 38 839 | 900 / 900 | 75 % от 0.75 | 155 | ухудшает | | why#n4-lb1 | LB ×4 (1.0 CPU) | 922.25 | −2.2 | 1196 | 0 | 34 667 | 900 / 900 | 64 % от 0.75 | 153 | в пределах разброса | Пул 5 на этом темпе не снимался (`why#n4-pool5` в разделе «Вне сравнения» таблицы `summary-growth.md`); точек, исключённых проверкой сопоставимости, нет. Выводы — только из колонки «вывод»: - **PostgreSQL ×2 — единственный рычаг, поднимающий потолок**: +57.0 % (1480.45 из 1500 предложенных), p95 291 против 1196 ms, PostgreSQL использует 261 % ядра. - **API ×2 (−5.5 %) и LB ×4 (−2.2 %) — в пределах разброса**: пропускную способность не меняют. - **Пул 20 ухудшает** (−9.6 %, p95 1321 ms): больше соединений — больше конкуренции за строку чата (механизм — блок 1500 ниже: 55 ожидающих лок против 21). - **H4 (пул) отклонена в первоначальном виде**: рост пула не помогает, а за коленом измеримо вредит; уменьшение пула в серии не проверялось. ### Почему рост реплик перестаёт помогать: разрез по времени выполнения Ниже — измерение на одном темпе (1500 req/s), в одном временном окне, с одинаковым пулом VU (900): конфигурации различаются только распределением ресурсов, а каждая точка проверена по фактическим квотам (`docker inspect`). Сэмплер в этих прогонах дополнительно пишет распределение ожиданий сессий 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 повтора).** Блок из трёх конфигураций (N=1, N=4, N=4 + API ×2) держит 94.8–99.6 % предложенного темпа, 0 ответов 5xx, 887–894 req/s при p95 240–664 ms, то есть у колена ни одна из них не насыщена; N=4 (`block#n4`) — контроль только этого блока. Рычаги PG и пула проверяются в блоке 1500 (он же серия роста). Искать ограничитель нужно выше по темпу — это и делает блок 1500. **Блок 1500 req/s (по 1 прогону на конфигурацию, 900 VU, 0 ответов 5xx).** Здесь система насыщена, и ограничитель виден напрямую: | конфигурация | RPS | p95, ms | Lock-ожиданий пик | горячий оператор, ms | CPU API: пик реплики, % её квоты | CPU PG пик, % ядра | dropped / VU | | ------------ | ---------- | ------- | ----------------- | -------------------- | -------------------------------- | ------------------------------ | ------------ | | N=1 | 1035.4 | 1091 | 2 | **1.19** | 35 % от 3.0 | 151 | 27 877 / 900 | | N=4 | 943.0 | 1196 | 21 | 15.28 | 74 % от 0.75 | 152 | 33 420 / 900 | | N=4, API ×2 | 891.4 | 1363 | 19 | 16.41 | 48 % от 1.5 | 155 | 36 519 / 900 | | N=4, PG ×2 | **1480.5** | **291** | 17 | 5.55 | 83 % от 0.75 | **261 (квота 3.0 → 2.6 ядра)** | 1 174 / 516 | | N=4, пул 20 | 852.7 | 1321 | 55 | **52.8** | 75 % от 0.75 | 155 | 38 839 / 900 | | N=4, LB 1.0 | 922.3 | 1196 | 21 | 15.26 | 64 % от 0.75 | 153 | 34 667 / 900 | Что здесь видно: - **Ограничитель — CPU общего PostgreSQL.** Во всех конфигурациях, кроме PG ×2, PostgreSQL стоит у своей квоты 1.5 CPU (151–155 % ядра), а система держит ≈950–1030 req/s. Удвоение квоты PG снимает насыщение: 1480 из 1500 предложенных при p95 291 ms, PostgreSQL впервые реально потребляет ~2.6 ядра (261 %), а отброшенные итерации падают с 33–39 тыс. до 1.2 тыс. Это прямой тест рычага. - **CPU API — не ограничитель**: удвоение бюджета API ничего не даёт (891 против 943), при PG ×2 реплики доходят лишь до 83 % своей квоты. - **Пул 20 вредит**: 853 req/s, 55 ожидающих блокировку сессий и 52.8 ms на горячем операторе против 21 и 15.3 ms у базовой N=4 — больше соединений конкурируют за одну и ту же строку чата. - **Разделение бюджета делает работу дороже.** Один и тот же составной оператор выполняется за **1.19 ms на одной реплике и 15.3 ms на четырёх**; разница — в ожидании строки: пик `Lock:transactionid` 2 против 21. Порядок «одна реплика с полным бюджетом не хуже четырёх» сохраняется: 1035 против 943. - **Ожидания общие для всех реплик**: `LWLock:WALWrite` 17–20, `Lock:transactionid` 16–18, `LWLock:BufferContent` 5–9 — очередь на фиксацию WAL и на строку чата, а не дефицит CPU у отдельной реплики. - **Балансировщик не ограничитель, но его квота почти выбирается.** Проверено с фактическим применением квоты (`docker inspect`: 1.0 CPU): при 0.25 CPU HAProxy использует 0.21 ядра в среднем и 0.25 в пике (у квоты), при 1.0 CPU — 0.27 ядра, результат в пределах разброса (922 против 943; оба прогона упираются в 900 VU и в PG). То есть 0.25 ядра — это столько, сколько HAProxy нужно на ≈950 req/s этого профиля, а не искусственное ограничение. Итог: «почему» закрыто прямым измерением — на этом профиле потолок задаёт **CPU общего PostgreSQL** (и очередь на строку чата/WAL внутри него), а не распределение бюджета между репликами: удвоение квоты PG поднимает потолок с ≈950–1030 до 1480 req/s, тогда как удвоение CPU API, четырёхкратная квота LB и увеличение пула не дают ничего (пул 20 — вредит). **Балансировщик — не ограничитель, и его квота проверена отдельно.** Плечо `N=4, LB 1.0` (см. таблицу выше) отличается от базовой конфигурации только квотой LB, применённой фактически (`docker inspect`: 1.0 CPU). HAProxy использует 0.21–0.27 ядра, четырёхкратный лимит не меняет результат (922 против 943 в пределах разброса; оба прогона ограничены PG и пулом VU). В серии чтения `p-c` вывод про LB опирается на его загрузку: 8.3 % ядра в среднем, 13 % в пике при квоте 0.25. **Колено на текущей сборке.** Тот же профиль 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). То есть вывод «реплики не поднимают потолок, пока узкое место — общий PostgreSQL и очередь на строку чата» воспроизводится и на улучшенной сборке; он же объясняет, почему потолок сдвигает только удвоение квоты PG (блок 1500 выше), а не перераспределение бюджета API. ### 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), поэтому числа `ab#*` сравнимы **внутри серии** (обе стороны в идентичных условиях) и не сравнимы напрямую с `p-b#n4` (потолок ≈200 req/s на бюджете по умолчанию). `cmd_ab` фиксирует бюджет явно и печатает его в лог и в `ab-verdict.json`; контрольная серия `abdiag` ниже повторяет сравнение на лимитах по умолчанию. Память генератора — 1 GiB: на стороне A очередь за строкой чата раздувает число одновременных запросов, и при 512 MiB k6 убивался OOM (exit 137, зафиксировано в манифестах). Образ «до» собирается одной командой: `make lab3-before-image` (архив дерева `e9cd28d` + тот же Dockerfile, тег `mtusi-messenger:lab3-before`). | темп, req/s | A: успешный RPS (min..max) | A: ответов RPS | p95 A, ms | B: успешный RPS (min..max) | p95 B, ms | Δ успешных, % | вывод | | ----------- | -------------------------- | -------------- | ----------- | -------------------------- | --------- | ------------- | --------------- | | 50 | 50.0 (50.0..50.07) | 50.0 | 9.5 | 50.07 (50.0..50.07) | 7.9 | +0.1 | не подтверждено | | 100 | 100.07 (100.0..100.07) | 100.07 | 9.4 | 100.0 (100.0..100.07) | 6.7 | −0.1 | не подтверждено | | 150 | 150.07 (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) | 200.07 | 9.7 | 200.0 (198.93..200.07) | 7.8 | −0.0 | не подтверждено | | 250 | 250.07 (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) | 257.8 | **5200.9** | 300.07 (300.07..300.07) | 8.2 | **+16.4** | подтверждено | | 350 | 127.4 (98.8..182.07) | **188.33** | **10 991.9** | 348.6 (348.13..350.07) | 29.3 | **+173.6** | подтверждено | | 400 | 106.53 (102.27..124.4) | **171.73** | **10 816.3** | 400.07 (399.93..400.07) | 24.4 | **+275.6** | подтверждено | **Потолок: A ≈ 258 req/s, B ≥ 400 req/s** (правило подтверждения: медиана успешного RPS меняется ≥5 % и диапазоны min/max повторов не перекрываются; ниже 300 req/s обе стороны работают без насыщения, поэтому различие там и не должно было проявиться). Все числа таблицы — **успешные ответы** (`201`); колонка «ответов RPS» показывает, сколько запросов сторона A вообще довела до ответа: на 350/400 req/s это 188.33/171.73 при полезных 127.4/106.53 — разница и есть клиентские отказы (таблица ниже). **Уровень 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 секунд и падение успешной пропускной способности до 106.5 req/s на 400 req/s предложенных (при 171.7 доведённых до ответа — остальное отказы 503), у 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), поэтому её числа сравнимы только внутри себя; `abdiag` повторяет то же сравнение на лимитах по умолчанию (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) | A: ответов RPS | p95 A, ms | 5xx A за 3 повтора | B: успешный RPS (min..max) | p95 B, ms | 5xx B | Δ успешных, % | вывод | | ----------- | -------------------------- | -------------- | ------------ | ------------------ | -------------------------- | --------- | ----- | ------------- | --------------- | | 50 | 50.07 (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) | 100.07 | 7.9 | 0 | 100.07 (100.07..100.07) | 6.6 | 0 | 0.0 | не подтверждено | | 150 | 150.07 (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) | 200.07 | 9.2 | 0 | 200.07 (200.07..200.07) | 6.6 | 0 | 0.0 | не подтверждено | | 250 | 250.0 (249.2..250.07) | 250.0 | 11.0 | 0 | 250.07 (250.07..250.07) | 7.0 | 0 | 0.03 | не подтверждено | | 300 | 231.5 (228.3..244.5) | 231.5 | **7272.7** | 4 | 300.0 (299.4..300.07) | 7.6 | 0 | **+29.6** | подтверждено | | 350 | 86.7 (85.0..93.3) | **108.5** | **12 121.9** | 894 | 349.8 (348.7..350.07) | 21.8 | 0 | **+303.3** | подтверждено | | 400 | 68.3 (56.9..100.4) | **132.7** | **12 234.0** | 2813 | 398.7 (397.6..400.07) | 59.7 | 0 | **+484.0** | подтверждено | **Потолок: 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. Полезная работа стороны A при этом падает сильнее, чем частота ответов: на 400 req/s из 132.7 ответов в секунду успешны 68.3 (56.9–100.4 по повторам) — сравнение по частоте ответов показало бы +200 %, по выполненной работе — **+484 %**. То есть выигрыш 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 на запись. **Ответы стороны A, а не только их количество.** На 350/400 req/s клиент A насчитал 2671 и 3485 ответов «не 201» (в абсолюте за 3 повтора). Профиль k6 считает классы `2xx/4xx/5xx/other` по каждому шагу, а сэмплер пишет `hrsp_1xx..5xx` и `dresp` каждого backend-слота; в контрольной серии `abdiag` (тот же профиль, бюджет по умолчанию, 3+3 повтора) по ним видно, что все отказы стороны A — это `503 unavailable` (раздел ниже). Публикуемая пропускная способность сведена к **успешным** ответам: `summaryJson` пишет `successful_rps` (ответы ожидаемого класса) и `attempted_rps` (все ответы), а сатурация, потолок и Δ A/B считаются только по успешным; частота ответов остаётся отдельной диагностической колонкой. ### Воспроизводимость прогонов трека Параметры пула передаются API (объявлены в `environment`), лимиты PostgreSQL/HAProxy применяются пересозданием соответствующих сервисов, а фактическая конфигурация каждого прогона проверяется через `docker inspect` и пишется в манифест (`observed_stand`). Профиль p-c готовит по 50 сообщений на чат до начала нагрузки; активные VU фиксируются и на успешных ответах; CPU API в сводках — пик отдельной реплики в процентах её квоты; периодический подсчёт messages заменён оценкой `pg_class.reltuples`. **Корректность идемпотентности.** Удаление истёкшей записи условное: TTL проверяется в самом `DELETE`, поэтому параллельная реплика не может удалить свежую замену после устаревшего чтения. Покрыто targeted-тестами `app/src/messages/idempotency/idempotency.repository.spec.ts` и `app/src/messages/messages.service.spec.ts`. Все серии воспроизводятся из репозитория (все параметры — в манифестах `raw/*.manifest.json`): ```sh # базовая серия: 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 track1-extras --part why --loadgen-memory 1024m # блок 1500 req/s = серия роста python3 scripts/lab3/lab3.py run --label 'probecheck#n4#rep1' --profile p-a --peak 1500 --duration 60 \ --replicas 4 --api-total-cpus 3.0 --pg-cpus 1.5 --pool 10 --lb-cpus 0.25 \ --loadgen-cpus 1.5 --loadgen-memory 1024m --max-vus 900 --pre-vus 60 --no-warmup # агрегаты и графики 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 потерь (295/295 и 294/294 подтверждены); в окне остановки и дрейна (3.25–3.3 s) клиент держал ≈4.9–5.0 req/s и не получил ни одной ошибки | реплика возвращается за 3.4–3.9 s (`scripts/start-replica.sh`); потерь нет | | Рестарт всего стенда (`scripts/restart.sh`) | данные и сессии сохраняются, повторный вход не нужен | `make test-persistence` PASS; StartedAt всех контейнеровобновились, токен и сообщения живы | ≈8 s до `/health/ready`; потерь нет | | Rolling update под нагрузкой (замена реплик по одной) | нет 5xx, миграции не перезапускаются | 0 ответов 5xx из 884 попыток при 200 req/s; `BUILD_ID` меняется по шагам (`final-1b4aac7`); `migrate` StartedAt не изменился | замена реплики занимает 9.75–9.76 s (`docker stop` → `rm` → создание → healthy, измерено харнессом), стенд не теряет запросы | | Отказ Redis (`docker compose stop redis`) | реплики становятся неготовыми, LB исключает все backend, клиент не получает успешных ответов; анонимный запрос остаётся 401 | `make test-dependencies` PASS (4/4 теста); `/health/live` реплики `200`, `/health/ready` и бизнес-запросы — ограниченный `503 unavailable` с `request_id`, после дрейна всех слотов LB отвечает своим `503` | зависимость возвращается за ≈2 s, сессия сохраняется (AOF) | | Отказ PostgreSQL (`docker compose stop postgres`) | то же; после возврата данные целы | PASS, подтверждённые сообщения и сессия на месте | ≈6 s до `/health/ready` | | Локальный отказ PostgreSQL у одной реплики (reject в `pg_hba.conf` для её адреса + разрыв соединений) | из ротации уходит только затронутая реплика, здоровая продолжает обслуживать | выбранная реплика: `/health/ready=503` (ограниченное тело с `request_id`), её слот HAProxy `UP → UP 1/2 (L7STS) → DOWN`; здоровая: `200` и `UP`; 16 чтений через LB — все `200`, ни одно не обслужено выбранной репликой; время до `DOWN` — менее 3 s (проверяется e2e-тестом; 0.66 s при ручной проверке); до `DOWN` выбранная реплика ещё получает запросы и отвечает ограниченным `503` — это окно `fall 2`; после восстановления `pg_hba.conf` (в `finally`) реплика возвращается в ротацию и снова получает запросы | правило снимается в `finally`; потерь данных нет | ## Ограничения и следующие шаги **Что стенд выдерживает (проверено, 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`; после возврата зависимости подтверждённые данные и сессия целы. - Отказ общей зависимости для всех реплик: каждая становится неготовой, LB выводит их из ротации и отвечает **своим** `503` (без тела API и `request_id`) — это сознательный выбор в пользу честного «готовых узлов нет» вместо реплик в ротации, которые не могут обслужить запрос. `/health/live` при этом отвечает `200`, то есть процесс виден и отличим от «все backends мертвы». Локальный отказ зависимости у одной реплики (её адрес отвергается в `pg_hba.conf`) выводит из ротации только её: 16/16 чтений через LB обслужила здоровая реплика. Redis — обязательная зависимость готовности: Bearer-сессии хранятся только в Redis, без него аутентифицированный запрос невозможен; кэш истории деградирует на PostgreSQL, но это не спасает аутентификацию. **Чего доказательство не покрывает:** «миграции однократны» проверено (отдельный сервис `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` — 3.52 млн строк, `idempotency_keys` — столько же строк (каждая итерация генератора пишет новый ключ). Поэтому прогоны одной и той же конфигурации, снятые в разное время, не сравнимы напрямую, и внутри блока все конфигурации измеряются в одном временном окне с интерливингом повторов, чтобы различия относились к ресурсам, а не к дрейфу объёма данных. - **Серии сняты на разных сборках**: серия A и первая серия A/B — на сборке C1 (путь записи из 8 обращений); серия роста, VU-своп, `knee` и `abdiag` — на сборке C2. Абсолютные значения между группами несравнимы; все сравнения в отчёте делаются внутри одной серии/блока. - Первая серия A/B шла на унаследованном бюджете (API 6.0 CPU, PG 3.0, пул 20, генератор 2.0); её числа сравнимы только внутри себя. Контрольная серия `abdiag` повторяет сравнение на бюджете по умолчанию — см. раздел «A/B улучшения». - **Метрика трека 1 — успешный RPS.** `summaryJson` считает `successful_rps` (ответы ожидаемого класса) и `attempted_rps` (все ответы); сатурация, потолок, Δ A/B и сравнение роста используют только успешный RPS, иначе отказы под нагрузкой выглядят как выполненная работа (пример: `abdiag#A` на 400 req/s — 68.3 успешных против 132.7 полученных ответов в секунду). В сводках, снятых до введения полей, `successful_rps`/`attempted_rps` вычислены из счётчиков той же сводки (`status.ok`, `requests`, длительность ступени); новые прогоны пишут их сразу. Инвариант закреплён тестом `tests/test_lab3_analytics.py` (`make test-analytics`). - **Проба LB в сериях трека 1.** Серии трека 1 (A, p-b, p-c, VU-своп, knee, блоки block#/why#, ab, abdiag) сняты с пробой LB, проверявшей только процесс и флаг дреина (коммиты `e38795d`, `6cced49`). Текущая проба тоже не зависит от нагрузки (отдельное соединение, общий дедлайн). Контрольный прогон на `1b4aac7` при 1500 req/s: слоты всё время `UP`, 0 ответов 5xx, Δ −7.1 % к why#n4 (в пределах разброса ±8 %; в БД 3.63 млн сообщений против 2.64 млн у why#n4) — `evidence/track1/summary-probe-check.md`. Уровень 4 переснят на `1b4aac7`. **Что подтверждено измерением:** сокращение пути записи до одного оператора (коммит C2) поднимает потолок горячего чата с ≈258 до ≥400 req/s и снижает p95 с 5–11 s до 8–29 ms при том же бюджете ресурсов (A/B, 3+3 повтора, `evidence/track1/summary-ab.md`). Статус гипотез: - **H1 подтверждена**: (а) рост числа реплик при фиксированном бюджете не увеличивает пропускную способность (N=1 1035 против N=4 943 при 1500 req/s; 1034 против 972 в VU-свопе), и (б) ограничитель — именно PostgreSQL: удвоение его квоты поднимает потолок с ≈950–1030 до 1480 req/s при p95 291 ms. - **H2 подтверждена**: горячий чат — 39 ожидающих блокировку сессий, API-реплики простаивают (раздел «Диагностика»). - **H3 отклонена**: квота LB проверена фактически (0.25 и 1.0 CPU), HAProxy использует 0.21–0.27 ядра, результат не меняется (922 против 943 в пределах разброса). На пути чтения прогоны упирались в пул VU, поэтому там вывод опирается на загрузку HAProxy. - **H4 отклонена (в обратную сторону)**: рост пула не помогает, а вредит — пул 20 даёт 853 req/s, 55 ожидающих лок и 52.8 ms на горячем операторе против 943, 21 и 15.3 ms у базовой N=4. - **H5 подтверждена**: A/B (C1 против C2) — потолок горячего чата 258 → ≥400 req/s, p95 5–11 s → 8–29 ms; на 400 req/s сторона A обслуживала успешно 106.5 req/s из 171.7 полученных ответов, сторона B — 400.07. Контрольная серия `abdiag` на бюджете по умолчанию подтверждает разрыв (A 250, B 398.7 успешных req/s). **Что подтверждено отдельным экспериментом (механизм):** блок 1500 req/s (один темп, одно временное окно, одинаковый пул VU = 900) показывает, что удвоение CPU API не даёт ничего (891 против 943), четырёхкратная квота LB — тоже (922 против 943), пул 20 вредит (853), а удвоение CPU PostgreSQL снимает насыщение (1480 req/s, p95 291 ms). Разделение бюджета между репликами увеличивает среднее время горячего оператора с 1.19 до 15.3 ms и число ожидающих строку сессий с 2 до 21. Ожидания — `LWLock:WALWrite` (17–20), `Lock:transactionid` (16–18), `LWLock:BufferContent` (5–9) — общие для всех реплик, то есть узкое место — общий PostgreSQL. Остаётся гипотезой разделение вклада WAL/диска и строки чата внутри этого общего пути: чтобы их разъединить, PostgreSQL нужно вынести на отдельный узел (трек 2) или сменить диск. **Следующие шаги:** (1) повторить серию A с ≥3 повторами и прогревом 60 s, чтобы различать эффекты меньше 8 %; (2) повторить путь чтения с большим пулом VU генератора; (3) вынести PostgreSQL и LB на отдельные узлы и проверить перенос (трек 2); (4) добавить бэкап тома PostgreSQL и проверку восстановления.