Files
mtusi2026lab3/REPORT.md
T

102 KiB
Raw Blame History

Отчёт — лабораторная 3

  • Автор, группа: Костылев Артём, БПИ2303
  • Целевая оценка: 5; трек «5» — трек 1 «Цена масштабирования»
  • Ветка: solution/bpi2303-kostylev. Уровень «3» подтверждён на 0a1f48bd73e5780c732356880c23fdb476bcff98; этап grade4 повторяет проверки уровня «4» на SQLAlchemy 2.0.45 / Alembic 1.16.5, код 252e3e3ffeea5004cfd9dc342e686af1417a77a2. Публикация в этом этапе не выполняется.
  • Трек «Цена масштабирования» ниже пока содержит исторические результаты raw asyncpg, которые не подтверждают производительность SQLAlchemy. Активный change 2026-11-05-adopt-sqlalchemy-alembic остаётся открытым до этапа трека.
  • Источники и инструменты: FastAPI, gunicorn + uvicorn-worker, dishka, pydantic, structlog, SQLAlchemy, Alembic, asyncpg как драйвер, argon2-cffi, redis-py, pytest, ruff, ty; версии — evidence/environment.txt и uv.lock. Документация установленного SQLAlchemy проверена через Context7: async sessions, проверка соединений; Alembic — async cookbook 1.16.5. Инфраструктура опирается на HAProxy 3.2 Manual, Docker Compose, PostgreSQL и k6. Решение перенесено из собственной ЛР2; текущий этап выполнен с помощью Codex.

Запуск из чистого clone

Требуются Docker с Compose v2, make и curl; системный Python 3.9+ — только для публичных проверок и scripts/probe.py. Образы сторонних сервисов закреплены версией и digest, API собирается из исходников.

git clone <repo> && cd mtusi2026lab3 && git checkout solution/bpi2303-kostylev
export COMPOSE_PROJECT_NAME=mtusi2026lab3-grade4
export LB_HTTP_PORT=18083 LB_STATS_PORT=23083 API_REPLICAS=2
export NO_PROXY=localhost,127.0.0.1,::1 no_proxy=localhost,127.0.0.1,::1

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,
                    # затем scripts/lb-wait.sh: ждёт, пока статистика LB покажет UP у всех запущенных реплик
make test           # публичный smoke через балансировщик (BASE_URL — опубликованный порт lb, см. ниже)
make lb-check       # ≥2 X-Instance-Id на одном токене и 20 × 8 параллельных POST с одним ключом → evidence/lb-check.json
make retry-check    # потерянный ответ на живой и на убитой реплике, повтор тем же ключом → evidence/retry.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        # повторный alembic upgrade head, версия и данные не меняются
make storage-evidence   # \d+ схемы, повтор миграций, префикс KDF, правила ignore и volumes проекта → evidence/

make down           # безопасная остановка: контейнеры и сети удаляются, volumes с данными остаются

make secrets идемпотентен: существующие файлы не перезаписываются, значения нигде не печатаются; make up вызывает его сам. make up ждёт healthy всех сервисов, включая балансировщик (он здоров, когда в ротации есть хотя бы одна реплика, /healthz на порту статистики), а затем — пока в ротацию войдут все реплики: вторая входит после rise 2 проверок, примерно через 2,5 с, и без этого ожидания make test-failover сразу после make up мог увидеть один X-Instance-Id. Миграции применяет одноразовый migrate под advisory lock до старта реплик; реплики схему не трогают. Публикуются только порты lb на 127.0.0.1: LB_HTTP_PORT (по умолчанию 8080) и LB_STATS_PORT (8404, статистика только для чтения). В текущем прогоне переменные окружения задают 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).

Прогон уровня «3» выполнен из рабочего checkout, на новом Compose-проекте mtusi2026lab3-grade3-final-20261105 и пустых volumes, с указанными портами и без явного BASE_URL. evidence/grade3-start.txt содержит пустой список volumes перед запуском, сборку, make up, docker compose ps -a и версию Alembic 0002_idempotency_keys. Старые volumes не удалялись. Исторический запуск именно из clone сохранён в evidence/clean-clone.txt (e049c26); он не подменяет проверки текущего SQL-слоя.

Собственные проверки и тулчейн:

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
make student-test PYTEST_ARGS=-vv      # то же с именами тестов (так снят 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 — все подряд):

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=7fc911c   # предыдущая SQLAlchemy-версия → текущая под нагрузкой
make rolling-update         # замена текущей сборкой (эквивалентная поочерёдная замена)

