Files
mtusi2026lab3/REPORT.md
T
ArtyomandClaude Opus 5.5 5a3e372b08 Name the load of each column in the placement control table
The CPU per request and the lock waiters of the placement control are
taken at 4560 rps; the header now says so instead of leaving the reader
to guess between the two offered rates.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
2026-10-30 04:47:39 +03:00

638 lines
98 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**; трек «5» — **трек 1 «Цена масштабирования»**
- Commit/PR: ветка `solution/bpi2303-kostylev`. Код приложения (`src/`, `compose.yaml`, `Dockerfile`, `infra/`,
хуки) последний раз менялся в `a59e3a3` — перенос исправлений лабы 2 после её ревью (цикл
`2026-10-30-carry-over-lab2-review-fixes`); до него `e924281` — удалён комментарий `# type: ignore`, `22f0e62` —
улучшение трека 1 (отправка сообщения одной командой SQL) и `107fbbb` — закрепление CPU для замеров (по умолчанию
выключено). После `22f0e62` менялись также `AGENTS.md`, `student-tests/`, обвязка (`Makefile`, последний раз —
`b1c80ee`, `scripts/`, `tools/`), openspec, отчёт и `evidence/`. **Все доказательства уровней «3» и «4»**
(`checks`, `smoke`, `stack`, `environment`, `schema`, `migrations`, `kdf`, `secrets`, `lb-check`, `hooks`,
`failover-*`, `persistence`, `faults`, `limits*`, `detection/`, `failover-each/`, `rolling*/`, `student-tests`)
сняты на итоговом коде `b1c80ee`, запуск из чистого clone — на `f5fea5c` (тот же код плюс эти доказательства),
контрольные прогоны трека — на том же коде; после `b1c80ee` менялись только openspec, отчёт и `evidence/`. Серии трека A и B сняты на
коде до улучшения (его они и обосновывают), сравнение до/после — на `edc091d` против `22f0e62`. Дата и коммит —
в первой строке каждого отчёта `evidence/*.txt`, для JSON, CSV и сырья прогонов — в индексе `evidence/README.md`. PR «ЛР 3 —
БПИ2303 — Костылев — на 5» в репозиторий преподавателя заполняется по `.github/pull_request_template.md`; его
ссылка появляется при публикации
- Использованные источники, библиотеки и помощь ИИ: FastAPI, gunicorn + uvicorn-worker, dishka, pydantic,
structlog, asyncpg, argon2-cffi, redis-py, pytest, ruff, ty (версии — `evidence/environment.txt` и `uv.lock`);
HAProxy 3.2 Configuration Manual (health checks, resolvers, `retry-on`, `http-error`, `init-state`), Grafana k6
(`constant-arrival-rate`, `handleSummary`), uvicorn и gunicorn (порядок graceful shutdown), документация Docker
Compose (`deploy.replicas`, `depends_on`, secrets), PostgreSQL (`SELECT … FOR UPDATE`, `INSERT … ON CONFLICT`,
уровни изоляции, `WITH` с изменяющими данные операторами, `pg_stat_activity` и `pg_stat_statements`), IETF draft
«The Idempotency-Key HTTP Header Field», N. Gunther — Universal Scalability Law. Решение перенесено из моей лабы 2 и
выполнено с помощью Claude Code; код, стенд и отказы проверены прогонами, перечисленными ниже.
## Запуск из чистого clone
Требуются Docker с Compose v2, `make` и `curl`; системный Python 3.9+ — только для публичных проверок и
`scripts/probe.py`. Образы сторонних сервисов закреплены версией и digest, API собирается из исходников.
```sh
git clone <repo> && cd mtusi2026lab3 && git checkout solution/bpi2303-kostylev
make secrets # secrets/*: пароли PostgreSQL и Valkey, DATABASE_URL, CACHE_URL, ключ курсора; .env из .env.example
docker compose --env-file .env config --quiet
make up # docker compose up -d --build --wait: postgres, valkey → migrate (миграции, один раз) → api ×2 → lb
until curl -fsS "http://$(docker compose port lb 8080)/health/ready"; do sleep 1; done # готовность через LB
scripts/lb-wait.sh 2 # обе реплики UP в статистике LB
make test # публичный smoke через балансировщик (BASE_URL — опубликованный порт lb, см. ниже)
make lb-check # ≥2 X-Instance-Id на одном токене и 20 × 8 параллельных POST с одним ключом → evidence/lb-check.json
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make restore # вернуть остановленную реплику и дождаться её в ротации LB
curl -s -o /dev/null "http://$(docker compose port lb 8080)/health/live" # сдвиг round robin: следующий прогон остановит другую реплику
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && make restore
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make migrate # повторный запуск миграций: «up to date», данные не меняются
make down # безопасная остановка: контейнеры и сети удаляются, volumes с данными остаются
make reset-data # НАМЕРЕННОЕ удаление учебных данных: docker compose down -v --remove-orphans
```
`make secrets` идемпотентен: существующие файлы не перезаписываются, значения нигде не печатаются; `make up`
вызывает его сам. `make up` ждёт `healthy` всех сервисов, включая балансировщик, а он здоров, только когда в
ротации есть реплика (`/healthz` на порту статистики). Миграции применяет одноразовый `migrate` под advisory lock
до старта реплик; реплики схему не трогают. Публикуются только порты `lb` на `127.0.0.1`: `LB_HTTP_PORT`
(по умолчанию 8080) и `LB_STATS_PORT` (8404, статистика только для чтения). На машине, где выполнялась работа,
параллельно работали стенды других лаб, поэтому в локальном `.env` стояли `LB_HTTP_PORT=18083`,
`LB_STATS_PORT=23083`. Цели `make` берут `BASE_URL` по умолчанию из `docker compose port lb 8080`, то есть
работают и с изменённым `LB_HTTP_PORT`; без поднятого стенда — `http://localhost:8080`, явный `BASE_URL=…`
переопределяет. Цель failover-теста выбирает round robin (реплика, обслужившая первое сообщение); второй
прогон сразу после первого попадает в ту же реплику, поэтому перед ним нужен один запрос через LB (строка
`curl …/health/live` выше или `make failover-evidence SHIFT=1`).
Последний прогон из свежего clone (`evidence/clean-clone.txt`, коммит `f5fea5c` — код `b1c80ee`, каталог `mtusi2026lab3-clean` —
свой compose-проект и пустые volumes, `LB_HTTP_PORT=18083`, команды дословно из блока выше, **без `BASE_URL`**):
`config` — `valid`; `make up` — 10 с, `migrate` применил `0001_init` и `0002_idempotency_keys` и вышел с кодом 0;
smoke `PASS`; 40 `GET` одним токеном — 20 + 20 на две реплики, 160 × `201` в гонках ключа; failover обеих реплик
по очереди (второй — после одного `GET` через LB) — 134 и 132 записи, 0 ошибок, первая запись через 2.934 и 2.736 с,
остановлены `api-1`, затем `api-2`, каждая `Exited (0)`; persistence `PASS`; повторный `migrate` — `up to date`;
`make storage-evidence` в клоне перечислил только volumes `mtusi2026lab3-clean_*`; после `make down` volumes
остались, после `make reset-data` их 0.
Собственные проверки и тулчейн:
```sh
make install # uv sync --group dev (Python 3.14 и зависимости из uv.lock)
make lint # ruff check + ruff format --check (src, student-tests, scripts/{probe,limits,scaling}.py, tools) + ty check
make student-test # собственные тесты; поднимают одноразовые PostgreSQL и Valkey того же образа в Docker
PYTEST_ADDOPTS=-vv make student-test # то же с именами тестов (так снят evidence/student-tests.txt)
make check # офлайн-проверка skeleton
make validate # полная валидация OpenAPI 3.1 и примеров (openapi-spec-validator из dev-группы .venv)
make test-faults # тесты стенда лабы 2 (Valkey, PostgreSQL, гонки) через балансировщик
make faults-evidence # то же с датой и коммитом → evidence/faults.txt (путь репозитория → <repo>)
make failover-evidence [SHIFT=1] # docker inspect реплик до/после, make test-failover, логи остановленной, restore
make persistence-evidence # persistence-тест + StartedAt всех контейнеров до и после
make stack-evidence # сервисы, порты, hostname ↔ X-Instance-Id, лимиты, сети, взгляд LB
make storage-evidence # \d+ схемы, повтор миграций, префикс KDF, правила ignore
```
Проверки уровня «4» — по одной команде на пункт рубрики; каждая пишет файл в `evidence/` и завершается
ненулевым кодом при нарушении (`make level4` — все подряд):
```sh
make limits # лимиты, порты, секреты, volumes, сети по политике → evidence/limits.txt
make lb-check # 40 GET одним токеном + 20 раундов × 8 параллельных POST с одним ключом
make detection # три прогона: SIGTERM, kill, pause, остановка PostgreSQL → evidence/detection/run{1,2,3}/
make failover-each # каждая реплика: остановка, 10 с без неё, возврат — под k6 100 rps
make rolling-update FROM_REV=8d28d45 # стенд на версии уровня «3», затем замена на текущую под нагрузкой
make rolling-update # замена текущей сборкой (эквивалентная поочерёдная замена)
```
Генератор нагрузки — сервис `k6` под профилем `bench` (с `make up` не стартует); `RATE` задаёт интенсивность.
Трек 1 «Цена масштабирования» — одна команда на всё и одна на графики. База очищается (`down -v`) перед каждой
конфигурацией, после серий стенд возвращается к обычной конфигурации. Для отчёта серия A шла 2 ч 11 мин (с
ожиданием тишины на VM), серия B — 34 мин, сравнение — 30 мин (по полю `started` в `summary.csv`):
```sh
make track1 # снимок хоста, серия A (1x4/2x2/4x1), серия B (1x1/2x1/8x1), до/после на 8x1, контроль, графики
make track1-control # контроль: пул и maxconn на 8x1 при 5 400 rps; 8x0.5 против 4x1 на CPU 7–10
make plots # только графики и сводка потолков из готовых evidence/track1/*/summary.csv
```
**Версии и стенд:** Python 3.14.7 в образе `python:3.14-slim-trixie@sha256:51dafde8…`,
`haproxy:3.2.26-alpine@sha256:58938405…`, `postgres:17.11-alpine@sha256:266d3c25…`,
`valkey/valkey:8.1.11-alpine@sha256:2602ace2…`, `grafana/k6:2.3.0@sha256:2dd4756e…`, uv 0.9.7 по digest,
Docker 28.3.2, Compose 2.38.2. Машина — Apple M4 Max, 16 CPU, 48 ГБ RAM, macOS 15.1; VM Docker Desktop —
16 CPU, 7.65 ГиБ (`evidence/environment.txt`).
## Архитектура и решения
```
┌── api (gunicorn, 2 × UvicornWorker) ──┐ asyncpg pool, 1–2 с
клиент ──HTTP──▶ lb (HAProxy 3.2) ───┤ X-Instance-Id = hostname ├──▶ postgres (источник истины, pgdata)
127.0.0.1:8080 round robin, └── api (gunicorn, 2 × UvicornWorker) ──┘──▶ valkey (кэш сессий, AOF, valkeydata)
httpchk /health/ready migrate (тот же образ, один раз до реплик) ──▶ postgres
сеть edge ─────── lb ─────── сеть backend (internal): lb, api, migrate, postgres, valkey
```
**Перенесено из лабы 2 без изменения поведения:** зоны `identity` и `messaging`, порты и адаптеры, UoW, шина
событий с журналом аудита, ASGI-конвейер, Basic → Bearer, Argon2id, сессии в PostgreSQL с read-through кэшем
в Valkey и отметками отзыва, подписанный курсор, порядок истории под блокировкой строки чата, миграции под
advisory lock, тесты стенда (`make test-faults`). Уже в лабе 2 реплика не держала в памяти ничего, от чего
зависит корректность: кэш и отметки отзыва общие (Valkey), курсор подписан общим секретом, отметка
`created_at` назначается под блокировкой строки чата, а не часами процесса. **Изменено:** один контейнер с
портом → сервис `api` с `deploy.replicas` за HAProxy; `X-Instance-Id`; обязательный `Idempotency-Key`;
миграция `0002`; `restart.sh` перезапускает и LB; таймауты и воркеры под реплики; удалён `api-shortttl`
(публиковал порт API в обход LB, проверка истечения TTL осталась in-process тестом). Лаба 3 начата с коммита
`8cddb09` лабы 2, а исправления лабы 2 после её ревью (`8cddb09..102579e`) перенесены отдельным циклом
`2026-10-30-carry-over-lab2-review-fixes` (`a59e3a3`): предел тела считает фактически принятые байты
(`chunked` сверх 1 MiB → `413`), выход отзывает сессию через порт `SessionRevocations` и снимает отметку отзыва,
если PostgreSQL отверг удаление (`503` значит «сессия ещё действует»), пустой `cursor` → `400`, зоны связаны только
схемой БД, воркер сам прерывает зависший при остановке запрос (`500`) до `SIGKILL` мастера.
**`X-Instance-Id`.** `PlatformSettings.instance_id` по умолчанию — `socket.gethostname()`; Docker даёт
контейнеру hostname, равный короткому ID, поэтому значение одно на все воркеры реплики, стабильно на жизнь
контейнера и совпадает с `docker ps` (`evidence/stack.txt`). Конвейер ставит заголовок рядом с
`X-Request-Id` на каждый ответ, проходящий через него; ответ `500` формирует внешний `ServerErrorMiddleware`,
поэтому обработчик необработанных исключений ставит оба заголовка сам. `INSTANCE_ID` в compose не задаётся:
он был бы одинаков у всех реплик.
**Идемпотентная отправка (зона `messaging`).** Таблица `idempotency_keys (chat_id, user_id, key, fingerprint,
message_id, created_at)`, PK `(chat_id, user_id, key)` — область «пользователь + метод + путь чата + ключ»
(ключ бывает только у `POST …/messages`), FK `(chat_id, user_id) → chat_members` и `message_id → messages`,
`CHECK` формата ключа и длины отпечатка. После трека 1 отправка — **одна команда SQL** без явной транзакции
(`PostgresMessageLog.post`, порт `MessageLog`; до трека было пять обращений, три из них под блокировкой чата):
1. CTE `chat`: строка чата `FOR UPDATE`, соединённая с членством отправителя; нет строки → `404`;
2. `created_at = GREATEST(часы реплики, last_message_at + 1 мкс)` — история чата не идёт назад;
3. `INSERT idempotency_keys … ON CONFLICT DO UPDATE … WHERE` ключ истёк — живой ключ не трогается;
4. `INSERT messages` только если ключ записан, `UPDATE chats.last_message_at`; команда фиксируется сама;
5. ключ занят → вторая команда вне блокировки читает квитанцию, моложе `IDEMPOTENCY_TTL_SECONDS`: тот же
отпечаток → сохранённое сообщение (`201`, тот же `MessageOut`, `created_at` с микросекундами); другой → `409`.
Порядок проверок отправки: сессия (`401`) → форма запроса: `Idempotency-Key`, malformed JSON, лишние поля и
типы (`400`, проверяет FastAPI до обработчика, чат не читается, поэтому ответ одинаков для существующего и
несуществующего чата) → доступ к чату (`404`) → текст (`400`). Текст проверяется до записи; если он невалиден,
отдельным чтением проверяется членство, чтобы посторонний получил `404`, а не `400` (тесты
`test_access_checked_before_body` и `test_request_shape_is_checked_before_access`, сценарии
`lab3-idempotent-messages` «Порядок проверок отправки сообщения»). Сообщение и ключ фиксируются вместе или не фиксируются вовсе; маркера «в обработке»
нет, поэтому после гибели реплики посреди запроса повтор с тем же ключом создаёт сообщение один раз.
Одновременные повторы одного ключа всегда идут в один чат и ждут на блокировке его строки; дождавшийся
получает конфликт ключа, а следующая команда в `READ COMMITTED` видит зафиксированную квитанцию. Внешний ключ
квитанции на сообщение проверяется в конце команды, поэтому ключ можно вставить раньше сообщения. Отпечаток —
SHA-256 канонического JSON распарсенной модели, поэтому порядок полей и пробелы не важны. Ответы `4xx`/`5xx`
ничего не пишут; `lock_timeout` теперь `503`, а не `500`. Отвергнуто: `SET NX` в Valkey (не атомарен с
`COMMIT`), отдельный маркер «processing» (залипает после отказа).
**Балансировщик** (`infra/haproxy/haproxy.cfg`):
| Параметр | Значение | Зачем |
| --- | --- | --- |
| Обнаружение | `server-template api 8 api:8080`, `resolvers docker` (127.0.0.11), `init-addr none` | остановленная реплика пропадает из DNS, новая появляется без перезапуска LB и без `docker.sock` |
| Алгоритм | `balance roundrobin`, без `stick` | каждое новое соединение — следующая реплика; сессия общая, привязка не нужна |
| Проверка | `GET /health/ready`, `inter 1s fastinter 500ms downinter 2s fall 2 rise 2`, `timeout check 1s`, `init-state fully-down` | реплика без БД или в остановке выходит из ротации; вернувшаяся получает трафик только после проверок |
| Повторы | `retries 2`, `redispatch 1`, `retry-on conn-failure empty-response`; `disable-l7-retry` всем, кроме `GET` и `POST …/messages` с ключом | отказ соединения повторяется всегда (запрос не ушёл); после отправки — только безопасное к повтору; `POST /users`, `/chats`, вход не повторяются (`contracts/README.md`) |
| Соединения к API | `option http-server-close` | нет простаивающих keep-alive, за которые гонится остановка реплики |
| Таймауты | `connect 500ms`, `server 10s` > `REQUEST_TIMEOUT_SECONDS=8` > `statement_timeout` 2 с; `queue 3s`, `maxconn 64` на сервер | цепочка клиент > LB > приложение > БД |
| Ошибки LB | `502/503/504` — JSON `{"error":{…,"request_id"}}` с тем же `X-Request-Id` | формат контракта даже без реплик (`evidence/hooks.txt`) |
| `X-Request-Id` | непустой входящий до 200 символов пробрасывается, иначе uuid4 | приложение эхо-возвращает его |
| Остановка | `stop_signal: SIGUSR1`, `hard-stop-after 5s` | мягкий стоп внутри `stop_grace_period` 8 с |
**Остановка и процессы (уровень «4»).** По `SIGTERM` реплика сначала выходит из ротации и только потом
перестаёт принимать соединения. Каждый воркер запускает `DrainingServer` (наследник `uvicorn.Server`,
`src/messenger/gunicorn_conf.py`): после сигнала он поднимает флаг, `/health/ready` отвечает `503`, `/health/live`
— `200`, запросы обслуживаются как обычно, и так `DRAIN_SECONDS=2` — дольше худшего обнаружения `503`
балансировщиком (1,5 с). Затем uvicorn закрывает listener и дообрабатывает принятые запросы ещё
`SHUTDOWN_TIMEOUT_SECONDS − DRAIN_SECONDS − 1` = 3 с (не меньше таймаутов БД 1 + 2 с), а запрос, не завершённый
к этому сроку, прерывает сам с `500` и выходит с кодом 0; весь срок — ≤5 с < gunicorn `graceful_timeout` 6 с <
`docker stop -t 7` хука < `stop_grace_period: 8s` < 10 с, поэтому мастер gunicorn не доходит до `SIGKILL` воркера. Без окна (уровень «3») gunicorn закрывал listener сразу, и запрос, уже
стоявший в очереди `accept`, LB видел как обрыв после отправки: для `GET` и сообщений с ключом это повтор, для
`POST /users`, `/chats` и входа — `502`. Разница видна в счётчиках LB: rolling update со старой версии —
`wredis` 55 (запросы, перенаправленные на соседа), с новой — все 0 (`evidence/rolling*/result.json`). Хук
`stop-one.sh` теперь идёт 2,63 с (`evidence/hooks.txt`). На реплику `cpus: 1`, `512m`, 2 воркера, пул 8: 2 × 2 × 8 = 32 соединения <
`max_connections=200`. API работает `read_only` с `tmpfs /tmp`.
**Проверки, период и максимум обнаружения.** `GET /health/ready` раз в `inter 1s`; после первого провала —
`fastinter 500ms`; `fall 2` провала — реплика исключена; `rise 2` успеха — возвращена; `timeout check 1s`;
у `DOWN`-реплики — `downinter 2s`. Readiness пингует PostgreSQL за ≤0,8 с (0,4 с на соединение из пула и 0,4 с
на `SELECT 1`), то есть отвечает явным `503` раньше таймаута проверки. `init-state fully-down`: сервер, который
стартовал, появился через DNS или вернулся из `MAINT (resolution)`, получает трафик только после `rise 2`
проверок (без этого HAProxy делал его `UP/READY` сразу по DNS-ответу, и запросы уходили в ещё не слушающий
gunicorn — первый прогон `failover-each` показал `wredis` 19 и 49 без ошибок; это записано в `design.md`
изменения `2026-10-28-add-lab3-failover-operations`, сырьё того прогона заменено повторным с `init-state`).
| Отказ | Как замечает LB | Максимум обнаружения | Замер (`make detection`) |
| --- | --- | --- | --- |
| `SIGTERM` (`docker stop`, `stop-one.sh`) | readiness `503` в окне вывода | `inter + (fall−1)·fastinter` = 1,5 с, и раньше закрытия порта (2 с) | 0,99–1,43 с; действие (`docker stop -t 7`) завершилось через 2,53–2,61 с |
| процесс убит (`docker kill`) | отказ соединения, DNS | 1,5 с | 0,47–0,54 с |
| процесс завис (`docker pause`) | таймаут проверки | `inter + (fall−1)·fastinter + fall·timeout check` = 3,5 с | 2,91–3,23 с |
| PostgreSQL остановлен | readiness всех реплик `503` | 1,5 с до 0 `UP`; LB сам отвечает `503` | 0,93–1,44 с; `/health/live` через LB → `503 unavailable` без `X-Instance-Id` |
Замер — три прогона `make detection` подряд (`evidence/detection/run{1,2,3}/`), в таблице диапазон. Время
считается от запуска команды отказа, поэтому замер включает задержку docker CLI до сигнала и период опроса
статистики LB (50 мс) и может превысить формулу на эту величину: допуск замера — 0,25 с. На итоговом коде все 12
замеров уложились в формулу без допуска (в `faults.txt` остановка PostgreSQL — 0,93 с); раньше допуск
понадобился: на `a02d442` у PostgreSQL в двух прогонах из трёх (1,553 и 1,551 с), при ревью — у `SIGTERM` (1,609 с),
на `e00eb6c` — у `SIGTERM` в `failover-each` (1,515 с). Возврат в ротацию после восстановления — 1,96–3,63 с.
**Цепочка таймаутов** (проверяется тестом `student-tests/unit/test_timeouts.py` по `compose.yaml`,
`haproxy.cfg` и `scripts/stop-one.sh`, а не только таблицей):
| Звено | Значение | Условие |
| --- | --- | --- |
| LB `timeout server` | 10 с | > `REQUEST_TIMEOUT_SECONDS` |
| `REQUEST_TIMEOUT_SECONDS` | 8 с | > ожидание соединения + оператор БД |
| `DB_ACQUIRE_TIMEOUT_SECONDS` + `DB_COMMAND_TIMEOUT_SECONDS` (`statement_timeout` = `lock_timeout`) | 1 + 2 с | ≤ дообработки после окна |
| LB `timeout check` | 1 с | > readiness 0,8 с |
| `DRAIN_SECONDS` | 2 с | > обнаружения 1,5 с |
| дообработка после окна (uvicorn `timeout_graceful_shutdown`) | `SHUTDOWN − DRAIN − 1` = 3 с | ≥ таймаутов БД 1 + 2 с; затем зависший запрос → `500` |
| `SHUTDOWN_TIMEOUT_SECONDS` (gunicorn `graceful_timeout`) | 6 с | > окна + дообработки; < `STOP_TIMEOUT` хука |
| `STOP_TIMEOUT` хука `stop-one.sh` | 7 с | < `stop_grace_period` 8 с < 10 с |
| LB `timeout connect` / `queue` | 0,5 с / 3 с | отказ соединения повторяется на соседа сразу |
| LB `hard-stop-after` | 5 с | < `stop_grace_period` LB 8 с |
| клиенты: resilience / smoke / k6 | 2 / 10 / 10 с | — |
**Хуки.** `scripts/stop-one.sh` — контейнер `api` с `.Config.Hostname == TARGET_INSTANCE_ID` → `docker stop -t 7`,
реплика остаётся остановленной, неизвестный ID → код 3 без изменений. `scripts/restart.sh` — `stop lb api`,
`restart postgres valkey`, `up -d --no-recreate --wait` (те же контейнеры, повторный `migrate`), volumes не
трогаются. `scripts/restore.sh` — `up --no-deps --no-recreate --wait api`, затем `scripts/lb-wait.sh` ждёт, пока
статистика LB покажет все реплики `UP`.
**Роли и сервисы** (`compose.yaml`; сети `edge` и `backend` с `internal: true`):
| Роль | Сервис | Версия / digest | Health / readiness | Volume | Сеть / порт | Credentials |
| --- | --- | --- | --- | --- | --- | --- |
| load_balancer | `lb` | `haproxy:3.2.26-alpine@sha256:58938405…`, uid 99, `read_only`, `cap_drop: ALL` | `/healthz` :8404 (`nbsrv(api) ≥ 1`); проверяет реплики `GET /health/ready` | нет | `edge` + `backend`; `127.0.0.1:${LB_HTTP_PORT:-8080}`, `127.0.0.1:${LB_STATS_PORT:-8404}` | нет |
| api ×`API_REPLICAS` | `api` | сборка из `Dockerfile`, python по digest, uid 10001, `read_only` | `GET /health/ready` (пингует PostgreSQL) | нет | `backend`, порт не публикуется | secrets `database_url`, `cache_url`, `cursor_secret` через `*_FILE` |
| postgres | `postgres` | `postgres:17.11-alpine@sha256:266d3c25…`, uid 70, `pg_stat_statements` | `pg_isready` | `pgdata:/var/lib/postgresql/data` | `backend` | secret `postgres_password` через `POSTGRES_PASSWORD_FILE` |
| сессии (кэш) | `valkey` | `valkey/valkey:8.1.11-alpine@sha256:2602ace2…`, uid 999 | `valkey-cli ping` с паролем | `valkeydata:/data` (AOF) | `backend` | secret `valkey.conf` (`requirepass`) |
| bootstrap | `migrate` | образ api, `restart: "no"` | код выхода 0 | нет | `backend` | secret `database_url` |
| генератор нагрузки (профиль `bench`) | `k6` | `grafana/k6:2.3.0@sha256:2dd4756e…`, uid хоста | нет | нет (скрипт `infra/k6` только для чтения) | только `edge`, порт не публикуется | нет |
Готовность реплики зависит только от PostgreSQL: Valkey — кэш, при его отказе проверка идёт в БД. Общее
хранилище сессий — PostgreSQL (источник истины) плюс общий Valkey. Bootstrap: `make secrets` (идемпотентен,
не перезаписывает существующие файлы), `make up` (миграции — `migrate` под advisory lock); повтор безопасен
(`make migrate` → `up to date`). Лимиты: lb 1 CPU/128m, api 1 CPU/512m на реплику, migrate 0.5/256m,
postgres 2/1g, valkey 0.5/128m, k6 2/512m (`make limits` сверяет их и изоляцию с политикой).
**Соответствие `.env.example` реальной конфигурации:**
| `.env.example` | В решении | Комментарий |
| --- | --- | --- |
| `APP_HOST`, `APP_PORT` | `HOST`, `PORT` | заданы в образе (`0.0.0.0:8080`); снаружи — порт LB `LB_HTTP_PORT` |
| `APP_ENV` | не используется | режимов окружения нет |
| `SESSION_TTL_SECONDS` | `SESSION_TTL_SECONDS` | по умолчанию 3600 |
| `DATABASE_URL_FILE` | `DATABASE_URL_FILE` | любой параметр читается из `<ИМЯ>_FILE` |
| `SESSION_STORE=postgres` | фиксировано | PostgreSQL — источник истины сессий, Valkey — кэш поверх него |
| `CACHE_URL_FILE` | `CACHE_URL_FILE` | без него кэш выключен |
| `API_REPLICAS` | `deploy.replicas: ${API_REPLICAS:-2}` | число реплик сервиса `api` |
| `IDEMPOTENCY_TTL_SECONDS` | `IDEMPOTENCY_TTL_SECONDS` | 86 400; квитанция старше срока перезаписывается новым запросом |
| — | `LB_HTTP_PORT`, `LB_STATS_PORT` | опубликованные порты LB на `127.0.0.1` |
| — | `API_CPUS`, `API_MEMORY`, `WEB_CONCURRENCY`, `DB_POOL_MAX_SIZE`, `API_SERVER_MAXCONN` | размер реплики, воркеры, пул на воркер, очередь LB на сервер |
| — | `PG_MAX_CONNECTIONS`, `PG_CPUS`, `PG_MEMORY`, `LB_CPUS` | лимиты PostgreSQL и LB |
| — | `REQUEST_TIMEOUT_SECONDS`, `DRAIN_SECONDS`, `SHUTDOWN_TIMEOUT_SECONDS` | 8 с, 2 с и 6 с (заданы в compose и образе) |
| — | `DB_ACQUIRE_TIMEOUT_SECONDS`, `DB_COMMAND_TIMEOUT_SECONDS` | 1 с и 2 с: ожидание соединения из пула и `statement_timeout` = `lock_timeout` |
| — | `K6_CPUS`, `K6_MEMORY` | лимиты генератора нагрузки (профиль `bench`) |
| — | `API_CPUSET`, `LB_CPUSET`, `PG_CPUSET`, `VALKEY_CPUSET`, `K6_CPUSET` | закрепление за CPU для трека 1; пусто — не закреплено |
| — | `CURSOR_SECRET_FILE` | общий ключ подписи курсора для всех реплик |
## Доказательства критериев
Все проверки через LB шли на порт 18083: цели `make` берут `BASE_URL` из `docker compose port lb 8080` (см.
«Запуск»). Дата и коммит прогона — в первой строке отчёта `*.txt`, для JSON, CSV и сырья прогонов — в индексе
`evidence/README.md`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | `make test` | `PASS: lab3 public API scenario` (включая replay == first, `409` на другой body, `400` без ключа, `X-Instance-Id` на каждом ответе); на итоговом коде — тоже `PASS` | `evidence/smoke.txt`, `evidence/clean-clone.txt`, `evidence/track1/after-checks.txt` |
| Офлайн-контракт, OpenAPI и тулчейн | `make check`; `make validate`; `make lint` | `PASS: offline skeleton structure, local refs and Python syntax`; `PASS: full OpenAPI 3.1 and JSON Schema validation`; ruff `All checks passed!`, 103 files already formatted, ty `All checks passed!` | `evidence/checks.txt` |
| Запуск из чистого clone | `git clone`, `make secrets`, `config --quiet`, `make up`, ожидание `/health/ready`, тесты, `make migrate`, `make down`, `make reset-data` | `valid`; `make up` 10 с, `migrate` применил `0001`/`0002` и `Exited (0)`; smoke, failover обеих реплик, persistence `PASS` без явного `BASE_URL` при `LB_HTTP_PORT=18083`; повтор миграций `up to date`; после `down` 2 volume, после `reset-data` 0 | `evidence/clean-clone.txt` |
| **3.1** Весь стенд в `compose.yaml`, ≥2 API, одна точка входа, общая БД и общее хранилище сессий | `make stack-evidence` (`config --quiet`, `ps`, `docker port` реплик, `docker inspect`, статистика LB) | 2 контейнера `api` без портов (`docker port` пуст), порты только у `lb` на `127.0.0.1`; `container_name` 0; LB видит `api1 UP L7OK 200`, `api2 UP L7OK 200`; один `postgres`, один `valkey` | `evidence/stack.txt` |
| **3.2** Разные запросы одного пользователя — разные реплики без повторного входа, видно по `X-Instance-Id` | `make lb-check` (40 × `GET /users/me` одним токеном, новые соединения) + `docker inspect` | `{"286766bf2b32": 20, "fa81adafcb69": 20}` — ровно hostname двух контейнеров `api`; из чистого clone — тоже 20 + 20 | `evidence/lb-check.json`, `evidence/stack.txt`, `evidence/clean-clone.txt` |
| **3.3** Остановка любой одной реплики: ≤10 с, данные доступны, ошибки измерены | `make failover-evidence` → `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, `docker inspect` до/после, `restore`; затем `make failover-evidence SHIFT=1` — один `GET /health/live` через LB перед тестом сдвигает round robin на другую реплику | реплика `286766bf2b32`: первая запись после хука через 2.639 с от его старта, 139 записей, 0 ошибок; реплика `fa81adafcb69` (прогон с `SHIFT=1`): 2.747 с, 138, 0; после теста `exited` именно target, вторая `running`; в логе остановленной — сигнал, окно вывода из ротации с readiness `503`, закрытие и выход; `PASS: failover …` | `evidence/failover-286766bf2b32.txt`, `evidence/failover-fa81adafcb69.txt` |
| **3.3** Хук останавливает только заданную реплику | `scripts/stop-one.sh` с hostname, с неизвестным ID и без него | хук 2.63 с (окно вывода 2 с + остановка), код 0, target `exited exit_code=0`, вторая `running`; неизвестный ID → код 3, всё работает; без переменной → код 1 | `evidence/hooks.txt` |
| **3.4** Повтор с тем же ключом не создаёт дубль; конкурентный повтор и смена реплики | `make lb-check` (20 раундов × 8 параллельных POST с одним ключом через LB); `PYTEST_ADDOPTS=-vv make student-test`; failover-тест (после ошибки — тот же ключ и текст) | 160 × `201` от обеих реплик (80 + 80); в каждом из 20 раундов тела равны, в истории 1 копия, другой body → `409`; `test_replay_returns_the_same_message`, `test_same_json_in_other_layout_is_a_replay`, `test_other_body_with_same_key_conflicts`, `test_concurrent_retries_through_two_replicas_store_one_message` (8 повторов через два экземпляра приложения → одна строка ключа) — `PASSED` | `evidence/lb-check.json`, `evidence/student-tests.txt`, `evidence/failover-*.txt` |
| **3.4** Неподтверждённую запись можно безопасно повторить | `PYTEST_ADDOPTS=-vv make student-test`; failover-тест сверяет историю байт-в-байт | `test_rejected_attempt_does_not_take_the_key` (`4xx` не занимает ключ), `test_expired_key_starts_over`, `test_replay_checks_session_and_access_again` — `PASSED`; в истории после отказа нет дублей `id`/`text` | `evidence/student-tests.txt`, `evidence/failover-*.txt` |
| **3.5** `make test`, persistence и failover проходят; ≥2 наблюдаемых реплики | `make test`, `make persistence-evidence`, `make test-failover …` | smoke `PASS`; persistence `PASS`, `StartedAt` у `lb`, обеих `api`, `postgres`, `valkey`, `migrate` после теста новее, ID контейнеров те же; failover `observed_instances_before: 2`; на итоговом коде — то же | `evidence/smoke.txt`, `evidence/persistence.txt`, `evidence/failover-*.txt`, `evidence/clean-clone.txt` |
| Перенос lab2: схема PK/FK/UNIQUE и миграции с нуля, повтор без дублей | чистый clone (`make up` на пустом volume); `make storage-evidence` | `0001_init`, `0002_idempotency_keys` применены на пустом volume; `\d+` всех таблиц; повтор `up to date`, счётчики строк до и после равны (сообщений столько же, сколько ключей: 160 и 160) | `evidence/clean-clone.txt`, `evidence/schema.txt`, `evidence/migrations.txt` |
| Перенос lab2: Basic только на `/auth/sessions`, Bearer, logout, `X-User-Id` игнорируется | `make test`; `PYTEST_ADDOPTS=-vv make student-test`; `make test-faults` | smoke `PASS`; тесты `test_sessions.py`, `test_authentication.py`, `test_negative.py` — `PASSED`; logout `204` → `401` → `401` через LB | `evidence/smoke.txt`, `evidence/student-tests.txt`, `evidence/faults.txt` |
| Перенос lab2: password KDF | `make storage-evidence` | `$argon2id$v=19$m=19456,t=2,p=1$` у всех 28 пользователей; в `sessions` только 32-байтовые SHA-256 | `evidence/kdf.txt` |
| Перенос lab2: секреты и volumes вне Git | `git ls-files secrets .env`; `git check-ignore -v …`; в чистом clone `git status --ignored` | пусто; пути игнорируются; в clone `secrets/` и `.env` — `!!` (ignored) | `evidence/secrets.txt`, `evidence/clean-clone.txt` |
| Перенос lab2: отказы Valkey и PostgreSQL через LB | `make test-faults` (`BASE_URL` — порт `lb`) | 12 passed: гонка регистрации 201×1/409×49, чат с несуществующим участником `400`, остановка Valkey (выход `503`, затем `204`) и PostgreSQL (`503` за ≤0.014 с; live внутри реплики `200`; LB исключил обе реплики ещё через 0.93 с и сам отвечает `503`; готовность через 2.3 с), рестарт API (готовность 2.6 с), полный рестарт с выходом `204` → `401`, срок сессии после рестарта не продлевается | `evidence/faults.txt` |
| `X-Instance-Id` на каждом ответе приложения | `PYTEST_ADDOPTS=-vv make student-test` (`test_instance.py`) | `test_every_response_names_the_replica` (`200`, `401`, `404`, скрытый `405` как `404`, `400`, `204`), `test_rejected_body_names_the_replica` (`413`), `test_unhandled_error_names_the_replica` (`500`), `test_replica_defaults_to_container_hostname` — `PASSED` | `evidence/student-tests.txt`, `student-tests/api/test_instance.py` |
| Непривилегированные процессы | `make stack-evidence`; снимок окружения | api — uid 10001, lb — 99 (`haproxy`), postgres — 70, valkey — 999 | `evidence/stack.txt`, `evidence/environment.txt` |
**Уровень «4».** Нагрузка — k6 open model из сети `edge` в `lb:8080`: 100 запросов/с постоянной
интенсивности (80 % `POST` сообщения с уникальным ключом, 20 % чтения первой страницы истории), 20
пользователей и 10 чатов, прогрев 10 с, замер 60–90 с; параллельно зонд шлёт сообщение каждые 0,1 с и после
ошибки повторяет тот же ключ, а опрос статистики LB 10 раз в секунду пишет число `UP`. Счётчики LB —
дельта за прогон по backend `api`: `wretr` (повторы), `wredis` (перенаправления), `econ`, `eresp`, `hrsp_5xx`.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| **4.1** Health/readiness, таймауты и прекращение приёма при `SIGTERM` согласованы | `make student-test` (`test_timeouts.py`, `test_drain.py`, вывод `-s`) | цепочка: LB server 10 с > запрос 8 с > БД 3 с; readiness 0,8 с < check 1 с; окно 2 с > обнаружение 1,5 с; дообработка 3 с ≥ БД 3 с; остановка 6 с < хук 7 с < `stop_grace_period` 8 с; настоящий gunicorn по `SIGTERM` (в тесте окно 1 с, срок 3 с): ready/live `(503, 200)` в окне, порт закрыт через 1.18 с, запрос, принятый до сигнала и дописанный после закрытия порта, получил `201`, запрос, тело которого так и не пришло, прерван с `500`, выход через 2.62 с | `evidence/student-tests.txt`, `compose.yaml`, `infra/haproxy/haproxy.cfg`, `src/messenger/gunicorn_conf.py` |
| **4.1** LB исключает недоступный backend; период проверок и максимум обнаружения | `make detection` (три прогона) | период 1 с (0,5 с после провала), `fall 2`/`rise 2`; заявлено ≤1,5 с (`503`/отказ соединения) и ≤3,5 с (зависание), допуск замера 0,25 с; измерено (min–max трёх прогонов): `SIGTERM` 1.004–1.325 с — раньше конца остановки (2.446–2.634 с), `kill` 0.218–0.757 с, `pause` 3.013–3.045 с, PostgreSQL 1.269–1.553 с до 0 `UP` и `503 unavailable` от LB; возврат 1.92–3.04 с; все 12 `pass: true` | `evidence/detection/run{1,2,3}/{sigterm,kill,pause,postgres}.json` |
| **4.2** Последовательно остановить каждую реплику (с восстановлением предыдущей); RPS, ошибки, время восстановления | `make failover-each` (на реплику: `stop-one.sh`, `docker compose ps -a` реплик, 10 с без неё, `restore.sh` — всё внутри окна нагрузки) | `286766bf2b32`: 100.0 rps, 6000 запросов k6, ошибок 0, p50/p95/p99 2.04/6.56/13.68 мс, обнаружение 0.926 с, возврат в ротацию через 14.932 с от начала действия (действие 15.23 с: хук + 10 с + restore), зонд 655 попыток / 0 ошибок, пока реплика исключена, её `X-Instance-Id` не встречался (128 ответов только от `fa81adafcb69`); `fa81adafcb69`: 100.02 rps, 6001, 0 ошибок, 2.10/6.46/14.16 мс, 1.065 с, 14.587 с, 655/0; в `action.txt` сразу после хука — `Exited (0)` у остановленной и `Up (healthy)` у второй; счётчики LB `wretr`/`wredis`/`econ`/`eresp`/`hrsp_5xx` — 0. Обнаружение ≤1,5 с без допуска (на `e00eb6c` было 1.515 с — в пределах допуска замера 0,25 с на docker CLI и опрос, см. `make detection`) | `evidence/failover-each/summary.json`, `evidence/failover-each/<hostname>/` |
| **4.2** Общая идемпотентность — параллельными запросами с одним ключом | `make lb-check` | 20 раундов × 8: 160 × `201` от двух реплик, 20/20 раундов с одинаковыми телами, одной копией и `409` на другой body; на итоговом коде — то же | `evidence/lb-check.json`, `evidence/clean-clone.txt`, `evidence/track1/after-checks.txt` |
| **4.3** CPU/RAM-лимиты, API без портов в обход LB, секреты и хранилища только где нужно, нет `container_name` | `make limits` (`docker compose --profile bench config` + `docker inspect` против политики в `scripts/limits.py`) на итоговом коде | лимиты у всех 6 сервисов (api 1/512MiB, lb 1/128MiB, postgres 2/1024MiB, valkey 0.5/128MiB, migrate 0.5/256MiB, k6 2/512MiB) и применены у запущенных; порты только у `lb` на `127.0.0.1`; секреты: api — 3, migrate — `database_url`, postgres — пароль, valkey — конфиг, lb и k6 — нет; volumes `pgdata`/`valkeydata` только у своих хранилищ; `backend` internal, k6 только в `edge`; api и lb `read_only`; `PASS`. Подмешанные нарушения (порт и лишний секрет у api, `container_name`, снятый лимит) → 5 нарушений, код 1 | `evidence/limits.txt`, `evidence/limits-violations.txt` |
| **4.4** Rolling update под нагрузкой | `make rolling-update FROM_REV=8d28d45` (стенд на образе уровня «3» с тегом `mtusi-messenger:8d28d45`, затем замена на текущую версию с запасом +1) | `lb_up_min` 2 из 2, k6 100 rps, 8996 запросов, ошибок 0 (5 итераций k6 сброшены), зонд 934/0; после замены отвечают только новые контейнеры (`e2d392075b96`, `bc58bf60e518` → `c84bddf582a8`, `225f56282b82`; образ `84c47c47ad8a` → `cb0dac56ff0b`); старые реплики без окна дали `wredis` 55 — запросы, перенаправленные LB на соседа | `evidence/rolling-from-8d28d45/result.json`, `action.txt` |
| **4.4** То же на текущей версии | `make rolling-update` | `lb_up_min` 2, 9001 запрос, ошибок 0, зонд 942/0, все реплики новые (`c84bddf582a8`, `225f56282b82` → `89953d9764bd`, `1f35898d8b4e`); все счётчики LB 0. Образ пересобран из той же ревизии, ID другой (`cb0dac56ff0b` → `c23101d9a13d`): BuildKit пишет при сборке новый манифест с аттестацией (`exporting attestation manifest` в `clean-clone.txt`) — это эквивалентная поочерёдная замена | `evidence/rolling/result.json`, `action.txt` |
| **4.4** Миграции однократно и совместимы с работающей версией | `scripts/rolling-update.sh`; `make storage-evidence` | `migrate` запускается один раз до замены первой реплики (`migration.completed up to date`), реплики схему не трогают, `migrate` под `pg_advisory_lock`; между уровнями «3» и «4» схема не менялась; `0002_idempotency_keys` только добавляет таблицу, код лабы 2 её не замечает | `evidence/rolling*/action.txt`, `evidence/migrations.txt` |
**Трек 1 «Цена масштабирования».** Подробности, таблицы и выводы — в разделе трека ниже; поля CSV —
`evidence/track1/README.md`.
| Критерий трека | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Гипотеза и повторяемая методика | `openspec/changes/archive/2026-10-29-add-lab3-scaling-cost/proposal.md` (коммит `d8d551a`); `make track1` | гипотезы H1–H3 записаны в предложении до первого прогона серий; серии, сравнение и графики — одной командой; снимок хоста и версий | `evidence/track1/host.txt`, `evidence/track1/README.md` |
| 1/2/4 реплики при фиксированном суммарном CPU/RAM | `make track1-a` (4 CPU / 2 GiB, воркеров = CPU, пул 32 и очередь LB 128 во всех вариантах, CPU 7–10 закреплены) | пик успешных RPS: 1×4 — 5 375, 2×2 — 4 964, 4×1 — 4 724; потолок по SLO у всех 4 560 rps, но p95 там 9 / 69 / 150 мс | `evidence/track1/series-a/summary.csv`, `plots/series-a-*.png`, `plots/capacity.md` |
| Серия с ростом ресурсов | `make track1-b` (1→2→4→8 реплик по 1 CPU) | пик 1 720 → 2 936 → 4 724 → **4 260**: восемь реплик хуже четырёх; USL σ = 0,014, κ = 0,038, максимум около 5 реплик | `evidence/track1/series-b/summary.csv`, `plots/scaling.png`, `plots/capacity.md` |
| Saturation point БД/LB/пула и почему реплики перестают помогать | метрики каждого прогона: `docker stats`, HAProxy CSV, `pg_stat_activity`, `pg_stat_statements` | на 8×1: API 473 из 800 %, LB 40 % ядра, PostgreSQL 178 из 200 %, **47,5 из 64 соединений ждут блокировку строки чата**, 6,8 — `idle in transaction`, `SELECT … FOR UPDATE` чата — ≈14,1 мс в среднем (13,6–14,4) и 98,7 % времени топ-20 операторов. Контроль (`make track1-control`, 3 повтора): `maxconn` LB 16/32/64 — пик 4 526 / 4 677 / 4 525 rps, интервалы перекрываются (LB не ограничивает); пул 4/8/16 на воркер — 5 358 / 4 677 / 3 789 rps при 14,7 / 47 / 102 ждущих блокировку (пул не мал, а лишние соединения только добавляют конкурентов); 8×0,5 на CPU 4×1 — пик 5 525 против 5 928 (число процессов, а не другие ядра) | `evidence/track1/series-b/summary.csv`, `series-b/base-8x1_rate5400_rep*/pg_statements.csv`, `plots/utilisation.png`, `track1/control-{pool,cpus}/summary.csv`, `plots/capacity.md` |
| Графики и сырые данные | `make plots` | RPS и p95/p99 от нагрузки, CPU по компонентам, пик от CPU с USL, загрузка звеньев на пике, сводка потолков; сырьё каждого прогона — k6, `docker stats`, HAProxy CSV, `pg_stat_activity`, `pg_stat_statements` | `evidence/track1/plots/`, `evidence/track1/<серия>/<прогон>/` |
| Одно подтверждённое улучшение (до/после при тех же ресурсах) | `make track1-compare` (8×1, образ `edc091d` против текущего, чередование по повторам) | запись сообщения одной командой: при 3 600 rps p95 64,5 → 3,7 мс, CPU на запрос API −14 %, PostgreSQL −26 %; пик 4 252 → 4 894 rps (+15 %), интервалы повторов не пересекаются | `evidence/track1/compare/summary.csv`, `plots/compare-*.png` |
| Улучшение не ломает уровни «3» и «4» | сразу после улучшения: `make student-test`, `make test`, 20 гонок ключа, `make test-failover`, `make test-persistence`; на итоговом коде `b1c80ee` — весь уровень «3», `make test-faults` и `make level4` под k6 | после улучшения: 240 passed, smoke `PASS`, 160 × `201`, failover 131 запись / 0 ошибок, persistence `PASS`; на итоговом коде — 243 passed, 12 тестов стенда и все строки 3.x и 4.x выше (`detection` ×3, `failover-each`, оба rolling update — 0 ошибок под 100 rps), чистый clone | `evidence/track1/after-checks.txt`, `evidence/clean-clone.txt`, файлы строк 3.x–4.x |
## Эксперименты и отказы
Стенд: 2 реплики × (1 CPU, 512 MiB, 2 воркера), PostgreSQL 2 CPU / 1 GiB, HAProxy 1 CPU / 128 MiB, Valkey
0.5 CPU / 128 MiB, k6 2 CPU / 512 MiB; Docker Desktop на Apple M4 Max. Нагрузка в failover-тесте — один клиент,
`POST` каждые 0.1 с в течение 15 с, таймаут 2 с, повтор после ошибки с тем же ключом; в строках уровня «4» —
k6 100 rps плюс зонд (см. выше). Данные синтетические: каждый прогон создаёт своих пользователей и чаты.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| stop api#1 (`stop-one.sh`, `286766bf2b32`) | запись продолжается ≤10 с, target больше не отвечает | 0 неудачных попыток, 139 записей; после теста `286766bf2b32` `exited`, `fa81adafcb69` `running` (`failover-286766bf2b32.txt`) | первая запись после хука через 2.639 с от его старта (хук ≈2,6 с из-за окна вывода; запись не прерывалась); потерь и дублей нет |
| stop api#2 (после `restore` и одного запроса через LB — `SHIFT=1`, `fa81adafcb69`) | то же для второй реплики | 0 неудачных попыток, 138 записей; `fa81adafcb69` `exited` (`failover-fa81adafcb69.txt`) | 2.747 с; потерь и дублей нет |
| Полный restart (`restart.sh`: lb, api ×2, postgres, valkey) | прежний токен работает, история побайтно та же | persistence `PASS`; ID контейнеров прежние, `StartedAt` всех обновился: postgres, valkey, lb — 23:44:29, api — 23:44:30–31 при старте прогона в 23:44:25 (`persistence.txt`) | потерь нет; в чистом clone — то же (`clean-clone.txt`) |
| Конкурентный одинаковый ключ (20 раундов × 8 POST через LB) | в каждом раунде одно сообщение, все ответы равны | 160 × `201`, 80 + 80 по репликам, 20/20 раундов с 1 копией, другой body → `409` (`lb-check.json`) | дублей нет |
| Все реплики остановлены | LB отвечает `503` в формате контракта | `503 {"error":{"code":"unavailable",…,"request_id":"no-replica-1"}}` (`hooks.txt`) | после `make restore` — `200` |
| `docker compose stop postgres` | реплики выходят из ротации, ответы `503`, а не `500` | `503` за ≤0.014 с на ready, me, login, register; live внутри реплики `200`; LB исключил обе реплики через 0.93 с (`faults.txt`) и 0.93–1.44 с (`detection/run*/postgres.json`) и отвечает `503` сам | после `start` готовность через 2.3 с без рестарта API; в ротации через 2.48–2.65 с |
| `docker compose stop valkey` | проверка сессий через PostgreSQL, без анонимного доступа | действующий токен `200`, неизвестный `401`, выход `503` (`faults.txt`) | после `start` выход `204` |
| Повторный `migrate` | схема и данные не меняются | `up to date`, счётчики равны (`migrations.txt`, `clean-clone.txt`) | — |
| `SIGTERM` реплике (`docker stop -t 7`) | LB исключает её раньше, чем она закроет порт | исключена через 0.99–1.43 с, остановка завершилась через 2.53–2.61 с (`detection/run*/sigterm.json`); код выхода 0, в логе — окно 2 с и readiness `503` (`hooks.txt`, `failover-*.txt`) | возврат после `restore` 1.96–3.63 с |
| Процесс реплики убит (`docker kill`) | исключение ≤1,5 с | 0.47–0.54 с (`detection/run*/kill.json`) | `restore` 2.65–3.05 с |
| Процесс реплики завис (`docker pause`) | исключение ≤3,5 с по таймауту проверки | 2.91–3.23 с; через LB — `200` от соседа (`detection/run*/pause.json`) | после `unpause` 2.37–2.86 с |
| Поочерёдная остановка каждой реплики под 100 rps | 0 ошибок, запись не прерывается, реплика возвращается | обе реплики: k6 0 ошибок из 6000 и 6001, зонд 0 из 655 и 655, p99 13.7 и 14.2 мс, повторов LB 0 (`failover-each/summary.json`) | обнаружение 0.93–1.07 с; снова в ротации через 14.59–14.93 с от начала действия (хук + 10 с без реплики + `restore`) |
| Rolling update с уровня «3» под 100 rps | ёмкость не ниже 2, 0 ошибок, после — только новые реплики | `lb_up_min` 2, 0 ошибок из 8996, зонд 0 из 934; старые реплики без окна: `wredis` 55 | замена двух реплик за 7.062 с |
| Rolling update текущей версии под 100 rps | то же, и без повторов LB | `lb_up_min` 2, 0 ошибок из 9001, зонд 0 из 942, все счётчики LB 0 | 12.010 с |
### Трек 5 — трек 1 «Цена масштабирования»
**Гипотезы** (записаны в предложении до первого прогона). H1: при фиксированном бюджете API 4 CPU / 2 GiB
конфигурации 1×4, 2×2 и 4×1 дают одинаковый потолок в пределах ±15 %: упор — суммарный CPU интерпретатора, а
4×1 хуже по p99 из-за мелкой квоты CFS. H2: с 1 CPU на реплику пропускная способность растёт почти линейно до
4 реплик (≥3,2× от одной), от 4 к 8 — меньше чем в 1,5 раза, потому что насыщается общий PostgreSQL: блокировка
строки горячего чата (`SELECT … FOR UPDATE` держится три обращения к БД) и CPU у лимита; LB не узкое место.
H3: мера против найденного узкого места даёт ≥15 % потолка или вдвое меньший p95 при той же нагрузке и тех
же ресурсах.
**Методика** (`make track1`; `scripts/scaling.py`, сэмплеры `scripts/{docker,lb,pg}-stats.sh`, графики
`tools/plot_track1.py`, сценарий нагрузки `infra/k6/messages.js`):
- Стенд: Apple M4 Max, VM Docker Desktop 16 CPU / 7,65 ГиБ, Docker 28.3.2; образы — по digest (`host.txt`).
Каждый компонент закреплён за своими CPU (`cpuset`): PostgreSQL 0–1 (2 CPU, 1 GiB, `max_connections=200`),
HAProxy 2 (1 CPU, 128 MiB), Valkey 3 (0,5 CPU), k6 4–6 (3 CPU, 1 GiB), реплики API — с 7-го ровно R×C CPU.
- Конфигурация `R×C`: R реплик по C CPU, воркеров gunicorn = C, пул asyncpg 8 на воркер, `maxconn` LB 32 на
воркер. В серии A у всех вариантов одни и те же CPU 7–10, 2048/R MiB на реплику, 32 соединения с БД и 128
одновременных запросов к API — сравниваются реплики, а не очереди. В серии B — 1 CPU, 512 MiB, 1 воркер на
реплику; точка 4×1 общая с серией A.
- Нагрузка: k6 `constant-arrival-rate` (открытая модель, без coordinated omission) из сети `edge` в `lb:8080`,
профиль уровня «4»: 80 % `POST` сообщения с уникальным `Idempotency-Key`, 20 % чтения первой страницы истории,
на прогон 20 новых пользователей и 10 чатов. Прогрев 10 с, замер 30 с, метрики только по окну замера.
Интенсивности — геометрическая сетка ×1,5 от 150 rps на CPU (A) и 450 rps на CPU (B), пока два шага подряд не
насыщены во всех повторах или следующий шаг не превысит верхнюю границу сетки — 8 000 rps в серии A
(`--search 1.5:8000` по умолчанию) и 9 000 rps в серии B. В серии A все три конфигурации насыщены только на
6 830 rps: следующий шаг 10 245 rps выше границы, и сетка остановилась на одном насыщенном шаге. Контрольные прогоны идут на заданных интенсивностях без сетки.
**3 повтора на точку**: в итоговых таблицах 123 прогона (63 + 42 + 18), 9,6 млн запросов, и 27 контрольных
(15 + 12), 3,8 млн.
- Набор данных: перед каждой конфигурацией `down -v`, затем база растёт от прогона к прогону; размер в каждой
строке (`db_mb`, `messages` — перед прогоном): 7,7 МБ в начале конфигурации, до 1 019 МБ и 2,1 млн сообщений
перед последним прогоном серии A, 497 МБ и 1,0 млн — серии B, 1,77 ГБ и 3,7 млн — сравнения.
- Насыщение шага: ошибок > 1 %, сброшенных итераций > 1 % или p95 > 500 мс; интенсивность насыщена, если
насыщено большинство повторов. Потолок по SLO — наибольшая ненасыщенная интенсивность (грубо, шаг ×1,5),
пик — наибольшая медиана успешных RPS (в открытой модели при перегрузке это и есть пропускная способность).
- Сырьё прогона: итог k6, `docker stats` и счётчики `/proc/stat` всей VM, HAProxy CSV и `pg_stat_activity` раз в
секунду, топ-20 `pg_stat_statements`. Соседние стенды других лаб на той же VM мешали (сборки образов, тесты с
контейнерами): прогон, где CPU VM вне контейнеров стенда больше одного ядра, сэмплы прерывались дольше 10 с или
k6 шёл на 90 с дольше нагрузки, пишется в `disturbed.csv` и повторяется после 15 с тишины, до трёх раз (серия A —
12 отбраковок, B — 0, сравнение — 13, контроль пула — 24, контроль размещения — 0). Семь шагов остались
возмущёнными и после трёх повторов и вошли в таблицы с пометкой `disturbed`: серия A 4×1 при 3 040 rps, повтор 2
(чужой CPU 138 %), сравнение «после» при 5 400 и 8 100 rps, повтор 1 (105 и 136 %), контроль пула — пул 8 и 16
в повторе 1, `maxconn` 16 и 64 в повторе 2 (177–453 %), в контроле это нижние значения своих интервалов. Первая попытка серии A прервана: сборка образа соседней лабы остановила
Docker API почти на 16 мин между прогонами, а CPU API на запрос вырос до 3,8 мс против 0,7–0,9 у соседних
прогонов (2×2 при 1 350 rps — 410 % CPU; `aborted/series-a-1-summary.csv`).
**Серия A — фиксированный бюджет 4 CPU / 2 GiB** (медиана 3 повторов, в скобках min–max; «на пике» — при 6 830
rps):
| Конфигурация | p95 при 3 040 / 4 560 rps, мс | Потолок по SLO, rps | Пик успешных RPS | CPU API на запрос при 3 040 rps | Память API на пике | На пике: CPU API / PostgreSQL / LB, % ядра | На пике: ждут блокировку / `idle in transaction` из 32 |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| 1×4 | 2,9 / 9,3 | 4 560 | **5 375** (5 332–5 384) | 0,70 мс | 367 МиБ | 378 / 178 / 42 | 15,7 / 6,2 |
| 2×2 | 4,5 / 68,8 | 4 560 | 4 964 (4 894–5 104) | 0,80 мс | 2 × 214 МиБ | 379 / 173 / 41 | 16,0 / 6,9 |
| 4×1 | 35,0 / 150,3 | 4 560 | 4 724 (4 686–4 794) | 0,93 мс | 4 × 133 МиБ | 381 / 164 / 40 | 15,3 / 6,8 |
**Серия B — рост ресурсов** (1 CPU, 512 MiB, 1 воркер на реплику):
| Конфигурация | Потолок по SLO, rps | Пик успешных RPS | Ускорение к 1×1 | Эффективность на CPU | На пике: CPU API / лимит | CPU PostgreSQL / 200 | CPU LB | Ждут блокировку / `idle in transaction` / пул | Очередь LB |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
| 1×1 | 1 520 | 1 720 (1 674–1 722) | 1,00 | 100 % | 102 / 100 | 47 | 13 | 0,2 / 3,4 / 8 | 968 |
| 2×1 | 2 020 | 2 936 (2 868–2 998) | 1,71 | 85 % | 201 / 200 | 94 | 23 | 2,4 / 6,3 / 16 | 936 |
| 4×1 (из A) | 4 560 | 4 724 (4 686–4 794) | 2,75 | 69 % | 381 / 400 | 164 | 40 | 15,3 / 6,8 / 32 | 872 |
| 8×1 | ≥3 600 (первая точка сетки) | **4 260** (4 217–4 424) | 2,48 | 31 % | 473 / 800 | 178 | 40 | **47,5** / 6,8 / 64 | 744 |
Ошибок нет ни в одном прогоне таблиц (доля неуспешных ≤ 0,02 %): перегрузка проявляется как очередь в LB
(до 1 000 одновременных сессий — предел VU k6), рост задержки и сброшенные итерации, а не как `5xx`, — таймауты
`lock_timeout` 2 с и `timeout queue` 3 с не достигались. Генератор нагрузки не был узким местом: k6 ≤ 84 % из
300 %, Valkey ≤ 12 % ядра. Память: API 116–374 МиБ на контейнер, PostgreSQL до 661 МиБ, k6 до 675 МиБ.
USL по пикам серии B (N = 1, 2, 4, 8 CPU): σ = 0,014 (последовательная доля), κ = 0,038 (стоимость
согласования), максимум при N* = √((1−σ)/κ) ≈ 5 реплик, дальше — спад (`plots/scaling.png`, `plots/capacity.md`).
**Точка насыщения и почему реплики перестают помогать.** До двух реплик упор — CPU API (100 % лимита),
PostgreSQL загружен наполовину. С четырёх реплик API, PostgreSQL и блокировки упираются почти одновременно, а
на восьми ресурсы простаивают: у API свободно 40 % CPU, у LB — 60 % ядра, у PostgreSQL — 11 %, и всё же пик
ниже, чем у четырёх реплик. Насыщена **критическая секция записи в чат**: в профиле 10 чатов, запись в чат
сериализуется блокировкой его строки, поэтому одновременно идут не больше 10 записей, а остальные транзакции
держат соединения пула и ждут (`pg_stat_activity`: 47,5 из 64 соединений в `Lock: tuple/transactionid`, пул
исчерпан — свободных 6). `SELECT … FOR UPDATE` чата длится в среднем ≈14,1 мс (13,6 / 14,2 / 14,4 по повторам) и занимает 98,7 % суммарного
времени топ-20 операторов (`pg_statements.csv` трёх повторов 8×1 при 5 400 rps), и около 7 соединений стоят
`idle in transaction`: держатель блокировки ждёт, пока event loop реплики отправит следующий оператор. Каждая новая реплика добавляет пул из 8 соединений и параллельных
писателей в те же 10 строк — больше ожидающих, больше пробуждений и переключений в PostgreSQL, длиннее очередь
event loop у держателей, а последовательная часть не уменьшается: это и есть рост κ по USL. LB (40 % ядра)
и пул — не причина, это проверено контрольными прогонами ниже. Серия A
добавляет вторую цену дробления: CPU API на запрос растёт с числом процессов-реплик (0,70 мс у 1×4, 0,93 у 4×1
при 3 040 rps; 1,1–1,2 у 8×1 против 0,6–0,8 у 1×1), память — тоже (367 МиБ одной репликой против 4 × 133 =
532 МиБ четырьмя).
**Контрольные прогоны** (`make track1-control`, итоговый код `b1c80ee`; меняется один ресурс при прочих равных,
варианты чередуются по повторам, 3 повтора, `*` — прогон остался `disturbed` после трёх повторов). Первая часть —
8×1 при 5 400 rps (за коленом) с пулом 4/8/16 соединений на воркер и очередью LB `maxconn` 16/32/64 на реплику:
| Вариант 8×1 | Успешные RPS, медиана (min–max) | p95, мс | Ждут блокировку / соединений с БД | Очередь LB, max | CPU API / PostgreSQL, % |
| --- | ---: | ---: | ---: | ---: | ---: |
| пул 4 | **5 358** (5 316–5 394) | 179 | 14,7 / 32 | 739 | 517 / 163 |
| пул 8, `maxconn` 32 (как в серии B) | 4 677 (3 749*–4 966) | 273 | 47,0 / 64 | 744 | 471 / 170 |
| пул 16 | 3 789 (2 291*–4 077) | 355 | 102,3 / 128 | 744 | 372 / 180 |
| `maxconn` 16 | 4 526 (3 776*–4 917) | 258 | 47,3 / 64 | 872 | 424 / 177 |
| `maxconn` 64 | 4 525 (4 005*–4 908) | 299 | 46,8 / 64 | 487 | 442 / 178 |
Очередь LB пик не меняет: при `maxconn` 16, 32 и 64 медианы 4 526 / 4 677 / 4 525 rps, интервалы перекрываются,
меняется только то, где ждут запросы (в очереди LB или в соединениях реплики). Пул меняет пик, но в обратную
сторону: чем он меньше, тем выше пропускная способность — 4 соединения на воркер дают 5 358 rps (интервал не
пересекается с пулом 8), 16 — 3 789. Число ждущих блокировку растёт вместе с пулом (14,7 → 47,0 → 102,3), а
запись в чат длится дольше (среднее время команды записи 1,7–3,2 → 12,2–15,6 → 35–47 мс, `pg_statements.csv`):
пул не ограничивает сверху, а, наоборот, впускает в PostgreSQL больше конкурентов за строку чата. Это прямое
подтверждение, что цена — согласование писателей одной строки (κ), а не нехватка соединений или LB; маленький пул
работает как admission control — второе возможное улучшение, в трек как основное не взято (выбрано до контроля).
Вторая часть отделяет число процессов от размещения: 4×1 и 8×0,5 на одних и тех же CPU 7–10 (столько же vCPU,
что у 4×1, столько же процессов и соединений, что у 8×1):
| Конфигурация, CPU 7–10 | 4 560 rps: успешные RPS / p95 / p99, мс | 4 560 rps: CPU API на запрос | 4 560 rps: ждут блокировку / соединений | Пик при 6 830 rps, медиана (min–max) |
| --- | ---: | ---: | ---: | ---: |
| 4×1 | 4 560 / 32 / 65 | 0,75 мс | 1,4 / 32 | **5 928** (5 894–5 950) |
| 8×0,5 | 4 560 / 61 / 109 | 0,86 мс | 4,2 / 64 | 5 525 (5 482–5 583) |
На тех же ядрах восемь процессов дают на 7 % меньший пик (интервалы не пересекаются), на 15 % дороже запрос по
CPU и вдвое больший p95 ниже колена. Значит, ретроградность 8×1 объясняется числом процессов и соединений, а не
тем, что CPU 11–14 медленнее: в прогонах того же часа 8×1 с пулом 4 (те же 32 соединения, что у 4×1) даёт
5 358 rps против 5 928 у 4×1 — цена процессов, а с пулом 8 (64 соединения) — 4 677 — плюс цена ожидающих.
Первая попытка этой части отброшена: в четырёх прогонах 4×1 команда записи замедлилась до 7–34 мс
(`IO: WalSync`, `aborted/control-cpus-1-*.csv`) при чужой нагрузке на CPU ниже порога отбраковки — она такое не ловит;
повтор сразу после дал 0,2–0,6 мс и вошёл в таблицу.
**Улучшение: запись сообщения одной командой SQL** (выбрано по узкому месту серии B; обоснование и отвергнутые
варианты — `design.md` изменения `2026-10-29-add-lab3-scaling-cost`). Блокировка строки чата, проверка участия, отметка времени, ключ и сообщение —
одна команда с неявной транзакцией, без обращений к приложению под блокировкой (раздел «Идемпотентная отправка»
выше). Сравнение — `make track1-compare`: 8×1, те же ресурсы и профиль, образ «до» из `edc091d`, варианты
чередуются по повторам, по 3 повтора:
| Нагрузка | Вариант | Успешные RPS | p50 / p95 / p99, мс | CPU API / PostgreSQL, % | CPU на запрос API / PG, мс | Ждут блокировку / `idle in transaction` / ждут `LWLock` (WAL) |
| --- | --- | ---: | ---: | ---: | ---: | ---: |
| 3 600 | до | 3 596 (3 568–3 596) | 2,4 / 64,5 (35,7–142,5) / 122 | 457 / 137 | 1,27 / 0,38 | 12,8 / 4,5 / 1,5 |
| 3 600 | **после** | 3 600 (3 600–3 600) | 1,7 / **3,7** (2,8–5,4) / 12,6 | 391 / 102 | 1,09 / 0,28 | 0,15 / 0 / 1,9 |
| 5 400 | до | 4 252 (4 054–4 396) | 227 / 296 / 349 | 475 / 178 | — | 46,6 / 7,0 / 2,3 |
| 5 400 | **после** | **4 894** (4 494–5 104) | 198 / 246 / 278 | 479 / 179 | — | 46,4 / 0 / 8,5 |
| 8 100 | до | 4 104 (4 001–4 448) | 236 / 311 / 364 | 475 / 178 | — | 47,1 / 7,3 / 1,9 |
| 8 100 | **после** | 4 841 (4 618–5 046) | 202 / 254 / 287 | 462 / 174 | — | 46,3 / 0 / 9,2 |
Ниже колена (3 600 rps) p95 уменьшился в 17 раз, p99 — почти в 10, разброс повторов исчез; CPU API на запрос
−14 %, PostgreSQL −26 % (меньше операторов и обращений). За коленом пик вырос на 15 % (при 8 100 rps — на 18 %),
интервалы повторов «до» и «после» не пересекаются. При насыщении соединений `idle in transaction` больше нет,
но пул по-прежнему занят ждущими блокировку: теперь держатель ждёт не приложение, а сброс WAL при фиксации
(ожидания `LWLock`, почти все — `WALWrite`, 8,5–9,2 против 1,9–2,3 «до»; `pg_activity.csv`), а CPU PostgreSQL —
89 %. Нижние значения варианта «после» за коленом (4 494 и 4 618 rps) — как раз возмущённые прогоны (см.
методику): вывод они не усиливают, а ослабляют. Проверки уровней «3» и «4» на новом коде проходят
(`after-checks.txt`, `clean-clone.txt`), а на итоговом коде повторён весь уровень «4» под k6 (строки 4.x).
**Выводы.**
- H1 **подтверждена частично.** Потолки 1×4, 2×2 и 4×1 действительно в пределах ±15 % (4 724–5 375, −12 % у
4×1), но различие систематическое и больше разброса: чем мельче реплики, тем дороже запрос по CPU (+33 % у
4×1) и памяти, и тем раньше растёт хвост (p95 при 4 560 rps — 9, 69 и 150 мс). Упор на пике — не только CPU
API (95 %): у всех трёх половина соединений ждёт блокировку чата. При фиксированном бюджете выгоднее меньше
реплик покрупнее, а число реплик определяется отказоустойчивостью (≥2), а не скоростью.
- H2 **опровергнута в части линейного роста и CPU БД, подтверждена в части 4→8.** Гипотеза ждала ≥3,2× на 4
репликах и CPU PostgreSQL у лимита; измерено 2,75× (линейный рост — только до двух реплик, 1,71× на 2 CPU) и
CPU PostgreSQL 89 % (178 из 200). Рост 4→8 действительно меньше 1,5×, и даже отрицательный: 8 реплик дают
**меньше, чем 4** (2,48×) — ретроградное масштабирование, κ > 0, максимум около 5 реплик. Насыщенное звено —
общая БД, но не её CPU и не `max_connections` (64 из 200), а сериализованная по строке чата запись,
растянутая обращениями к приложению; размер очереди LB и пула пик не ограничивает (контрольные прогоны).
Отдельно проверено, что ретроградность — от числа процессов и соединений, а не от размещения на других vCPU.
- H3 **подтверждена.** Укорочение критической секции до одной команды дало +15 % пика при тех же ресурсах и в
17 раз меньший p95 ниже колена. Следующий потолок — фиксация под блокировкой горячей строки (WAL) и CPU
PostgreSQL: его сдвигают только больше чатов в профиле, `synchronous_commit = off` (ценой подтверждённых, но
потерянных при сбое сообщений) или более быстрый диск и больше CPU для БД — новые реплики API не помогут.
**Ограничения трека.** Один host: k6, LB, API и PostgreSQL делят VM Docker Desktop, закрепление CPU разводит
их по vCPU, но не по физическим ядрам (у M4 Max ядра двух типов), поэтому абсолютные RPS — свойство этой машины,
сравнимы только конфигурации внутри одного прогона. Эффект числа процессов отделён от размещения контролем на
одних CPU 7–10; насколько сами CPU 11–14 медленнее 7–10, отдельно не измерялось. Соседние стенды других лаб работали всё время замеров;
отбраковка ловит нагрузку больше одного ядра, меньшая остаётся шумом (`host-others.csv`), а задержки дисковой
подсистемы VM не ловит вовсе (отброшенная первая попытка контроля размещения). CFS-квоты дают
троттлинг мелких реплик; гипотеза, что из-за него 4×1 дороже по CPU, не проверялась счётчиками `cpu.stat`.
`docker stats` даёт точку раз в 4–6 с, `pg_stat_activity` — раз в секунду, это выборка, а не трасса.
Профиль с 10 чатами нарочно горячий; с тысячами чатов узким местом стали бы CPU API и PostgreSQL, и кривая
серии B была бы ближе к линейной. Сетка ×1,5 делает потолок по SLO грубым, поэтому сравнение идёт по пику.
`maxVUs` k6 ограничен 1 000, поэтому при перегрузке растут сброшенные итерации, а очередь в LB упирается в
1 000. Порт-форвардинг Docker Desktop в замеры не входит — k6 бьёт в `lb` изнутри сети. База растёт внутри
конфигурации (до 1 ГБ в серии A), поэтому старшие интенсивности идут на большей базе, чем младшие. Сравнение
до/после сделано на одной конфигурации 8×1; третий повтор «после» снят отдельным запуском после сбоя
`compose up` (`evidence/track1/README.md`). `compose up --wait` на восьми репликах при смене варианта изредка
проходит только со второй попытки (оркестратор повторяет его через 30 с). Причина видна в полном выводе
(`control-pool/compose-up-failed.log`, оба раза при переходе на пул 16): смена переменных пересоздаёт все реплики
сразу, балансировщик на это время остаётся без готовых серверов, его healthcheck (`nbsrv(api) ≥ 1`, 3 провала по
2 с) помечает `lb` как `unhealthy`, и `--wait` завершается ошибкой; через 30 с реплики готовы и повтор проходит.
На обычный стенд это не влияет: `make up` и rolling update не пересоздают все реплики разом.
## Ответы на вопросы защиты
**Чем отказ процесса отличается от отказа узла?** Отказ процесса — это одна реплика: контейнер остановлен,
убит или завис, а host, LB, PostgreSQL и соседняя реплика работают. Его ловит проверка готовности LB, и
трафик уходит на соседа: `SIGTERM` — 1,0–1,4 с, `kill` — 0,5 с, зависание (`docker pause`) — 2,9–3,2 с по таймауту
проверки (`evidence/detection/`), запись не прерывается (`failover-each`: 0 ошибок под 100 rps). Отказ узла
забирает всё, что на нём запущено, сразу: здесь узел один, поэтому вместе с репликами пропадают LB, PostgreSQL,
Valkey и volumes — отказ всего стенда, и никакая реплика его не переживёт. Кроме того, мёртвый узел не отвечает
`RST` и не закрывает соединения: обнаружение идёт только по таймаутам, как в сценарии `pause`, а не по отказу
соединения, как при `kill`. Защита от потери узла — несколько узлов и реплицированные LB и БД (трек 2) — в эту
работу не входит.
**Почему `depends_on`/`healthcheck` сами по себе не являются балансировщиком?** `depends_on` упорядочивает
только запуск: `migrate` ждёт `healthy` PostgreSQL, `api` — успешного завершения `migrate` и старта Valkey, один
раз, при `up`, и дальше ни на что не влияет. `healthcheck` лишь меняет статус контейнера в `docker ps`: у `api` он раз в 5 с с 3 повторами, то есть
`unhealthy` наступает через десяток секунд, и Compose ничего не делает с трафиком — встроенный DNS Docker
отдаёт адрес работающего контейнера независимо от его здоровья. Нет единой точки входа, распределения запросов,
повторов отказавшего соединения на соседа, мягкого вывода из ротации и ответа `503` в формате контракта, когда
готовых реплик нет. Всё это делает HAProxy: активная проверка `/health/ready` раз в 1 с с `fall 2`/`rise 2`,
round robin, `retry-on conn-failure` и `redispatch`. Пример — остановка PostgreSQL: контейнеры `api` продолжают
работать, а LB исключает обе реплики за 0,9–1,4 с и сам отвечает `503 unavailable` (`detection/run*/postgres.json`).
**Какие POST можно повторять после timeout и что защищает Idempotency-Key?** Только `POST
/api/v1/chats/{chat_id}/messages` с тем же `Idempotency-Key` и тем же телом. Сообщение и квитанция ключа
фиксируются одной командой, поэтому повтор после таймаута, обрыва или гибели реплики посреди запроса либо
находит квитанцию и получает тот же `201` с тем же `Message`, либо, если исходная запись не зафиксировалась,
создаёт сообщение один раз. Одновременные повторы через разные реплики сериализуются блокировкой строки чата:
160 × `201` и одна копия в каждом из 20 раундов (`lb-check.json`); failover-тест повторяет запись с тем же ключом
после ошибки, и в истории нет дублей (`failover-*.txt`). Ключ не защищает от другого тела с тем же ключом
(`409`), от повтора через 24 ч и больше (`IDEMPOTENCY_TTL_SECONDS`, ключ начинается заново) и не отменяет
проверку сессии и доступа при повторе (`401`/`404`). `POST /users`, `POST /chats` и `POST /auth/sessions`
ключа не имеют: повтор после таймаута может создать второй чат или вторую сессию, поэтому их не повторяют ни
клиент, ни LB — в HAProxy `disable-l7-retry` для всего, кроме `GET` и сообщений с ключом; отказ соединения
повторяется для всех, потому что запрос до реплики не дошёл.
**Что сломается при увеличении числа API, если сессии находятся в локальной памяти?** При round robin без
привязки токен, выданный репликой A, неизвестен остальным: при N репликах доля `401` на действующий токен —
около (N−1)/N, и проверка «разные реплики без повторного входа» не проходит. Выход на реплике A не отзывает
токен на B — отозванная сессия продолжает работать. Остановка или рестарт реплики теряют её сессии, и failover и
persistence с прежним токеном падают. Sticky-сессии лишь маскируют это: при отказе реплики клиенты всё равно
теряют вход, а нагрузка распределяется неравномерно. Здесь сессии хранятся в PostgreSQL (только SHA-256
токена) с общим кэшем и отметками отзыва в Valkey: 40 запросов одним токеном — 20 + 20 по репликам
(`lb-check.json`), выход `204` → `401` → `401` через LB (`faults.txt`), прежний токен живёт после рестарта всего
стенда (`persistence.txt`). То же относится к ключам идемпотентности: в памяти реплики повтор через соседа
создал бы дубль.
## Ограничения и следующие шаги
- Один Docker-host: потеря host, LB или PostgreSQL — отказ всего стенда. LB и БД — единственные точки отказа;
их резервирование вне рамок лабы.
- Цель failover-теста выбирает round robin (кто обслужил первое сообщение); второй прогон сразу после первого
и `make restore` попадает в ту же реплику, поэтому перед ним нужен один запрос через LB:
`make failover-evidence SHIFT=1` или `curl -s -o /dev/null "http://$(docker compose port lb 8080)/health/live"`
перед `make test-failover` (так сняты `failover-fa81adafcb69.txt` и второй failover в `clean-clone.txt`).
- `X-Instance-Id` раскрывает короткий ID контейнера — допустимо до лабы 7, где появится непрозрачный alias.
- Таблица ключей растёт вместе с историей (строка на сообщение); истёкшие ключи только перезаписываются при
повторном использовании, фоновой очистки нет.
- Запись в один горячий чат сериализуется блокировкой строки чата; повтор с ключом берёт ту же блокировку.
После трека 1 блокировка держится одну команду SQL, но фиксация (сброс WAL) остаётся внутри неё — это
следующий потолок для горячих чатов (раздел трека).
- Окно вывода из ротации удлиняет каждую остановку реплики на 2 с; оно рассчитано на проверки LB раз в
секунду: при большем `inter` окно нужно увеличить (это ловит `test_timeouts.py`).
- Время обнаружения измерено тремя прогонами на сценарий; верхняя граница — формула по параметрам проверки.
Замер считается от запуска команды отказа и включает задержку docker CLI и период опроса статистики LB, поэтому
может превысить формулу на эту величину; допуск замера — 0,25 с. На итоговом коде все замеры в пределах
формулы, раньше превышение в пределах допуска было у PostgreSQL (1,553 с), `SIGTERM` (1,609 и 1,515 с).
- Rolling update проверен со сменой кода без смены схемы. Миграция, несовместимая с работающей версией
(удаление или переименование столбца), потребовала бы двух выпусков expand/contract; в лабе таких нет.
- `scripts/rolling-update.sh` и `restore.sh` используют `--no-recreate`: после замены с другим `API_IMAGE`
обычный `make up` пересоздаст реплики под текущий конфиг — это ожидаемо.
- Секреты лежат файлами в `secrets/` на хосте (каталог `0700`, файлы `0644`, чтобы их читали непривилегированные
пользователи контейнеров); это учебное упрощение вместо менеджера секретов.
- Трек 1: подтверждено одно улучшение (запись одной командой, +15 % пика, p95 в 17 раз ниже колена); гипотезы
о троттлинге CFS как причине дорогих мелких реплик и о росте с числом чатов не проверялись. Переход отправки
на одну команду убрал агрегат `Chat` из записи: правила участия и порядка теперь в SQL адаптера и держатся
интеграционными тестами.