Files
mtusi2026lab3/REPORT.md
T
2026-10-16 16:18:15 +03:00

673 lines
81 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Отчёт — лабораторная 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 <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)
```
Проверки отказов и сохранности (требуют управления контейнерами):
```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 ─┐
(проба /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 подтверждена; блок 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: достигнуто при 900 / 1100 | N=4: достигнуто при 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 достигнутый темп равен предложенному (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` — повтор с поднятой квотой
генератора).
### Серия роста ресурсов
Каждая точка отличается от базовой конфигурации (N=4: API total 3.0 CPU — 0.75 CPU на
реплику, PostgreSQL 1.5 CPU, пул 10, LB 0.25 CPU) **ровно одним** ресурсом. После
пересъёмки все приведённые точки измерены на одном темпе (900 req/s), в одном
временном окне и на одном датасете, по одному прогону на точку; базовая точка — из
блока 900 (2 повтора). Основной вывод о «почему» даёт блок 1500 ниже, где рычаг
действительно срабатывает.
Все точки серии измерены на темпе 900 req/s в одном временном окне, конфигурация
каждой применяется харнессом и сверяется с `docker inspect` — фактические квоты
CPU/RAM и размер пула записаны в манифест (`observed_stand`). Контрольная точка на
560 req/s (80 % колена, API ×2) держит предложенный темп (559.0 при p95 8.8 ms), как
и все конфигурации ниже колена (VU-своп: 698–700 при предложенных 700).
| Точка (все на 900 req/s) | достигнуто, req/s | p95, ms | dropped | CPU API: пик реплики, % её квоты | CPU PG пик, % ядра |
| --------------------------------- | ----------------- | ------- | ------- | -------------------------------- | ------------------ |
| базовая N=4 (block#n4, 2 повтора) | 893.0 | 290 | 0 | 72 % от 0.75 | 157 |
| API ×2 (6.0 CPU) | 884.8 | 605 | 913 | 42 % от 1.5 | 155 |
| PostgreSQL ×2 (3.0 CPU) | 897.0 | **33** | 180 | 81 % от 0.75 | 158 |
| API ×2 + PostgreSQL ×2 | 898.2 | 20 | 107 | 46 % от 1.5 | 171 |
| пул 5 (20 соединений) | 896.6 | **56** | 203 | 80 % от 0.75 | 149 |
| пул 20 (80 соединений) | 880.9 | 272 | 1150 | 74 % от 0.75 | 157 |
Выводы:
- **Около колена (900 req/s) ни один рычаг не меняет пропускную способность**:
881–898 req/s, разброс ±1 % — система близка к текущему потолку, но ещё держит
темп. Отличается хвост: у PG ×2 и пула 5 p95 падает до 20–56 ms против 240–605 ms
у остальных, то есть при том же темпе меньше очередь за строкой чата и за WAL.
- **Пул 20 — единственная точка, которая хуже базовой** и по пропускной способности
(881), и по p95 (272 ms при 1150 отброшенных итерациях): больше соединений —
больше конкуренции за строку чата.
- **H4 (пул) отклонена в первоначальном виде**: рост пула не помогает, а за коленом
измеримо вредит (см. блок 1500 ниже: 853 req/s, 55 ожидающих лок).
- Рычаг, который действительно поднимает потолок, — CPU общего PostgreSQL: ниже
показано +57 % от его удвоения.
### Почему рост реплик перестаёт помогать: разрез по времени выполнения
Ниже — измерение на одном темпе (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, то есть у колена ни одна из них не насыщена;
рычаги PG и пула на этом темпе проверены серией роста выше (там же и контрольный
N=4). Искать ограничитель нужно выше по темпу — это и делает блок 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) | 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),
поэтому её числа сравнимы только внутри себя; `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) | 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 на запись.
**Ответы стороны A, а не только их количество.** На 350/400 req/s клиент A насчитал
2671 и 3485 ответов «не 201». Профиль k6 считает классы `2xx/4xx/5xx/other` по
каждому шагу, а сэмплер пишет `hrsp_1xx..5xx` и `dresp` каждого backend-слота; в
контрольной серии `abdiag` (тот же профиль, бюджет по умолчанию, 3+3 повтора) по
ним видно, что все отказы стороны A — это `503 unavailable` (раздел ниже).
### Воспроизводимость прогонов трека
Параметры пула передаются 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 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` — 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 улучшения».
**Что подтверждено измерением:** сокращение пути записи до одного оператора (коммит 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; контрольная серия `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 и проверку восстановления.