Генератор нагрузки — сервис k6 под профилем bench (с make up не стартует); RATE задаёт интенсивность.

Трек 1 «Цена масштабирования» — одна команда на всё и одна на графики. База очищается (down -v) перед каждой конфигурацией, после серий стенд возвращается к обычной конфигурации. Для отчёта серия A шла 2 ч 11 мин (с ожиданием тишины на VM), серия B — 34 мин, сравнение — 30 мин (по полю started в summary.csv):

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) ──┐   SQLAlchemy async 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, зоны связаны только схемой БД, воркер сам прерывает зависший при остановке запрос до SIGKILL мастера. После второго ревью этот ответ — 503 unavailable в формате контракта (был text/plain 500 uvicorn без X-Request-Id и X-Instance-Id), readiness стоит за портом Readiness, а окно вывода пишется событием service.draining (цикл 2026-10-30-close-lab3-second-review-gaps).

SQLAlchemy и Alembic. ORM-модели и Core-запросы остаются в инфраструктуре зон; домен — dataclass, pydantic — на HTTP-границе. Database создаёт async engine postgresql+asyncpg, async_sessionmaker(expire_on_commit=False) и ограниченный пул без overflow. Каждая операция получает собственный AsyncSession; незавершённая транзакция откатывается при закрытии.

pool_pre_ping=True проверяет соединение до его выдачи бизнес-операции. Без этого после возврата PostgreSQL readiness могла уже быть успешной, а регистрация через другое соединение получала 503. Проверка заменяет закрытое соединение; уже начатые транзакции автоматически не повторяются. Цена — дополнительное обращение к БД на выдаче открытого соединения; старые RPS трека к этому коду неприменимы.

One-shot migrate выполняет alembic upgrade head под advisory lock. Журнал — alembic_version, актуальная ревизия — 0002_idempotency_keys. На старом volume принимается только проверенная схема: alembic/legacy.py сверяет журнал и каталог PostgreSQL, сохраняет строки и прежний schema_migrations. Безусловного stamp нет. Свежая схема, сохранение данных, откат неуспешной миграции и два мигратора проверяются в student-tests/api/test_migrations.py; повтор на реальном стенде — evidence/migrations.txt.

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-оператор; после перехода на SQLAlchemy он выполняется в транзакции с явным session.commit() (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; сообщение и ключ фиксируются вместе через session.commit();
  5. ключ занят → следующая команда в том же AsyncSession читает квитанцию, моложе 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): после сигнала он поднимает флаг процесса DRAINING (shared/infrastructure/readiness.py) и пишет service.draining; адаптер DatabaseReadiness за портом Readiness проверяет флаг до пинга PostgreSQL, поэтому /health/ready отвечает 503, /health/live — 200, запросы обслуживаются как обычно, и так DRAIN_SECONDS=2 — дольше худшего обнаружения 503 балансировщиком (1,5 с). Затем uvicorn закрывает listener и дообрабатывает принятые запросы ещё SHUTDOWN_TIMEOUT_SECONDS − DRAIN_SECONDS − 1 = 3 с (не меньше таймаутов БД 1 + 2 с), а задачу запроса, не завершённого к этому сроку, отменяет и выходит с кодом 0. Отмену ловит конвейер: пишет request.cancelled и, если ответ ещё не начат, отвечает 503 unavailable в общем формате с X-Request-Id и X-Instance-Id, затем пробрасывает отмену дальше (без этого uvicorn отвечал своим text/plain 500 без заголовков контракта); весь срок — ≤5 с < gunicorn graceful_timeout 6 с < docker stop -t 7 хука < stop_grace_period: 8s < 10 с, поэтому мастер gunicorn не доходит до SIGKILL воркера. Результаты текущего кода и счётчики повторов LB приведены в таблице уровня «4» ниже. Хук останавливает конкретный контейнер, соответствие hostname проверяется через docker inspect. На реплику 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,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).

Три серии на SQLAlchemy 2.0.45 (252e3e3), команда make detection:

Отказ Как замечает LB Максимум обнаружения Замер, с
SIGTERM (docker stop -t 7) readiness 503 в окне вывода 1,5 с 1.069–1.266; остановка 2.535–2.665
docker kill отказ соединения, DNS 1,5 с 0.886–0.934
docker pause таймаут проверки 3,5 с 2.778–3.215
Остановка PostgreSQL readiness всех реплик 503 1,5 с до 0 UP 1.196–1.263; через LB 503 unavailable без X-Instance-Id

