Files
mtusi2026lab3/REPORT.md
T

671 lines
68 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
- **Автор, группа:** заполните перед сдачей
- **Целевая оценка:** 5 (уровни 3 и 4 целиком + трек 1 «Цена масштабирования»)
- **Commit/PR:** ветка `lab3`; коммиты: `e9cd28d` (идентичность реплики, LB-проверка,
идемпотентность), `917ed1a` (стенд HAProxy + реплики, лимиты, хуки), `410e1ea`
(харнесс экспериментов), `5a5a8fe` (оптимизация пути записи, C2), `2950b77`
(evidence, этот отчёт, документация, C5), `eabb1d2` (проверка из чистого clone),
`06431d8`, `1802ca1`, `e38795d` (доказательства уровня 4 и трека 1 на финальной
сборке, уточнение статуса гипотез), `b7cf7b2` (догоняющие серии трека 1 по
замечаниям ревью: `abdiag`, блок «почему», колено, LB) и этот коммит с
актуализацией списка хешей. PR — после пуша ветки в origin оператором (нужны его
credentials).
- **Источники, библиотеки и помощь ИИ:** контракт `contracts/openapi.json`,
`contracts/README.md`, `tests/README.md`, документация HAProxy 3.2, Docker
Compose, k6 0.54, докуменация NestJS/Fastify/pg/redis. Код и эксперименты
подготовлены с использованием ИИ-ассистента; все числа в отчёте получены
прогонами на описанном стенде и лежат в `evidence/`.
## Запуск из чистого clone
Версии: Docker 29.9.0, Docker Compose v5.6.0, Node.js 25.7.0, Python 3.14 (для
проверок и харнесса; публичные тесты требуют 3.9+), образы `postgres:16.4-alpine`,
`redis:7.4.2-alpine`, `haproxy:3.2-alpine`, `grafana/k6:0.54.0`,
`node:25.7.0-slim` (сборка API). Хост — Fedora, 8 логических CPU, 16 GiB RAM.
```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 подтверждена).
- Реплики добавляют собственную накладную нагрузку: при N=4 квота 0.75 CPU на
реплику удерживает p95 в районе 850–990 ms там, где N=1 с квотой 3.0 CPU даёт
360–515 ms при большем достигнутом RPS. Это и есть «цена масштабирования»:
сублинейный (здесь — отрицательный) эффект при неизменном бюджете.
- Генератор в серии A загружен умеренно (средняя 26–31 % ядра, пики 45–123 % при
квоте 150 %), но на верхних шагах упирается в свой пул VU (200, `Insufficient VUs`
на 900/1100 req/s), поэтому приведённые потолки — нижние оценки; VU-своп ниже
показывает, меняется ли вывод.
### Оговорка к серии A (по замечаниям ревью)
Серия A снята на **сборке C1** (путь записи из 8 обращений), на датасете, который
рос от 0.3 до 1.5 млн сообщений, и с `MAX_VUS=200` — на верхних шагах k6 упирался
в пул VU. Поэтому её абсолютные значения — нижние оценки для той конфигурации, а
сравнивать их с прогонами на сборке C2 и другом объёме данных нельзя. Что из
серии A остаётся в силе: (а) форма кривой и knee (100–700 req/s держатся ровно,
дальше рост прекращается), (б) PostgreSQL во всех конфигурациях у квоты при
неполной загрузке API, (в) направление «N реплик при фиксированном бюджете не
быстрее одной» — оно воспроизведено ниже на сборке C2 с достаточным пулом VU.
### VU-своп: потолок сервера или потолок генератора?
Замечание ревью: во всех прогонах серии A на верхних шагах k6 упирался в свой пул
VU (200, `Insufficient VUs`), поэтому «потолки» 754–807 / 538–650 / 587–637 req/s
могли быть потолком генератора. Чистый VU-своп — одна и та же конфигурация
(API 3.0 CPU всего, PG 1.5, пул 10, LB 0.25, генератор 1.5 CPU), меняется только
`MAX_VUS`; лестница 700/900/1100 req/s, по одному прогону на точку:
| `MAX_VUS` | N=1: достигнуто при 900 / 1100 | N=4: достигнуто при 900 / 1100 |
| --- | --- | --- |
| 200 | 888 / 1059 | 862 / 911 |
| 900 | 885 / 1067 | 889 / 1009 |
| 2000 | 888 / 1074 | 887 / 972 |
Выводы:
- **Потолок не зависит от пула VU** при N=1 (1059 → 1067 → 1074, разброс 1.4 %) —
измеренные значения серверные, а не генератора; при N=4 пул VU даёт до +11 %
(911 → 1009), то есть там часть разброса действительно была ограничением k6.
- Порядок «одна реплика с полным бюджетом не хуже четырёх с четвертью» на текущей
сборке сохраняется и при достаточном пуле VU: 1074 против 972–1009 при 1100 req/s.
- **Абсолютные числа несравнимы с серией A**: та серия снята на сборке C1 (до
оптимизации пути записи), на датасете 0.46–1.5 млн сообщений и с `MAX_VUS=200`;
VU-своп и блоки ниже — на сборке C2, на меньшем датасете и с `MAX_VUS≥900`.
Сравнивать корректно внутри одной серии/блока (это и сделано везде ниже), а
направление эффекта (реплики при фиксированном бюджете не увеличивают
пропускную способность) воспроизводится на обеих сборках.
### Диагностика: горячий чат и путь чтения
**Горячий чат (p-b, N=4, все записи в один чат).** Потолок наступает раньше и
падает: до 200 req/s достигнутый темп равен предложенному (p95 9–14 ms), на 250
— 189 req/s (p95 2.2 s), на 300–400 — 79–104 req/s при p95 3.3–4.3 s, генератор
упирается в свои 200 VU, а сервер стоит в очереди за строкой чата. PostgreSQL в
этом прогоне: 39 ожидающих блокировку сессий (в серии A пик 2–18 в зависимости от
конфигурации и шага),
41 активная сессия, 356 xact/s (против 1224), hit ratio 0.85 (против 0.95),
CPU БД 156 % (квота исчерпана), при этом API-реплики загружены на 29–40 % —
они ждут блокировку, а не работают. Причина — якорь инвалидации кэша:
`UPDATE chats SET message_version = message_version + 1` в той же транзакции,
что и вставка сообщения, сериализует всех писателей одного чата до COMMIT.
Поэтому в профиле «один чат» добавление реплик не помогает вообще: H2 подтверждена,
и именно этот профиль выбран для A/B улучшения.
**Путь чтения (p-c, N=4, GET истории limit=50).** Потолок ≈1300–1400 req/s,
knee на 1500 req/s, p95 растёт с 24 ms (1000 req/s) до 241–379 ms. Два прогона с
разным лимитом LB (`LB_CPUS=0.25` и `1.0`) дали одинаковый потолок (1419 против
1397 на 1500 req/s, 1268 против 1329 на 3000 req/s), а сам HAProxy за прогон
использовал 8.3 % CPU в среднем и 13 % в пике, то есть около половины своей
квоты 0.25 CPU: **H3 отклонена — балансировщик в этом стенде не является
ограничителем пути чтения**. Оговорка ревью принята: прогоны `p-c` снимались с
`MAX_VUS=200` и на шагах ≥1500 req/s упирались в пул VU, поэтому равенство
потолков при разных лимитах LB ограничено сверху потолком генератора, а вывод
про LB опирается на его загрузку (≈половина квоты 0.25 CPU). Ограничителями
оказались общие компоненты: CPU
PostgreSQL 155 % (квота 150 %) и генератор, чей пик 144 % при квоте 1.5 CPU
(контингенция плана: `p-c#gen2.0` — повтор с поднятой квотой генератора).
### Серия роста ресурсов
Каждая точка отличается от базовой конфигурации (N=4: API total 3.0 CPU — 0.75 CPU на
реплику, PostgreSQL 1.5 CPU, пул 10, LB 0.25 CPU) **ровно одним** ресурсом; темп —
560 req/s (80 % от колена) и 900 req/s. Точки — **одиночные прогоны по 60 s**
(кроме блока 900 ниже, где по два повтора): на разнице 2–15 % при разбросе ±5–8 %
одиночные точки не доказывают предпочтение одного рычага, поэтому основной вывод
о «почему» строится на блоках с повторами.
Оговорки по данным таблицы (по замечаниям ревью):
- точка `API ×2` при 560 req/s была **переснята**: первый прогон унаследовал от
предыдущей серии `LB_CPUS=1.0` (баг раннего харнесса — baseline не прибивался),
поэтому в таблице стоит новое значение `559.0 / p95 8.8` при LB 0.25, как и у
остальных точек; манифест нового прогона это подтверждает;
- базовая строка «550 (лестница)» взята из серии A — другого времени, другого
объёма данных и другой сборки, поэтому она приведена как ориентир, а не как
строгий контроль; строгий контроль — блок 900/1500 ниже (одно время, интерливинг,
повторы).
| Точка | темп, req/s | достигнуто, req/s | p95, ms | dropped | PG CPU пик, % |
| --- | --- | --- | --- | --- | --- |
| базовая | 550 (лестница) | 545.5 | 117 | — | 154 |
| API ×2 (6.0 CPU) | 560 | 559.0 | 8.8 | 63 | 151 |
| PostgreSQL ×2 (3.0 CPU) | 560 | 559.4 | 94 | 35 | 144 |
| пул 5 (20 соединений) | 560 | 559.3 | 98 | 45 | 145 |
| пул 20 (80 соединений) | 560 | 559.3 | 122 | 50 | 149 |
| базовая (серия A) | 900 (лестница) | 611.8 | 908 | — | 156 |
| API ×2 | 900 | 530.5 | 899 | 22 173 | 156 |
| PostgreSQL ×2 | 900 | 597.7 | 921 | 18 142 | 151 |
| API ×2 + PostgreSQL ×2 | 900 | 581.0 | 658 | 19 142 | 153 |
| пул 5 | 900 | 521.4 | 1143 | 22 725 | 156 |
| пул 20 | 900 | 572.1 | 712 | 19 676 | 154 |
Выводы:
- **При 80 % от колена ни один из проверенных ресурсов не является ограничителем**:
все точки держат 99.6–99.9 % предложенного темпа при p95 94–122 ms. Разница с
базовой строкой объясняется разным предложенным темпом (550 в лестнице против
560 в фиксированном прогоне), а не эффектом ресурса.
- **За плато ни один рычаг не поднимает потолок**: удвоение CPU API (530), CPU
PostgreSQL (598), обоих сразу (581) и пула до 20 (572) остаются в диапазоне
разброса базовой конфигурации 587..637, а p95 держится на 658–1143 ms. Система
в этом режиме перегружена: генератор фиксирует 18–23 тыс. отброшенных итераций,
а PostgreSQL во всех точках стоит у квоты (151–156 %).
- **H4 (пул) отклонена в проверенном диапазоне**: 20/40/80 соединений (5/10/20 на
реплику) не меняют ни потолок, ни p95 значимо.
- Калибровочные прогоны `p-a#n1-vu900` и `p-a#n4-vu900` (900 VU, генератор 2.0 CPU)
показывают, что измеренный потолок — серверный, а не потолок генератора:
достигнуто 680 req/s при N=1 против 616 при N=4 при том же предложенном темпе 900.
Порядок «одна реплика с полным бюджетом лучше четырёх с четвертью» сохраняется.
### Почему рост реплик перестаёт помогать: разрез по времени выполнения
Замечание ревью: knee найден, LB и пул отклонены, но «почему» закрыто
рассуждением. Ниже — измерение на одном темпе, в одном временном блоке, с
интерливингом повторов и одинаковым пулом VU (900): конфигурации различаются
только распределением ресурсов. Сэмплер в этих прогонах дополнительно пишет
распределение ожиданий сессий PostgreSQL (`wait_event_type:wait_event`), дельты
`pg_stat_statements` по операторам, коды ответов LB (`hrsp_2xx..5xx`, `dresp`) и
классы ответов клиента (2xx/4xx/5xx); подробные таблицы — в
`evidence/track1/summary-mechanism.md`.
**Блок 900 req/s (2 повтора на конфигурацию, интерливинг).** Все пять
конфигураций держат 94.8–99.6 % предложенного темпа, 0 ответов 5xx:
| конфигурация | RPS медиана (min..max) | p95, ms (min..max) | лимиты |
| --- | --- | --- | --- |
| N=1 | 876.4 (863.0..889.9) | 267..1121 | **3.0 CPU / 1536m** одной реплике |
| N=4 | 893.0 (892.0..893.9) | 240..339 | 4 × 0.75 CPU / 384m |
| N=4, API ×2 | 869.9 (853.1..886.7) | 664..1223 | 4 × 1.5 CPU |
| N=4, PG ×2 | 894.1 (892.0..896.2) | 171..312 | PG 3.0 CPU |
| N=4, пул 20 | 889.7 (887.0..892.4) | 388..594 | 80 соединений |
Пропускная способность одинакова в пределах разброса повторов (у N=1 повторы дали
863 и 890, то есть ±1.5 %), а p95 гуляет от 171 до 1223 ms при одной и той же
конфигурации: на этом темпе ни одна конфигурация не насыщена, поэтому блок — это
отрицательный контроль. Он показывает, что перераспределение того же бюджета
потолок не двигает, и что искать ограничитель нужно выше по темпу.
**Блок 1500 req/s (за коленом, 2 повтора на конфигурацию, интерливинг).** Здесь
система насыщена: предложено 1500 req/s, достигнуто 821–854 при p95 1.4–1.6 s и
0 ответов 5xx. Все пять конфигураций дают один и тот же результат, и выделяется
только «одна реплика с полным бюджетом»:
| конфигурация | RPS медиана (min..max) | p95, ms | Lock-ожиданий пик | время горячего оператора, ms | CPU API пик, % квоты | CPU PG пик |
| --- | --- | --- | --- | --- | --- | --- |
| N=1 | 852.7 | 1468 | 3 | **1.56** | 78 % от 3.0 | 156 % (квота 1.5 → упёрлась) |
| N=4 | 821.4 (788.8..854.0) | 1479..1510 | 17 | 17.5 | 63 % от 3.0 | 157 % |
| N=4, API ×2 | 820.1 (812.1..828.2) | 1398..1479 | 21 | 17.9 | 61 % от 6.0 | 155 % |
| N=4, PG ×2 | 823.6 (806.7..840.5) | 1409..1597 | 20 | 17.7 | 66 % от 3.0 | 156 % (квота 3.0 → половина) |
| N=4, пул 20 | 839.2 (824.0..854.5) | 1397..1534 | 20 | 17.3 | 54 % от 3.0 | 156 % |
Что здесь видно:
- **Разделение бюджета делает работу дороже.** Один и тот же составной оператор
при той же достигнутой пропускной способности выполняется **1.56 ms на одной
реплике и 17.3–17.9 ms на четырёх** — разница целиком в ожидании строки: пик
сессий в `Lock:transactionid` равен 3 против 16–21.
- **Ни один рычаг потолок не поднимает.** Удвоение CPU API, CPU PostgreSQL и пула
оставляет 820–839 req/s (одна реплика — 852.7). При этом PostgreSQL с квотой
3.0 CPU использует ≈1.56 ядра (156 %), то есть половину новой квоты: на квоте
1.5 он в неё упирается, но добавление ядер ничего не меняет — время уходит не на
счёт, а на ожидание.
- **Ожидания общие для всех реплик**: пики `LWLock:WALWrite` 18–21,
`Lock:transactionid` 16–18, `LWLock:BufferContent` 9–15, `IO:DataFileRead` 3–6,
`IO:WALSync`. Это очередь на запись/фиксацию WAL и на строку чата — общий
последовательный ресурс, а не дефицит CPU у отдельной реплики.
Итог: «почему» закрыто измерением — потолок задаёт общий последовательный путь
записи (строка чата + WAL), а не распределение бюджета между репликами; отсюда и
статус H1/H2 «подтверждена», и отсутствие эффекта у всех рычагов роста.
**Отдельно проверен балансировщик (последний вопрос к блоку 1500).** HAProxy при
квоте 0.25 CPU в этом блоке показывает пик 22–26 %, то есть стоит у своей квоты,
поэтому к блоку добавлена пара прогонов, отличающихся только квотой LB: при
`LB_CPUS=1.0` HAProxy использует **те же 25 %** (≈0.25 ядра) и даёт 834.0 req/s
(p95 1385 ms, время горячего оператора 17.6 ms), при `LB_CPUS=0.25` — 818.8 req/s
(p95 1389 ms, 18.3 ms). Разница внутри разброса блока (±4 %), то есть 0.25 ядра —
это ровно столько, сколько нужно HAProxy на ≈850 req/s этого профиля, а не
искусственное ограничение: четырёхкратная квота не меняет ни загрузку, ни
результат. Это и есть прямой ответ на H3 на пути записи (в серии чтения `p-c`
прогоны упирались в пул VU, поэтому там вывод опирался только на загрузку LB).
**Колено на текущей сборке.** Тот же профиль p-a, но лестница 900→2200 req/s
(900 VU, генератор 1 GiB, `knee#n1` / `knee#n4`): N=1 — 890 / 1106 / 1036 / 1004 /
991 req/s (p95 74 / 471 / 1285 / 1196 / 1248 ms), N=4 — 887 / 1055 / 903 / 929 /
965 req/s (p95 125 / 873 / 1420 / 1302 / 1235 ms). Колено сместилось с ≈700 req/s
(серия A на сборке C1) до ≈1200 req/s, а за коленом пропускная способность снова
перестаёт зависеть от числа реплик: одна реплика с полным бюджетом держит даже
немного больше (991–1036 против 903–965). То есть вывод «реплики не поднимают
потолок, пока путь записи упирается в общую строку» воспроизводится и на
улучшенной сборке.
### A/B улучшения
Профиль p-b (все записи в один чат), N=4; A — сборка из коммита **C1 = `e9cd28d`**
(8 SQL-обращений на путь записи, явная транзакция), B — **C2 = `5a5a8fe`** (один
оператор). Прогоны интерливились: A,B,A,B,A,B — по три повтора на сторону; между
сторонами менялся только образ API.
**Бюджет серии (по манифестам прогонов, `evidence/track1/raw/ab#*.manifest.json`):**
API total 6.0 CPU на 4 реплики, PostgreSQL 3.0 CPU, пул 20, LB 0.25 CPU, генератор
2.0 CPU и 512 MiB (повторы 1–2) / 1024 MiB (повтор 3), `MAX_VUS=1200`; датасет
1.38–1.52 млн сообщений. Это **не** бюджет по умолчанию (3.0/1.5/пул 10): он
унаследовался от последней точки серии роста, потому что ранняя версия `cmd_ab`
переопределяла только образ и число реплик. Поэтому числа `ab#*` сравнимы **внутри
серии** (обе стороны в идентичных условиях) и не сравнимы напрямую с `p-b#n4`
(потолок ≈200 req/s на бюджете по умолчанию). В харнессе это исправлено
(`cmd_ab` прибивает бюджет явно, как `cmd_growth`, и печатает его в лог и в
`ab-verdict.json`), а контрольная серия `abdiag` ниже повторяет сравнение
на бюджете по умолчанию. Память генератора пришлось поднять с 512 MiB до 1 GiB:
на стороне A очередь за строкой чата раздувает число одновременных запросов, и
k6 убивался OOM (exit 137) — это зафиксировано в манифестах. Образ «до»
собирается одной командой: `make lab3-before-image` (архив дерева `e9cd28d` +
тот же Dockerfile, тег `mtusi-messenger:lab3-before`).
| темп, req/s | A: RPS (min..max) | p95 A, ms | B: RPS (min..max) | p95 B, ms | Δ, % | вывод |
| --- | --- | --- | --- | --- | --- | --- |
| 50 | 50.0 (50.0..50.07) | 9.5 | 50.07 (50.0..50.07) | 7.9 | +0.1 | не подтверждено |
| 100 | 100.07 (100.0..100.07) | 9.4 | 100.0 (100.0..100.07) | 6.7 | −0.1 | не подтверждено |
| 150 | 150.07 (150.07..150.07) | 10.1 | 150.07 (150.0..150.07) | 7.1 | 0.0 | не подтверждено |
| 200 | 200.07 (200.07..200.07) | 9.7 | 200.0 (198.93..200.07) | 7.8 | −0.0 | не подтверждено |
| 250 | 250.07 (250.07..250.07) | 11.2 | 250.07 (250.0..250.07) | 7.5 | 0.0 | не подтверждено |
| 300 | 257.8 (243.87..261.87) | **5200.9** | 300.07 (300.07..300.07) | 8.2 | **+16.4** | подтверждено |
| 350 | 188.33 (187.93..210.07) | **10 991.9** | 348.6 (348.13..350.07) | 29.3 | **+85.1** | подтверждено |
| 400 | 171.73 (167.07..226.73) | **10 816.3** | 400.07 (399.93..400.07) | 24.4 | **+133.0** | подтверждено |
**Потолок: A ≈ 258 req/s, B ≥ 400 req/s** (правило подтверждения: медиана меняется
≥5 % и диапазоны min/max повторов не перекрываются; ниже 300 req/s обе стороны
работают без насыщения, поэтому различие там и не должно было проявиться).
**Уровень SQL подтверждает механизм.** Среднее время горячего оператора в
`pg_stat_statements` при одном и том же предложенном темпе: у A `UPDATE chats` —
**95.0 ms** (это и есть ожидание строки чата; в тот же момент 38 сессий стояли в
`Lock:transactionid`), у B составной оператор — **2.34–3.16 ms**. Разница в 30–40
раз и есть цена «8 обращений + явная транзакция» против «одного оператора».
До насыщения обе версии одинаковы (различие ≤0.1 %): один оператор не меняет
семантику, он меняет только время удержания блокировки строки чата и число круглых
поездок. После насыщения разница радикальна: у A очередь за строкой чата даёт p95
5–11 секунд и падение пропускной способности до 172 req/s на 400 req/s предложенных,
у B на 400 req/s p95 равен 24 ms, а отброшенных итераций 29 на 18 000. Это и есть
подтверждённое улучшение трека 1: сокращение критической секции (вместо проверки
чата, BEGIN, claim, проверки членства, INSERT, UPDATE версии, store и COMMIT —
один оператор, который делает всё то же самое атомарно).
Расширенная лестница для стороны B (400, 500, 600, 800 req/s, прогрев 30 s)
показывает новый потолок горячего чата: 400→400 (p95 65 ms), 500→495 (p95 276 ms),
600→559 (p95 1205 ms), 800→529 (p95 3113 ms), то есть **≈560–600 req/s против
≈258 req/s у A — рост более чем в 2 раза** при том же бюджете ресурсов
(`evidence/track1/raw/p-b#after-ext.*`).
**Контрольная серия `abdiag` (бюджет по умолчанию, 3+3 повтора, 900 VU).**
Замечания ревью: у первой серии A/B бюджет был унаследован (6.0 CPU API, PG 3.0,
пул 20, генератор 2.0), поэтому её числа несравнимы с `p-b#n4`; кроме того,
«не 201» у стороны A не разобраны. Серия `abdiag` снимает оба: `cmd_ab` теперь
прибивает бюджет явно и печатает его в лог и вердикт, прогоны шли на лимитах по
умолчанию (API 3.0 CPU на 4 реплики, PG 1.5, пул 10, LB 0.25, генератор 1.5 CPU /
1 GiB), профиль тот же (p-b, горячий чат), и профиль k6 пишет классы ответов,
а сэмплер — `hrsp_*`/`dresp` каждого backend-слота.
| темп, req/s | A: RPS (min..max) | p95 A, ms | 5xx A за 3 повтора | B: RPS (min..max) | p95 B, ms | 5xx B | Δ, % | вывод |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| 50 | 50.07 (50.07..50.07) | 9.3 | 0 | 50.07 (50.07..50.07) | 7.2 | 0 | 0.0 | не подтверждено |
| 100 | 100.07 (100.07..100.07) | 7.9 | 0 | 100.07 (100.07..100.07) | 6.6 | 0 | 0.0 | не подтверждено |
| 150 | 150.07 (150.07..150.07) | 11.0 | 0 | 150.07 (150.07..150.07) | 5.5 | 0 | 0.0 | не подтверждено |
| 200 | 200.07 (200.07..200.07) | 9.2 | 0 | 200.07 (200.07..200.07) | 6.6 | 0 | 0.0 | не подтверждено |
| 250 | 250.0 (249.2..250.07) | 11.0 | 0 | 250.07 (250.07..250.07) | 7.0 | 0 | 0.03 | не подтверждено |
| 300 | 231.5 (228.3..244.7) | **7272.7** | 4 | 300.0 (299.4..300.07) | 7.6 | 0 | **+29.6** | подтверждено |
| 350 | 108.5 (107.4..108.7) | **12 121.9** | 894 | 349.8 (348.7..350.07) | 21.8 | 0 | **+222.3** | подтверждено |
| 400 | 132.7 (131.9..148.5) | **12 234.0** | 2813 | 398.7 (397.6..400.07) | 59.7 | 0 | **+200.4** | подтверждено |
**Потолок: A 250 req/s (249.2..250.07), B 398.7 req/s (397.6..400.07)** — на бюджете
по умолчанию разрыв ещё больше, чем в первой серии (там A доходил до 258 при
удвоенных ресурсах). Разбор отказов: у A на 300/350/400 req/s клиент получил (суммарно по трём
повторам) 4, 894 и 2813 ответов класса 5xx (все — `503 unavailable`: срабатывает
`statement_timeout` 5 s, код `57014` переводится фильтром в ограниченный 503, а не
в 500), у B — ни одного 5xx и ни одного 4xx. То есть выигрыш C2 не только в
пропускной способности: при том же бюджете версия C1 под затором на строке чата
начинает отказывать, а C2 держит темп. Сводка и вердикт —
`evidence/track1/summary-ab-abdiag.md`, `ab-verdict-abdiag.json`; классы ответов
по каждому шагу — в `evidence/track1/raw/abdiag#*.k6.json` и в
`summary-mechanism.md`.
**Что именно изменилось в SQL — по снятым данным, а не по коду.** Сэмплер пишет
`pg_stat_statements` каждые 10 s, поэтому по прогонам A и B считаются дельта вызовов
и времени по каждому оператору (`evidence/track1/statement-deltas.md`):
| сторона | оператор (начало) | вызовов | суммарно, ms | среднее |
| --- | --- | --- | --- | --- |
| A (C1) | `UPDATE chats SET message_version = …` | 18 629 | 1 773 086 | **95.2 ms** |
| A (C1) | `SELECT … chats …` (проверка чата) | 18 629 | 73 121 | 3.9 ms |
| A (C1) | `INSERT INTO messages …` | 18 629 | 59 479 | 3.2 ms |
| B (C2) | `WITH claim AS (INSERT INTO idempotency_keys …` | 28 515 | 66 939 | **2.35 ms** |
У C1 три видимых оператора выполняются ровно по разу на запись (18 629 = число
подтверждённых записей), и только они дают **≈102 ms SQL на запись**, из которых
95 ms — ожидание в `UPDATE chats` под блокировкой строки чата; у C2 путь записи —
один оператор со средним **2.35 ms**, отдельных `SELECT`/`INSERT`/`UPDATE` в
статистике нет (они вошли в составной оператор). Остальные обращения C1 (BEGIN,
claim, проверка членства, store, COMMIT) в выборку top-10 по суммарному времени не
попали — они дешевле перечисленных, поэтому «8 обращений» подтверждается кодом
(diff `410e1ea`→`5a5a8fe`) и структурой статистики, а измеримая разница — это
102 ms против 2.35 ms на запись. Ранняя формулировка этого абзаца ссылалась на
существование отдельных SQL-метрик `messages.*` в `/internal/metrics` — таких
счётчиков у C1 не было (это были имена prepared statements драйвера); формулировка
исправлена по замечанию ревью.
**Ответы стороны A, а не только их количество.** На 350/400 req/s клиент A насчитал
2671 и 3485 ответов «не 201»; в первых прогонах коды не сохранялись (k6 писал только
«не 201», сэмплер не читал `hrsp_*`). Теперь профиль k6 считает `2xx/4xx/5xx/other`
по каждому шагу, а сэмплер пишет `hrsp_1xx..5xx` и `dresp` каждого backend-слота;
контрольные прогоны `abdiag` (тот же профиль, бюджет по умолчанию, 3+3 повтора)
показывают распределение кодов (раздел ниже).
### Воспроизводимость прогонов трека
Все серии воспроизводятся из репозитория (все параметры — в манифестах `raw/*.manifest.json`):
```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` — 2.03 млн строк
(525 MB), `idempotency_keys` — столько же строк и 1.5 GB (каждая итерация
генератора пишет новый ключ). Контроль дрейфа: среднее время горячего оператора
при одинаковом предложенном темпе 400 req/s за сессию не растёт (3.16 ms в
01:05 против 2.34 ms в 02:12), то есть различия между блоками не объясняются
деградацией записи; внутри блока обе стороны/плеча измеряются в одном окне.
- **Серии сняты на разных сборках и объёмах данных**: серия A и первая серия A/B —
на сборке C1 (путь записи из 8 обращений) и датасете до 1.5 млн сообщений;
VU-своп, блоки 900/1500, `knee` и `abdiag` — на сборке C2 и меньшем датасете.
Абсолютные значения между этими группами несравнимы; все сравнения в отчёте
делаются внутри одной серии/блока, а направление эффекта проверено на обеих
сборках. Датасет монотонно растёт в течение серии (это видно в манифестах),
поэтому конфигурации интерливятся по повторам.
- Первая серия A/B шла на унаследованном бюджете (API 6.0 CPU, PG 3.0, пул 20,
генератор 2.0); её числа сравнимы только внутри себя. Контрольная серия `abdiag`
повторяет сравнение на бюджете по умолчанию — см. раздел «A/B улучшения».
**Что подтверждено измерением:** сокращение пути записи до одного оператора (коммит C2) поднимает потолок горячего чата с ≈258 до ≥400 req/s и снижает p95 с 5–11 s до 8–29 ms при том же бюджете ресурсов (A/B, 3+3 повтора, `evidence/track1/summary-ab.md`). Статус гипотез: **H1** подтверждена в части «рост числа реплик при фиксированном бюджете не увеличивает пропускную способность» и не подтверждена в части «ограничитель — именно PostgreSQL» (удвоение только его CPU потолок не поднимает); **H2** подтверждена (горячий чат: 39 ожидающих блокировку сессий, API-реплики простаивают); **H3** отклонена с оговоркой (равенство потолков при 0.25 и 1.0 CPU ограничено пулом
VU генератора; независимо — загрузка HAProxy ≈половина квоты 0.25 CPU); **H4** отклонена в проверенном диапазоне (пул 5/10/20); **H5** подтверждена A/B.
**Что подтверждено отдельным экспериментом (механизм):** блок «почему» — один
темп, одно временное окно, интерливинг повторов, одинаковый пул VU (900) — показал,
что при том же суммарном бюджете перераспределение ресурсов (больше реплик, больше
CPU API, больше CPU PostgreSQL, больше пула) не меняет ни потолок, ни классы
ответов, а само разделение бюджета между репликами увеличивает среднее время
горячего оператора с 1.56 до 17.3–17.9 ms и число ожидающих строку сессий с 3 до
16–21. Ожидания — `LWLock:WALWrite` (18–21), `Lock:transactionid` (16–18),
`LWLock:BufferContent` (9–15) — общие для всех реплик. Остаётся гипотезой
разделение вклада WAL/диска и строки чата внутри этого общего пути: чтобы их
разъединить, PostgreSQL нужно вынести на отдельный узел (трек 2) или сменить диск.
**Следующие шаги:** (1) повторить серию A с ≥3 повторами и прогревом 60 s, чтобы
различать эффекты меньше 8 %; (2) повторить путь чтения с большим пулом VU
генератора; (3) вынести PostgreSQL и LB на отдельные узлы и проверить перенос
(трек 2); (4) добавить бэкап тома PostgreSQL и проверку восстановления.