# Отчёт — лабораторная 3 - Автор, группа: Костылев Артём, БПИ2303 - Целевая оценка: **5**; трек «5» — **трек 1 «Цена масштабирования»** - Commit/PR: ветка `solution/bpi2303-kostylev`. Код (`src/`, `compose.yaml`, `Dockerfile`, `infra/`, хуки) последний раз менялся в коммите `22f0e62` — улучшение трека 1 (отправка сообщения одной командой SQL); до него `107fbbb` добавил закрепление CPU для замеров (по умолчанию выключено). Доказательства уровней «3» и «4» (`smoke`, `stack`, `lb-check`, `hooks`, `failover-*`, `persistence`, `faults`, `detection/`, `failover-each/`, `rolling*/`, `limits-violations`) сняты на `e00eb6c` — коде уровня «4», схема и KDF (`schema`, `migrations`, `kdf`, `secrets`) — на `0796e29`, с тех пор миграции не менялись. На итоговом коде повторены: запуск из чистого clone с миграциями на пустом volume, smoke, 20 гонок ключа, failover, persistence, повтор миграций, остановка и удаление данных (`clean-clone.txt`, `e88673d`), все собственные тесты (`student-tests.txt`, `e88673d`), лимиты и изоляция (`limits.txt`, `e88673d`) и проверки после улучшения (`track1/after-checks.txt`, `dde113b`). После `22f0e62` менялись только обвязка замеров трека (`Makefile`, `scripts/scaling.py`, `tools/`), openspec, отчёт и `evidence/`. Каждый файл `evidence/` несёт дату и коммит в первой строке, индекс — `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 && 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://localhost:8080/health/ready; do sleep 1; done # готовность через LB scripts/lb-wait.sh 2 # обе реплики UP в статистике LB make test # публичный smoke через балансировщик 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 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`, а проверки запускались с `BASE_URL=http://localhost:18083`. Последний прогон из свежего clone (`evidence/clean-clone.txt`, коммит `e88673d`, каталог `mtusi2026lab3-clean` — свой compose-проект и пустые volumes): `config` — `valid`; `make up` — 17 с, `migrate` применил `0001_init` и `0002_idempotency_keys` и вышел с кодом 0; smoke `PASS`; 40 `GET` одним токеном — 20 + 20 на две реплики, 160 × `201` в гонках ключа; failover — 132 записи, 0 ошибок, первая запись через 2.985 с, остановленная реплика `Exited (0)`; persistence `PASS`; повторный `migrate` — `up to date`; после `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 python3 -m venv /tmp/oas && /tmp/oas/bin/pip install -r requirements-dev.txt # .venv от uv валидатора не содержит make validate PYTHON=/tmp/oas/bin/python # полная валидация OpenAPI 3.1 и примеров make test-faults BASE_URL=… # тесты стенда лабы 2 (Valkey, PostgreSQL, гонки) через балансировщик make failover-evidence BASE_URL=… # docker inspect реплик до/после, make test-failover, логи остановленной, restore make persistence-evidence BASE_URL=… # 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/ 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 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 тестом). **`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`. Текст проверяется до записи; если он невалиден, отдельным чтением проверяется членство, чтобы посторонний получил `404`, а не `400`. Сообщение и ключ фиксируются вместе или не фиксируются вовсе; маркера «в обработке» нет, поэтому после гибели реплики посреди запроса повтор с тем же ключом создаёт сообщение один раз. Одновременные повторы одного ключа всегда идут в один чат и ждут на блокировке его строки; дождавшийся получает конфликт ключа, а следующая команда в `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` = 3 с; весь срок — gunicorn `graceful_timeout` 5 с < `docker stop -t 6` хука < `stop_grace_period: 8s` < 10 с. Без окна (уровень «3») gunicorn закрывал listener сразу, и запрос, уже стоявший в очереди `accept`, LB видел как обрыв после отправки: для `GET` и сообщений с ключом это повтор, для `POST /users`, `/chats` и входа — `502`. Разница видна в счётчиках LB: rolling update со старой версии — `wretr` 2, `wredis` 54, `eresp` 2, с новой — все 0 (`evidence/rolling*/result.json`). Хук `stop-one.sh` теперь идёт 2,72 с (`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,71 с; действие (`stop-one.sh`) завершилось через 2,49 с | | процесс убит (`docker kill`) | отказ соединения, DNS | 1,5 с | 0,67 с | | процесс завис (`docker pause`) | таймаут проверки | `inter + (fall−1)·fastinter + fall·timeout check` = 3,5 с | 2,76 с | | PostgreSQL остановлен | readiness всех реплик `503` | 1,5 с до 0 `UP`; LB сам отвечает `503` | 1,23 с; `/health/live` через LB → `503 unavailable` без `X-Instance-Id` | Допуск замера — 0,25 с (задержка docker CLI до сигнала и опрос статистики LB раз в 50 мс); время считается от запуска команды отказа. Возврат в ротацию после восстановления — 1,96–3,08 с. **Цепочка таймаутов** (проверяется тестом `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 с | ≤ дообработки 3 с после окна | | LB `timeout check` | 1 с | > readiness 0,8 с | | `DRAIN_SECONDS` | 2 с | > обнаружения 1,5 с | | `SHUTDOWN_TIMEOUT_SECONDS` (gunicorn `graceful_timeout`) | 5 с | > окна; < `STOP_TIMEOUT` хука | | `STOP_TIMEOUT` хука `stop-one.sh` | 6 с | < `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 6`, реплика остаётся остановленной, неизвестный 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 с и 5 с (заданы в 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 шли с `BASE_URL=http://localhost:18083` (см. «Запуск»). Коммит каждого прогона — в первой строке файла и в шапке отчёта. | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | | Публичный smoke | `make test BASE_URL=http://localhost:18083` | `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` | | Запуск из чистого clone | `git clone`, `make secrets`, `config --quiet`, `make up`, ожидание `/health/ready`, тесты, `make migrate`, `make down`, `make reset-data` | `valid`; `make up` 17 с, `migrate` применил `0001`/`0002` и `Exited (0)`; smoke, failover, persistence `PASS`; повтор миграций `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` | `{"27de23496b0f": 20, "a3536e394b3f": 20}` — ровно hostname двух контейнеров `api`; на итоговом коде — 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`; второй прогон после сдвига round robin | реплика `27de23496b0f`: первая запись после хука через 2.638 с от его старта, 133 записи после, 0 ошибок; реплика `a3536e394b3f`: 2.689 с, 130, 0; после теста `exited` именно target, вторая `running`; в логе остановленной — сигнал, окно вывода из ротации с readiness `503`, закрытие и выход; `PASS: failover …` | `evidence/failover-27de23496b0f.txt`, `evidence/failover-a3536e394b3f.txt` | | **3.3** Хук останавливает только заданную реплику | `scripts/stop-one.sh` с hostname, с неизвестным ID и без него | хук 2.72 с (окно вывода 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`, счётчики строк до и после равны (сообщений столько же, сколько ключей: 497 и 497) | `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=http://localhost:18083` | 10 passed: гонка регистрации 201×1/409×49, чат с несуществующим участником `400`, остановка Valkey и PostgreSQL (`503` за ≤0.014 с; live внутри реплики `200`; LB исключил обе реплики ещё через 0.61 с и сам отвечает `503`; готовность через 2.1 с), рестарт API | `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 с; остановка 5 с < хук 6 с < `stop_grace_period` 8 с; настоящий gunicorn по `SIGTERM`: ready/live `(503, 200)` в окне, порт закрыт через 1.74 с, запрос, принятый до сигнала и дописанный после закрытия порта, получил `201`, выход через 2.11 с | `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 с (зависание); измерено: `SIGTERM` 0.706 с — раньше конца остановки (2.493 с), `kill` 0.665 с, `pause` 2.756 с, PostgreSQL 1.227 с до 0 `UP` и `503 unavailable` от LB; возврат 1.96–3.08 с; все `pass: true` | `evidence/detection/{sigterm,kill,pause,postgres}.json` | | **4.2** Последовательно остановить каждую реплику (с восстановлением предыдущей); RPS, ошибки, время восстановления | `make failover-each` (на реплику: `stop-one.sh`, 10 с без неё, `restore.sh` — всё внутри окна нагрузки) | `a3536e394b3f`: 100.02 rps, 6001 запрос k6, ошибок 0, p50/p95/p99 2.4/3.41/5.1 мс, обнаружение 1.515 с, возврат в ротацию через 14.111 с от начала действия (действие 14.511 с: хук + 10 с + restore), зонд 635 записей / 0 ошибок, пока реплика исключена, её `X-Instance-Id` не встречался; `27de23496b0f`: 100.02 rps, 0 ошибок, 2.44/3.42/5.08 мс, 0.894 с, 14.392 с, 635/0; счётчики LB `wretr`/`wredis`/`econ`/`eresp`/`hrsp_5xx` — 0 | `evidence/failover-each/summary.json`, `evidence/failover-each//` | | **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», затем замена на текущую версию с запасом +1) | `lb_up_min` 2 из 2, k6 100 rps, 9000 запросов, ошибок 0, зонд 897/0; после замены отвечают только новые контейнеры (`7a4c320f9b13`, `00548d9b229e` → `28af1eaa77c8`, `f3f2f7801b56`; образ `cbd83541c3e5` → `13e52dc26774`); старые реплики без окна дали `wretr` 2, `wredis` 54, `eresp` 2 — запросы, повторённые LB на соседа | `evidence/rolling-from-8d28d45/result.json`, `action.txt` | | **4.4** То же на текущей версии | `make rolling-update` | `lb_up_min` 2, 9001 запрос, ошибок 0, зонд 904/0, все реплики новые (`28af1eaa77c8`, `f3f2f7801b56` → `239278da12b2`, `58b4bb97f5db`); все счётчики LB 0. Образ пересобран из той же ревизии, ID другой (`13e52dc26774` → `9d621745fe6b`): 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,2 мс в среднем и 98,7 % времени топ-20 операторов | `evidence/track1/series-b/summary.csv`, `series-b/base-8x1_rate5400_rep*/pg_statements.csv`, `plots/utilisation.png` | | Графики и сырые данные | `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 гонок ключа через LB, `make test-failover`, `make test-persistence` на новом образе | 240 passed; smoke `PASS`; 160 × `201`, 20/20 раундов с одной копией и `409`; failover 131 запись, 0 ошибок, 2.728 с; persistence `PASS`; повторено из чистого clone на `e88673d` | `evidence/track1/after-checks.txt`, `evidence/clean-clone.txt` | ## Эксперименты и отказы Стенд: 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`, `27de23496b0f`) | запись продолжается ≤10 с, target больше не отвечает | 0 неудачных попыток, 133 записи после хука; после теста `27de23496b0f` `exited`, `a3536e394b3f` `running` (`failover-27de23496b0f.txt`) | первая запись после хука через 2.638 с от его старта (хук ≈2,7 с из-за окна вывода; запись не прерывалась); потерь и дублей нет | | stop api#2 (после `restore`, `a3536e394b3f`) | то же для второй реплики | 0 неудачных попыток, 130 записей после хука; `a3536e394b3f` `exited` (`failover-a3536e394b3f.txt`) | 2.689 с; потерь и дублей нет | | Полный restart (`restart.sh`: lb, api ×2, postgres, valkey) | прежний токен работает, история побайтно та же | persistence `PASS`; ID контейнеров прежние, `StartedAt` всех обновился: postgres, valkey, lb — 16:57:13, api — 16:57:19–20 при старте прогона в 16:57:10 (`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.61 с (`faults.txt`) и 1.227 с (`detection/postgres.json`) и отвечает `503` сам | после `start` готовность через 2.1–2.5 с без рестарта API | | `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 6`) | LB исключает её раньше, чем она закроет порт | исключена через 0.706 с, остановка завершилась через 2.493 с (`detection/sigterm.json`); код выхода 0, в логе — окно 2 с и readiness `503` (`hooks.txt`, `failover-*.txt`) | возврат после `restore` 1.959 с | | Процесс реплики убит (`docker kill`) | исключение ≤1,5 с | 0.665 с (`detection/kill.json`) | `restore` 3.078 с | | Процесс реплики завис (`docker pause`) | исключение ≤3,5 с по таймауту проверки | 2.756 с; через LB — `200` от соседа (`detection/pause.json`) | после `unpause` 2.383 с | | Поочерёдная остановка каждой реплики под 100 rps | 0 ошибок, запись не прерывается, реплика возвращается | обе реплики: k6 0 ошибок из 6001, зонд 0 из 635, p99 ≈5 мс, повторов LB 0 (`failover-each/summary.json`) | обнаружение 0.894–1.515 с; снова в ротации через 14.111–14.392 с от начала действия (хук + 10 с без реплики + `restore`) | | Rolling update с уровня «3» под 100 rps | ёмкость не ниже 2, 0 ошибок, после — только новые реплики | `lb_up_min` 2, 0 ошибок из 9000, зонд 0 из 897; старые реплики без окна: `wretr` 2, `wredis` 54, `eresp` 2 | замена двух реплик за 7.695 с | | Rolling update текущей версии под 100 rps | то же, и без повторов LB | `lb_up_min` 2, 0 ошибок из 9001, зонд 0 из 904, все счётчики LB 0 | 11.782 с | ### Трек 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), пока два шага подряд не насыщены во всех повторах. **3 повтора на точку**: в итоговых таблицах 123 прогона (63 + 42 + 18), 9,6 млн запросов. - Набор данных: перед каждой конфигурацией `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). Три шага остались возмущёнными и после трёх повторов и вошли в таблицы с пометкой `disturbed`: серия A 4×1 при 3 040 rps, повтор 2 (чужой CPU 138 %), сравнение «после» при 5 400 и 8 100 rps, повтор 1 (105 и 136 %). Первая попытка серии 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,2 мс и занимает 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 МиБ четырьмя). **Улучшение: запись сообщения одной командой 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 597) | 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,7 / 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`). **Выводы.** - 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 **подтверждена с поправкой.** Линейный рост — только до двух реплик (1,71× на 2 CPU), 4 реплики дают 2,75×, а 8 — **меньше, чем 4** (2,48×): ретроградное масштабирование, κ > 0, максимум около 5 реплик. Насыщенное звено — общая БД, но не её CPU (89 %) и не `max_connections` (64 из 200), а сериализованная по строке чата запись, растянутая обращениями к приложению; LB далёк от лимита. - 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 — свойство этой машины, сравнимы только конфигурации внутри одного прогона. Соседние стенды других лаб работали всё время замеров; отбраковка ловит нагрузку больше одного ядра, меньшая остаётся шумом (`host-others.csv`). 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`). ## Ответы на вопросы защиты **Чем отказ процесса отличается от отказа узла?** Отказ процесса — это одна реплика: контейнер остановлен, убит или завис, а host, LB, PostgreSQL и соседняя реплика работают. Его ловит проверка готовности LB, и трафик уходит на соседа: `SIGTERM` — 0,71 с, `kill` — 0,67 с, зависание (`docker pause`) — 2,76 с по таймауту проверки (`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 исключает обе реплики за 1,23 с и сам отвечает `503 unavailable` (`detection/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. - `X-Instance-Id` раскрывает короткий ID контейнера — допустимо до лабы 7, где появится непрозрачный alias. - Таблица ключей растёт вместе с историей (строка на сообщение); истёкшие ключи только перезаписываются при повторном использовании, фоновой очистки нет. - Запись в один горячий чат сериализуется блокировкой строки чата; повтор с ключом берёт ту же блокировку. После трека 1 блокировка держится одну команду SQL, но фиксация (сброс WAL) остаётся внутри неё — это следующий потолок для горячих чатов (раздел трека). - Окно вывода из ротации удлиняет каждую остановку реплики на 2 с; оно рассчитано на проверки LB раз в секунду: при большем `inter` окно нужно увеличить (это ловит `test_timeouts.py`). - Время обнаружения измерено одним прогоном на сценарий; верхняя граница — формула по параметрам проверки, а замер её подтверждает. Время считается от запуска команды отказа, с допуском 0,25 с на docker CLI и опрос. - Замеры уровня «4» под нагрузкой (`detection`, `failover-each`, `rolling*`) и тесты отказов `faults.txt` сняты на `e00eb6c`, до того как трек 1 переписал отправку сообщения; на итоговом коде повторены smoke, гонки ключа, failover, persistence, миграции с нуля, лимиты и собственные тесты, но не прогоны под k6. - 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 адаптера и держатся интеграционными тестами. - Процесс openspec: правило `config.yaml` «proposal в пределах 400 слов» нарушено в `add-lab3-scaling-cost` — 405 слов по `wc -w` с разметкой (у `add-lab3-failover-operations` ровно 400, у `add-lab3-load-balanced-replicas` — 368). Архив закоммичен, историю не переписываю.