Для ответившей 503 реплики максимум — inter + (fall−1)·fastinter = 1,5 с; для зависшей — дополнительно fall·timeout check, итого 3,5 с. Измерение начинается перед запуском docker CLI, статистика LB опрашивается раз в 50 мс; допуск — 0,25 с. Все 12 замеров уложились в формулу даже без допуска, SIGTERM исключён до завершения остановки. Возврат после команды восстановления — 1.953–3.095 с. Данные: evidence/detection/run{1,2,3}/*.json, команда и SHA — evidence/grade4-detection.txt.

Цепочка таймаутов (проверяется тестом 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,4 с
DRAIN_SECONDS 2 с > обнаружения 1,5 с
дообработка после окна (uvicorn timeout_graceful_shutdown) SHUTDOWN − DRAIN − 1 = 3 с ≥ таймаутов БД 1 + 2 с; затем зависший запрос → 503 unavailable
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 → код 0, версия Alembic и счётчики строк неизменны). Лимиты: 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 общий ключ подписи курсора для всех реплик

Доказательства критериев

Проверки уровня «3» выполнены 2026-11-05 на 0a1f48bd73e5780c732356880c23fdb476bcff98. Стенд — mtusi2026lab3-grade3-final-20261105, LB 127.0.0.1:18083, статистика 23083; BASE_URL автоматически определяется Makefile. Даты, команды, коды завершения и SHA — в evidence/.

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
3.1 Документированный запуск, ≥2 API, общая БД и сессии, одна точка входа make up; make stack-evidence Новые пустые volumes; migrate завершился с 0, версия 0002_idempotency_keys; обе API healthy/UP, один PostgreSQL и Valkey; API без опубликованных портов, только LB на 18083/23083; container_name отсутствует evidence/grade3-start.txt, evidence/stack.txt, evidence/environment.txt
3.2 Один токен работает через разные реплики make lb-check 40 GET: 1b4a73f61b07 и 8ffe0c70f4ea по 20 ответов; hostname совпадают с двумя контейнерами evidence/grade3-lb-check.txt (актуальный lb-check.json повторно снят на этапе grade4), evidence/stack.txt
3.3 Остановка любой одной реплики, чтение/запись ≤10 с make test-failover ACTION_SCRIPT=scripts/stop-one.sh; docker compose ps -a; make restore; сдвиг round robin и повтор По очереди остановлены api-1 (8ffe0c70f4ea) и api-2 (1b4a73f61b07), обе с Exited (0); сосед продолжал работать. Первая запись после хука через 2.762 / 2.817 с, 129 / 128 успешных записей, 0 / 0 ошибок, по 2 наблюдаемых реплики; история подтверждённых сообщений сохранена evidence/failover-current-1.txt, evidence/failover-current-2.txt, evidence/grade3-restore-1.txt, evidence/grade3-restore-2.txt
3.4 Конкурентный одинаковый ключ и смена реплики make lb-check 20 раундов × 8 POST: 160 ответов 201, по 80 от каждой реплики; 20/20 одинаковых тел, одна копия в истории, другой body → 409 evidence/grade3-lb-check.txt (актуальный lb-check.json повторно снят на этапе grade4)
3.4 Безопасный повтор неподтверждённой записи make retry-check При блокировке чата 1.5 с клиент прекращает ожидание через 0.5 с. Повтор с тем же ключом на другой реплике: 201 с первой попытки, одна копия и тот же ID. Оба варианта — живая реплика и docker kill ожидающей реплики — прошли; повтор через 1.539 / 1.551 с evidence/retry.json, evidence/grade3-retry.txt
3.5 Публичный smoke, persistence и failover make test; make persistence-evidence (вызывает make test-persistence ACTION_SCRIPT=scripts/restart.sh); два failover выше Все PASS. При persistence прежний токен и история сохранились, IDs контейнеров те же, StartedAt у lb, обеих API, postgres, valkey и migrate обновились evidence/smoke.txt, evidence/persistence.txt, evidence/grade3-persistence.txt, evidence/failover-current-*.txt
Перенос lab2: миграции, схема и повтор без изменения данных make up на пустых volumes; make storage-evidence PK/FK/UNIQUE/CHECK и индексы показаны в схеме; Alembic head 0002_idempotency_keys. Повтор миграций: код 0, до/после 70 users, 24 sessions, 6 chats, 12 members, 284 messages и 284 keys, 1 строка версии evidence/schema.txt, evidence/migrations.txt, evidence/grade3-storage.txt
Перенос lab2: KDF, сессии, секреты make storage-evidence; make test; make test-faults Все 70 паролей — Argon2id, 24 хеша токенов по 32 байта; секреты и .env не отслеживаются Git. Basic/Bearer, logout 204 → 401 и абсолютный TTL сохраняются evidence/kdf.txt, evidence/secrets.txt, evidence/smoke.txt, evidence/faults.txt
Перенос lab2: отказы PostgreSQL/Valkey make test-faults 12 passed. PostgreSQL недоступен → 503 за ≤0.014 с, live внутри API 200; после старта ready через 2.0 с, прежний токен 200, 40 новых регистраций 201 через обе реплики без рестарта API. Valkey обходится для проверки сессии, logout при отказе 503 и после возврата 204 evidence/faults.txt
Негативные случаи и заголовки, гонки, миграции make student-test PYTEST_ARGS=-vv 271 passed, 12 deselected (стендовые тесты запущены отдельно). Включены X-Instance-Id/X-Request-Id на ошибках, ключи/доступ/TTL, 22 миграционных теста и первый POST после закрытия соединения evidence/student-tests.txt
Контракт, OpenAPI, форматирование и типы make check; make validate; make lint; uv lock --check; openspec validate --all --strict Все успешно; 107 файлов соответствуют формату. Diff нормативных файлов против upstream пуст evidence/checks.txt
Остановка без удаления данных make down; docker compose ps -a; docker volume ls --filter label=… Контейнеров этапа нет; оба volumes финального и исходного прогонов сохранены evidence/grade3-stop.txt, evidence/grade3-initial-stop.txt

Уровень «4» подтверждён на SQLAlchemy, код 252e3e3ffeea5004cfd9dc342e686af1417a77a2. Проект mtusi2026lab3-grade4-20261105, порты 18083/23083; запуск и версии — grade4-start.txt. Старые замеры raw asyncpg доступны через git show ef0b9a3:evidence/<имя>.

Нагрузка — k6 open model из edge в lb:8080: 100 запросов/с, 80 % отправок сообщений, 20 % чтений истории, 20 пользователей и 10 чатов, прогрев 10 с, замер 60/90 с. Отдельный зонд пишет каждые 0,1 с; после ошибки повторяет тот же ключ, после прогона читает все страницы своего чата и сверяет тела Message. Время восстановления теперь считается по завершению успешного ответа после последней ошибки; отсутствие такого ответа, дубли, потери, dropped iterations или отсутствующая статистика LB делают прогон неуспешным. 14 регрессионных тестов покрывают эти случаи. В итоговых прогонах ошибок зонда нет, поэтому recovery_s = 0; время первого успешного ответа после начала действия указано отдельно.

Критерий README Команда Наблюдение Доказательство
4.1 Readiness, SIGTERM и таймауты make student-test PYTEST_ARGS='-v -s student-tests/api/test_drain.py student-tests/unit/test_timeouts.py' 3 passed. LB 10 с > запрос 8 с > acquire+SQL 3 с; drain 2 с > обнаружение 1,5 с; shutdown 6 с < hook 7 с < grace 8 с. Настоящий gunicorn: ready/live 503/200, принятый запрос 201, зависший 503 с обоими заголовками; тестовое окно 1 с, порт закрыт через 1,05 с, выход через 2,44 с evidence/grade4-drain.txt
4.1 Обнаружение отказа make detection 12/12 PASS; SIGTERM 1,069–1,266 с, kill 0,886–0,934 с, pause 2,778–3,215 с, PostgreSQL 1,196–1,263 с. Все в пределах формулы без допуска; SIGTERM исключён до конца остановки evidence/grade4-detection.txt, evidence/detection/
4.2 Каждая реплика под нагрузкой make failover-each RATE=100 Два прогона, по 6001 запросу, 0 ошибок и dropped; конкретная реплика Exited (0), сосед healthy; исключённая реплика не обслуживает зонд, после restore возвращается; история полностью совпадает evidence/grade4-failover-each.txt, evidence/failover-each/<hostname>/action.txt, result.json, probe.csv, lb_up.csv, k6/
4.2 Общая идемпотентность make lb-check 20 × 8 параллельных POST: 160 × 201, по 80 от каждой реплики; 20/20 одинаковых тел, единственных копий и конфликтов другого body evidence/grade4-baseline.txt, evidence/lb-check.json
4.3 Лимиты и изоляция make limits; docker inspect во время k6 CPU/MiB: API 1/512 на реплику, LB 1/128, PostgreSQL 2/1024, Valkey 0,5/128, migrate 0,5/256, k6 2/512. Лимиты реально применены; только LB публикует порты на loopback, API read_only и без container_name; secrets/volumes/сети соответствуют политике evidence/limits.txt, evidence/grade4-runtime-limits.txt
4.3 Отрицательная проверка политики scripts/limits.py с override из лога Все 5 нарушений обнаружены, ожидаемый exit 1; конфигурация не применялась к стенду evidence/grade4-limits-negative.txt, evidence/limits-violations.txt
4.4 Поочерёдная замена make rolling-update RATE=100; make rolling-update FROM_REV=7fc911c RATE=100 В обоих прогонах минимум 2 UP, по 9001 запросу, 0 ошибок/dropped, 913/913 сообщений зонда сохранены; после действия отвечают только новые контейнеры. Старые/новые image ID записаны для каждой замены evidence/grade4-rolling*.txt, evidence/rolling/, evidence/rolling-from-7fc911c/
4.4 Один migrate и совместимость scripts/rolling-update.sh; повтор make migrate В каждом action.txt один migrate перед первой заменой. Обе версии SQLAlchemy используют ту же схему Alembic; повтор upgrade head не меняет версию и счётчики таблиц evidence/rolling/action.txt, evidence/rolling-from-7fc911c/action.txt, evidence/grade4-migration-repeat.txt

Измерения поочерёдного отказа:

Остановленный hostname RPS p50/p95/p99, мс Обнаружение, с Первый успешный ответ, с Возврат в LB от начала действия, с Подтверждено = в истории
7cfd91ddf780 100.02 2.97/3.86/4.47 0.884 0.023 14.885 645 = 645
5bbf259ff136 100.02 2.98/3.88/4.53 1.498 0.111 14.990 642 = 642

Возврат включает намеренные 10 с без реплики и её запуск; это не перерыв доступности записи. Счётчики LB wretr/wredis/econ/eresp/hrsp_5xx равны нулю в обоих отказах и обоих rolling update. Опрос LB под нагрузкой — каждые 100 мс; более короткий провал таким измерением не исключается.

Rolling update RPS p50/p95/p99, мс Действие, с Первый успешный ответ, с Минимум UP
Текущая сборка 100.01 3.01/3.89/4.53 10.734 0.055 2
7fc911c → текущая 100.01 2.99/3.85/4.47 13.836 0.082 2

Ограничение миграционного доказательства: 7fc911c — предыдущая SQLAlchemy-версия до исправления восстановления пула, с той же схемой 0002_idempotency_keys. Миграция в rolling update — no-op. Это подтверждает однократный запуск и совместную работу версий на существующей схеме, но не произвольный DDL под нагрузкой. Будущие миграции требуют expand/contract и отдельной проверки совместимости. Подготовительная установка старого образа выполняется до запуска нагрузки; непрерывность гарантируется измеренным окном поочерёдной замены. Новый image ID той же сборки может отличаться из-за аттестации BuildKit.

Публичные сценарии после замены, итоговые проверки и остановка — evidence/grade4-public.txt, grade4-checks.txt, grade4-student-tests.txt, grade4-stop.txt. Повтор persistence в grade4-persistence-scoped.txt фиксирует неизменные IDs и обновлённые StartedAt всех шести контейнеров. Полный набор собственных тестов — 285 passed, 12 deselected (stack). Неуспешный smoke через системный прокси, прерванный detection, первоначальные ошибки форматирования и некорректная отрицательная Compose-fixture сохранены; причины и итоговые повторы перечислены в evidence/README.md. Эти попытки не считаются PASS.

Трек 1 «Цена масштабирования» — исторические результаты до SQLAlchemy. Подробности, таблицы и выводы — в разделе трека ниже; поля 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 при предложенных 5 400 rps в двух повторах из трёх не насыщен) / 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 ждут блокировку 12,8 → 0,15 соединения, idle in transaction 4,5 → 0, CPU на запрос API −14 %, PostgreSQL −26 %, p95 64,5 → 3,7 мс (у «до» больше чужой нагрузки на VM; в повторе 1 при равной — 35,7 → 5,4 мс); пик 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; на коде до SQLAlchemy e049c26 — весь уровень «3», make retry-check, make test-faults и make level4 под k6 после улучшения: 240 passed, smoke PASS, 160 × 201, failover 131 запись / 0 ошибок, persistence PASS; на коде до SQLAlchemy — 243 passed, 12 тестов стенда, retry-check и все строки 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

Эксперименты и отказы

Текущий уровень «3», код 0a1f48b; все числа ниже взяты из указанных файлов.

Сценарий Наблюдение Сохранность и возврат Evidence
Остановка api-1 129 записей, 0 ошибок; первая запись после хука через 2.762 с История без дублей, api-2 работает, api-1 Exited (0), затем восстановлена failover-current-1.txt, grade3-restore-1.txt
Остановка api-2 128 записей, 0 ошибок; первая запись после хука через 2.817 с История без дублей, api-1 работает, api-2 Exited (0), затем восстановлена failover-current-2.txt, grade3-restore-2.txt
Потерянный ответ и kill Таймаут клиента 0.5 с при блокировке чата 1.5 с; повтор через соседа 201 Одна копия, одинаковый ID; оба варианта pass retry.json, grade3-retry.txt
Полный restart StartedAt всех сервисов обновились, IDs прежние Старая сессия и история сохранились persistence.txt
PostgreSQL остановлен 503 за ≤0.014 с, live внутри API 200; LB исключил реплики ещё через 0.86 с После запуска ready через 2.0 с; 40 регистраций через 2 реплики без рестарта API faults.txt
Valkey остановлен Живой токен 200, неизвестный 401; logout 503 После запуска logout 204; рестарт Valkey сохраняет отзыв faults.txt
Повтор Alembic Код 0, head не меняется Все счётчики строк до и после равны migrations.txt, grade3-storage.txt

Первый прогон не был успешным: grade3-faults.txt содержит 11 passed / 1 failed — регистрация получила 503 после возврата PostgreSQL. grade3-pool-regression-before.txt воспроизводит закрытое простаивающее соединение; pool_pre_ping устранил ошибку (grade3-pool-regression-after.txt, итоговый student-tests.txt). Полный набор также был прерван на коллизии порта тестового gunicorn с LB (46 passed, grade3-student-tests-interrupted.txt), затем упал при старте тестовой БД (70 passed / 201 errors, полный обезличенный вывод сжат в grade3-student-tests-startup.txt.gz). Исправлены изоляция порта, дедлайн ожидания и повтор временного SQLSTATE 57P03. После исправлений итоговые 271 собственный и 12 стендовых тестов прошли. Публичные проверки не менялись.

Трек 5 — трек 1 «Цена масштабирования» (исторические замеры)

Все числа этого раздела получены до SQLAlchemy и pool_pre_ping. Новые серии относятся к следующему этапу; до их завершения эти результаты не являются доказательством «5» для текущего кода.

Гипотезы (записаны в предложении до первого прогона). 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 млн — сравнения. Пики серии A (6 830 rps) сняты на базе 0,58–0,74 ГБ у 1×4, 0,58–0,87 ГБ у 2×2 и 0,87–1,02 ГБ у 4×1, точка 8×1 серии B при 5 400 rps — на 0,17–0,31 ГБ. В контроле пула база между вариантами не очищалась и выросла с 7,7 МБ до 2,26 ГБ за 15 прогонов; в контроле размещения у каждой конфигурации своя свежая база, до 0,40 ГБ.
  • Насыщение шага: ошибок > 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

Перегрузка проявляется как очередь в LB (до 1 000 одновременных сессий — предел VU k6), рост задержки и сброшенные итерации, а не как ошибки: доля неуспешных во всех прогонах таблиц ≤ 0,02 %, timeout queue LB (3 с) не достигался — у LB econ, eresp и wretr равны 0, а единичные 5xx отдали сами реплики (hrsp_5xx серверов в lb_stats.csv, проваленные проверки k6). В сериях это один прогон: 1×4 при 600 rps, повтор 2 — 3 ответа из 16 883 во время короткой остановки записи (p99 645 мс, до 17 соединений ждут блокировку, dropped_iterations 1 117), ещё 18 — в прогреве повтора 3, вне окна замера. Код ответа (500 или 503) сырьё LB не различает; вероятнее всего это 503 по таймауту ожидания соединения из пула (1 с): самые долгие запросы этого прогона шли до 1,5 с. В контроле такие ответы были только у пула 16 (таблица ниже). Генератор нагрузки не был узким местом: 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 на реплику. Варианты чередуются по повторам, но в одном и том же порядке (пул 4 → 8 → 16 → maxconn 16 → 64), и база между ними не очищается: 7,7 МБ перед первым прогоном, 2,26 ГБ перед последним, поэтому каждый следующий вариант повтора идёт на базе больше предыдущего. Вывод от этого не зависит: в повторе 3 при почти одинаковой базе (1,96–2,26 ГБ) порядок тот же — 5 394 / 4 966 / 4 077 rps у пула 4 / 8 / 16, а пул 4 в повторах 1 и 3 даёт 5 358 и 5 394 rps на базе 7,7 МБ и 1,96 ГБ:

Вариант 8×1 Успешные RPS, медиана (min–max) p95, мс Ждут блокировку / соединений с БД Очередь LB, max CPU API / PostgreSQL, % Неуспешные запросы по повторам
пул 4 ≥5 358 (5 316–5 394), не насыщен в 2 из 3 179 14,7 / 32 739 517 / 163 0 / 0 / 0
пул 8, maxconn 32 (как в серии B) 4 677 (3 749*–4 966) 273 47,0 / 64 744 471 / 170 0 / 0 / 0
пул 16 3 789 (2 291*–4 077) 355 102,3 / 128 744 372 / 180 1* / 5 / 3
maxconn 16 4 526 (3 776*–4 917) 258 47,3 / 64 872 424 / 177 0 / 0 / 0
maxconn 64 4 525 (4 005*–4 908) 299 46,8 / 64 487 442 / 178 0 / 0 / 0

Неуспешные запросы — проваленные проверки message 201 k6 (из 69–122 тыс. запросов прогона); их отдали реплики (hrsp_5xx серверов, у LB eresp/econ 0). У пула 16 самые долгие записи шли 2,2–2,8 с, дольше lock_timeout 2 с, — это 503 по таймауту блокировки: чем больше пул, тем больше соединений в очереди за строкой чата и тем чаще запись не дожидается её за 2 с. Это ещё один довод в пользу малого пула.

Очередь LB пик не меняет: при maxconn 16, 32 и 64 медианы 4 526 / 4 677 / 4 525 rps, интервалы перекрываются, меняется только то, где ждут запросы (в очереди LB или в соединениях реплики). Пул меняет пик, но в обратную сторону: чем он меньше, тем выше пропускная способность — 4 соединения на воркер дают не меньше 5 358 rps (интервал не пересекается с пулом 8; при 5 400 rps пул 4 почти не насыщен, поэтому это нижняя граница его пика), 16 — 3 789. Число ждущих блокировку растёт вместе с пулом (14,7 → 47,0 → 102,3), а запись в чат длится дольше (среднее время команды записи 1,7–3,4 → 12,2–15,4 → 35–56 мс по повторам; среднее по всем строкам этой команды в pg_statements.csv, взвешенное по вызовам; 56 мс — возмущённый повтор 1 пула 16): пул не ограничивает сверху, а, наоборот, впускает в 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 против 4×1» для этого не хватает: пул 4 снят только при 5 400 rps и почти не насыщен, его пик не измерен, поэтому с 5 928 у 4×1 он не сравнивается; цену ожидающих показывает сам контроль пула (пул 8 при 64 соединениях — 4 677 rps против ≥5 358 у пула 4). Первая попытка этой части отброшена: в четырёх прогонах 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 % (меньше операторов и обращений). Чужая нагрузка на VM при этих прогонах была разной: у «до» 53 / 82 / 74 % ядра, у «после» 50 / 15 / 4 % (cpu_other, ниже порога отбраковки), поэтому кратность по p95 завышена шумом. Вывод опирается на то, что от шума не зависит: блокировку строки чата ждут 12,8 → 0,15 соединения, idle in transaction 4,5 → 0, CPU на запрос ниже; а в повторе 1, где чужая нагрузка почти равна (53 и 50 %), p95 35,7 → 5,4 мс — в 6,7 раза. За коленом пик вырос на 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. Актуальные проверки SQLAlchemy перечислены в строках 4.x выше.

Выводы.

  • H1 подтверждена частично. Потолки 1×4, 2×2 и 4×1 действительно в пределах ±15 % (4 724–5 375, −12 % у 4×1; 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, отдельно не измерялось. Соседние стенды других лаб работали всё время замеров; отбраковка ловит нагрузку больше одного ядра, меньшая остаётся шумом (cpu_other каждой строки summary.csv; для серий A, B и сравнения ещё и host-others.csv с именами соседей, контрольные прогоны 30.10 он не покрывает), а задержки дисковой подсистемы VM не ловит вовсе (отброшенная первая попытка контроля размещения). Такой шум не равен между вариантами: при 3 600 rps у «до» чужой CPU 53–82 %, у «после» 4–50 %, поэтому вывод сравнения опирается на ожидание блокировки и CPU на запрос, а не на кратность p95 (раздел улучшения). 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), поэтому старшие интенсивности идут на большей базе, чем младшие, и конфигурации на пике сравниваются на разной базе: из-за разного числа отбраковок 4×1 серии A шла на 0,87–1,02 ГБ, 1×4 — на 0,58–0,74 ГБ, а 8×1 серии B — на 0,17–0,31 ГБ. Смещение работает против 4×1: вывод «8×1 хуже 4×1» оно делает только осторожнее, а в −12 % у 4×1 против 1×4 база может давать вклад. Внутри конфигурации рост базы на 0,16 ГБ меняет пик не больше чем на 1 % (1×4: 5 384 → 5 332 rps, у 4×1 тренда нет), поэтому этот вклад, скорее всего, мал, но отдельно не измерялся. Сравнение до/после сделано на одной конфигурации 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,069–1,266 с, kill — 0,886–0,934 с, зависание (docker pause) — 2,778–3,215 с по таймауту проверки (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,196–1,263 с и сам отвечает 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). Потерянный ответ воспроизведён на стенде (make retry-check, retry.json): запись ждёт блокировку строки чата дольше таймаута клиента, клиент повторяет её с тем же ключом через LB — и когда реплика жива (она сама отвечает 201 уже без клиента), и когда её убили, пока запрос ждал; в обоих случаях повтор получает 201 с тем же id, а в истории одна копия. Ключ не защищает от другого тела с тем же ключом (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). То же относится к ключам идемпотентности: в памяти реплики повтор через соседа создал бы дубль.

Ограничения и следующие шаги

Следующий этап — повторный трек «Цена масштабирования» на SQLAlchemy. Уровни «3» и «4» подтверждены; цифры улучшения трека в списке ниже остаются историческими.

  • Один 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-current-2.txt).
  • X-Instance-Id раскрывает короткий ID контейнера — допустимо до лабы 7, где появится непрозрачный alias.
  • Таблица ключей растёт вместе с историей (строка на сообщение); истёкшие ключи только перезаписываются при повторном использовании, фоновой очистки нет.
  • Запись в один горячий чат сериализуется блокировкой строки чата; повтор с ключом берёт ту же блокировку. В SQLAlchemy блокировка держится до явного COMMIT после одного изменяющего SQL-оператора — это следующий потолок для горячих чатов (раздел трека).
  • Окно вывода из ротации удлиняет каждую остановку реплики на 2 с; оно рассчитано на проверки LB раз в секунду: при большем inter окно нужно увеличить (это ловит test_timeouts.py).
  • Время обнаружения измерено тремя прогонами на сценарий; верхняя граница — формула по параметрам проверки. Замер считается от запуска команды отказа и включает задержку docker CLI и период опроса статистики LB, поэтому может превысить формулу на эту величину; допуск замера — 0,25 с. На текущем коде все 12 замеров в пределах формулы без использования допуска (evidence/grade4-detection.txt).
  • Rolling update проверен со сменой кода без смены схемы. Миграция, несовместимая с работающей версией (удаление или переименование столбца), потребовала бы двух выпусков expand/contract; в лабе таких нет.
  • scripts/rolling-update.sh и restore.sh используют --no-recreate: после замены с другим API_IMAGE обычный make up пересоздаст реплики под текущий конфиг — это ожидаемо.
  • Секреты лежат файлами в secrets/ на хосте (каталог 0700, файлы 0644, чтобы их читали непривилегированные пользователи контейнеров); это учебное упрощение вместо менеджера секретов.
  • Исторический трек 1 до SQLAlchemy: подтверждено одно улучшение (запись одной командой, +15 % пика, p95 в 17 раз ниже колена); гипотезы о троттлинге CFS как причине дорогих мелких реплик и о росте с числом чатов не проверялись. Переход отправки на одну команду убрал агрегат Chat из записи: правила участия и порядка теперь в SQL адаптера и держатся интеграционными тестами.