Files
mtusi2026lab3/REPORT.md
T
2026-10-13 18:02:20 +03:00

266 KiB
Raw Blame History

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

  • Автор, группа: Сафронов Роман Николаевич, БВТ2301
  • Целевая оценка 5; выбранный трек 5: трек 1 «Цена масштабирования» (серии сняты, change scaling-bench; одно подтверждённое улучшение — пул без переполнения, change scaling-improvement, засчитано с оговоркой: раздел «Улучшение по найденному узкому месту: пул без переполнения»)
  • Commit/PR: ветка solution/bvt2301-safronov, PR «ЛР 3 — БВТ2301 — Сафронов — на 5» — ссылка на PR после публикации (push и PR делает автор). Из чистого clone проверен commit 8fa12f5 (2026-10-13, код change fix-known-issues, evidence/tests/clean-clone-final.md). После него менялись только документы: REPORT.md, evidence/tests/clean-clone-final.md и файлы change; код приложения, Dockerfile, pyproject.toml, uv.lock, compose, конфигурации, скрипты, тесты и bench/ — нет.
  • Использованные источники, библиотеки и помощь ИИ: раздел «Источники, библиотеки и использование ИИ» в конце отчёта.

Сделано по changes OpenSpec (openspec/changes/archive/), поверх кода лабы 2:

  • X-Instance-Id и обязательный Idempotency-Key с ключами в PostgreSQL — instance-id-idempotency (уровень «3»);
  • HAProxy перед двумя репликами API, лимиты, failover hook scripts/stop-one.sh — replicas-lb (уровни «3» и «4»);
  • согласованная цепочка таймаутов и профиль отказа под нагрузкой — graceful-failover (уровень «4»);
  • поочерёдная замена реплик с дренажём через runtime API HAProxy, expand-миграция и профиль замены под нагрузкой — rolling-update (уровень «4»);
  • CPU и память каждого компонента по окнам профилей отказа и замены (сэмплер cgroup без сети, метки resources) — profile-resources (уровень «4», «CPU/RAM» минимального отчёта о нагрузке);
  • трек 1 «Цена масштабирования»: серии a, b, pool, db, A/A, графики, точка насыщения и ответ 503 на «too many clients» — scaling-bench (уровень «5»);
  • одно улучшение по найденному узкому месту — пул без переполнения — scaling-improvement (уровень «5»);
  • исправление пяти найденных попутно дефектов перед переносом в лабу 4 — fix-known-issues: SIGTERM на старте реплики больше не теряется (ранний обработчик до импорта приложения), профиль failover читает события Docker потоком, PostgreSQL стенда отказов работает под init и make failure_checks проверяет его журнал, паспорт меток пишет swapouts_delta и при нуле, доказательства исключений сверки покрытия сняты на стенде лабы 3 (KNOWN_ISSUES.md — без открытых записей).

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

Версии. Образ API: python:3.12.14-slim-trixie и uv 0.12.17; LB: haproxy:3.4.6-trixie; Postgres: postgres:18.6-trixie; Valkey: valkey/valkey:9.1.2-trixie. Все закреплены тегом и digest индекса (amd64 + arm64) в Dockerfile и docker-compose.yml. Приложение: Python 3.12, FastAPI 0.141.1, uvicorn 0.54.0, pydantic 2.13.5, SQLAlchemy 2.1.1 (async), asyncpg 0.31.0, alembic 1.20.0, argon2-cffi 25.1.0, redis-py 8.1.0, structlog 24.4.0 и остальное строго по uv.lock. Тесты: pytest 9.1.1, httpx 0.28.1; нагрузка: k6 2.3.0 в контейнере (grafana/k6:2.3.0@sha256:…, bench/run.py). Проверено на Docker Desktop 29.8.2 (ВМ linux/arm64, 12 CPU, 7,7 GiB), Compose v5.5.1, macOS на Apple M3 Pro.

Нужно на машине:

  • Docker Engine 25+ (compose использует healthcheck.start_interval) с BuildKit и Compose v2, make, openssl (пароли в make env_setup), curl (шаги последовательности ниже);
  • python3 3.9+ для публичных make check, make test, make test-persistence, make test-failover, make instances, make test_isolated, make failure_checks. Драйвер make instances — только stdlib, проверен и на системном python3 3.9.6 macOS (make instances PYTHON=/usr/bin/python3 — instances: 2);
  • uv — для make validate (валидатор в dev-группе), make student_test, make failure_checks, make test_isolated (внутри uv run pytest), стенда замеров make bench* и make run_dev;
  • свободные порты 127.0.0.1:8080 (LB), 127.0.0.1:5433 (Postgres) и 127.0.0.1:6380 (Valkey). Стенд лабы 2 занимает те же порты: перед запуском его нужно остановить (make stop в его каталоге). Другие порты — аргументом make (make run_docker APP_OUT_PORT=8090) или в .env, затем make test BASE_URL=http://localhost:8090.

Подготовка и секреты. make env_setup создаёт .env из .env.example и config.toml из config_example.toml, существующие файлы не трогает. В шаблоне пароли Postgres и Valkey пустые, в новый .env подставляются случайные (openssl rand -hex 16): общего пароля стенда в git нет. Отдельно запускать env_setup не обязательно, его вызывают make run_docker, make run_dev, make test_isolated и make failure_checks. Пароль Postgres задаётся только при создании volume: после смены POSTGRES_PASSWORD нужен make wipe_data.

Последовательность проверяющего — та, что прошла из настоящего git clone на портах по умолчанию (evidence/tests/clean-clone-final.md):

git clone <fork> && cd <каталог clone> && git checkout solution/bvt2301-safronov
make env_setup        # .env (случайные POSTGRES_PASSWORD и VALKEY_PASSWORD) и config.toml из шаблонов
make run_docker       # docker compose build + up -d: postgres, valkey → migrate → api × API_REPLICAS (2) → haproxy
docker compose ps     # готовность — haproxy (healthy): через LB можно обслужить запрос; у api портов нет
make check            # структура skeleton
uv sync && make validate PYTHON=.venv/bin/python     # полная валидация OpenAPI 3.1
make test             # публичный smoke через LB на http://localhost:8080
make instances        # ≥2 X-Instance-Id одной сессии через LB (шаг 1 сценария защиты)
make test-persistence ACTION_SCRIPT=scripts/restart.sh
STOP_ONE_LOG=/tmp/stop-one.log make test-failover ACTION_SCRIPT=scripts/stop-one.sh   # остановлена первая реплика
make replicas         # вернуть остановленную реплику (тот же контейнер и ID)
curl -s -o /dev/null http://127.0.0.1:8080/health/live     # сдвиг очереди round-robin, иначе тест выберет ту же реплику
STOP_ONE_LOG=/tmp/stop-one.log make test-failover ACTION_SCRIPT=scripts/stop-one.sh   # остановлена вторая
make replicas
make student_test     # свой набор через LB, тесты реплик выполняются (EXPECT_REPLICAS = API_REPLICAS)
make failure_checks   # проверки отказов на отдельном проекте mtusi-lab3-failures, ~70 с; рабочий стенд не трогается
make test_isolated    # образ на временной базе test_messenger, один контейнер API: smoke + свой набор, ~65 с

Ожидаемо: make check, make validate, make test, make test-persistence и оба make test-failover — PASS; make instances — instances: 2; make student_test — 131 passed; make failure_checks — 17 passed; make test_isolated — 127 passed, 4 skipped (тесты реплик против одного процесса пропускаются с причиной). Строка STOP_ONE_LOG называет TARGET_INSTANCE_ID, который выбрал тест, и полный ID остановленного контейнера; docker compose ps -a показывает его Exited.

Вариант README без make — те же compose-команды, но только после make env_setup: без config.toml compose падает с bind source path does not exist (он монтируется read-only, create_host_path: false).

make env_setup
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build   # тот же стенд, что make run_docker
curl -s -o /dev/null -w '%{http_code}\n' http://127.0.0.1:8080/health/ready   # 200 — готов

Проверено на рабочем стенде 2026-10-12 (7f00128): config --quiet — код 0, up -d --build — migrate прошёл повторно (no-op), реплики, LB и хранилища не пересозданы, /health/ready через LB — 200; в чистом clone — config --quiet и сборка docker compose build (evidence/tests/clean-clone.md).

Порт API на хосте один — у HAProxy (127.0.0.1:${APP_OUT_PORT}, 8080). Число реплик — API_REPLICAS в .env (по умолчанию 2), разово — make replicas API_REPLICAS=N. В консоли (make run_dev) — один процесс без LB на 127.0.0.1:8080, с Postgres и Valkey из того же compose; свой набор против него — make student_test EXPECT_REPLICAS=1. Порт 8080 занят HAProxy работающего стенда, поэтому перед make run_dev — make stop (или docker compose stop haproxy).

Сценарий защиты

make run_docker && make instances                  # 1. ≥2 X-Instance-Id одной сессии через LB
STOP_ONE_LOG=/tmp/stop-one.log make test-failover ACTION_SCRIPT=scripts/stop-one.sh   # 2. запись и чтение во время отказа
cat /tmp/stop-one.log; docker compose ps -a        # 3. какой контейнер остановлен: ID = TARGET_INSTANCE_ID
make replicas; curl -s -o /dev/null http://127.0.0.1:8080/health/live
STOP_ONE_LOG=/tmp/stop-one.log make test-failover ACTION_SCRIPT=scripts/stop-one.sh   #    то же для второй реплики
cat /tmp/stop-one.log; docker compose ps -a        #    остановлен второй контейнер: ID = TARGET_INSTANCE_ID
make replicas
make test-persistence ACTION_SCRIPT=scripts/restart.sh   # 4. рестарт LB, реплик, Postgres и Valkey, тот же токен
# уровень 4 — на своём стенде mtusi-bench, рабочий стенд перед ними: make stop
make stop
make bench_failover_quick   # отказ каждой реплики под нагрузкой (stop, kill), ~2 мин; полный — make bench_failover
make bench_rollout_quick    # поочерёдная замена под нагрузкой с образа прежнего commit, ~2 мин; полный — make bench_rollout
make run_docker             # рабочий стенд снова (после make stop)
make load                   # в соседнем терминале — нагрузка на время замены
make rolling_update         # на рабочем стенде: новый код без простоя
# уровень 5, трек 1: самопроверка серий (~4 мин), полные серии — make bench_scaling SERIES=…
make bench_scaling_quick

Полные метки и графики трека 1 уже лежат в evidence/bench/scaling-*/, evidence/plots/ и evidence/compare/ (раздел «Цена масштабирования»); на защите показываются они, серии идут 25–100 мин.

Остановка и удаление данных

  • make stop — остановить контейнеры; make down — удалить контейнеры, volume postgres_data с данными остаётся, кэш Valkey теряется (он без volume, данные от этого не страдают);
  • make wipe_data — удалить контейнеры и volume, только после ввода yes и только проекта mtusi-lab3 (evidence/tests/stand-lab3.md); следующий make run_docker поднимает пустую базу со схемой.

Ранние проверки из clone: один API без LB — сборка без .env и config.toml, smoke на образе (evidence/tests/clean-clone.md); стенд с LB на нестандартных APP_OUT_PORT, APP__PORT и портах Postgres и Valkey — make test и make student_test (evidence/replicas/clean-clone-ports.md).

Архитектура и решения

клиент → 127.0.0.1:APP_OUT_PORT → haproxy ──→ api (реплика 1) ──→ postgres  (данные, сессии, ключи идемпотентности; volume)
                                          └─→ api (реплика 2) ──→ valkey    (кэш неизменяемых карточек чатов)
                                   migrate (один раз на каждый up, до реплик) ──→ postgres

Источник истины — PostgreSQL: пользователи, чаты, сообщения, сессии и ключи идемпотентности. Valkey — общий кэш, его отказ — обход в Postgres. Реплики api одинаковы и взаимозаменяемы, порта на хосте у них нет; единственная точка входа — HAProxy.

Что перенесено из лабы 2 (репозиторий mtusi2026lab2-safronov, ветка solution/bvt2301-safronov, commit c6ad34d), без изменения поведения, кроме перечисленного ниже:

  • PostgreSQL как источник истины, схема и миграции alembic отдельным сервисом migrate, ограниченный пул и таймауты, 503 при недоступности БД;
  • регистрация с паролем (Argon2id в потоке), вход по Basic только на POST /auth/sessions, остальное — Bearer-сессия в таблице sessions (SHA-256 токена, срок [auth] session_ttl_seconds, мгновенный отзыв);
  • Valkey — cache-aside неизменяемой карточки чата, отказ — обход в Postgres;
  • keyset-пагинация по (created_at, id), формат ошибок контракта, JSON-журнал без содержимого сообщений;
  • свои тесты student-tests/ (make test_isolated, make failure_checks) и стенд замеров bench/ трека 2 лабы 2 (make bench, make bench_restore).

Что изменилось при переходе 2 → 3: переход API (COURSE.md) — X-Instance-Id в каждом ответе и обязательный Idempotency-Key у отправки сообщения; новые миграции только добавляют (таблица idempotency_keys, колонка messages.instance_id); проект compose mtusi-lab3 вместо mtusi-lab2, чтобы не подключиться к данным второй лабы; HAProxy и реплики без портов; цепочка таймаутов (keep-alive uvicorn 60 с, idle_in_transaction_session_timeout 10 с); пул 10 + 0 вместо 10 + 5 (scaling-improvement); отказ PostgreSQL «too many clients» (SQLSTATE 53300) — 503, а не 500. Стенды make failure_checks и bench/ переведены на HAProxy перед API, make test_isolated остался одним контейнером API на временной базе.

Транзакционные границы. Одна AsyncSession на запрос, commit делает сервис, изоляция READ COMMITTED; реплики общих транзакций не имеют, гонки между ними решают ограничения PostgreSQL:

Операция Шаги в одной транзакции
регистрация хэш пароля (до БД) → INSERT … ON CONFLICT (username) DO NOTHING RETURNING; конфликт → 409
вход транзакция 1: SELECT учётных данных → commit; проверка пароля вне БД; транзакция 2: INSERT sessions → commit
запрос с токеном один SELECT sessions JOIN users WHERE token_hash = … AND expires_at > now
выход DELETE FROM sessions WHERE id = … → commit
создание чата проверка участников → INSERT chats → INSERT chat_members → commit; ошибка до commit — откат всего. Карточка пишется в Valkey после commit
отправка сообщения членство (карточка из Valkey или SELECT) → захват ключа INSERT … ON CONFLICT … DO UPDATE WHERE просрочен RETURNING → INSERT messages (с instance_id реплики) → commit с отложенной проверкой FK ключа на сообщение. Ключ занят — чтение сохранённого результата и commit (снять блокировку), тот же 201 или 409. Ошибка до commit — нет ни ключа, ни сообщения
чтения карточка чата — из Valkey или одним SELECT; история и список чатов — один SELECT по keyset-индексу

Одновременная вставка того же ключа другой репликой ждёт на уникальном индексе commit или отката первой; явных блокировок и распределённых транзакций нет (раздел «Идемпотентность отправки сообщения»).

Согласования с преподавателем (AGENTS.md, «Согласования с преподавателем»), действуют и в этой лабе:

  • 2026-09-26 — лабы можно делать на FastAPI, несмотря на расхождения с контрактом: лишний 422 (у нас не отдаётся вообще, всё переводится в 400) и другой порядок кодов ошибок. Публичный smoke при этом проходит. Где это видно в лабе 3 — порядок кодов у Idempotency-Key (раздел «Идемпотентность отправки сообщения»);
  • 2026-09-29 — конфигурация через pydantic-settings: окружение → .env → config.toml → дефолты. config.toml не в git и не в образе, монтируется read-only при запуске; это считается выполнением «конфигурация приходит из окружения» (README лабы 1, п. 3) и п. 6 Dockerfile.example. Отсюда таблица «Соответствие переменных .env.example» ниже.

Новых согласований в лабе 3 не было.

Балансировщик и реплики (change replicas-lb)

Почему Compose + HAProxy (выбор подтверждён автором 2026-10-07; design change replicas-lb, решение 1):

Критерий HAProxy Nginx (бесплатный) Traefik Swarm
Активная проверка /health/ready с периодом есть (inter/fall/rise) нет: пассивная по живым запросам, активная — только в NGINX Plus есть (healthcheck в labels) healthcheck контейнера, грубее (interval × retries)
Новые реплики после --scale без правки конфига DNS Docker (server-template + resolvers) server ... resolve с 1.27.3 через docker socket встроено
Повтор только недошедшего запроса retry-on conn-failure по умолчанию POST не повторяется, если уже отправлен retry middleware, семантику для POST надо проверять повторов нет
Статистика по репликам (трек 1) встроена (/stats;csv) только общие счётчики метрики Prometheus нет
Лишние привилегии нет нет docker socket — почти root на хосте —
Переделка стенда лабы 2 добавить сервис добавить сервис сервис и labels build и depends_on не работают в stack deploy, migrate как job, образ доступен узлам

Swarm на одном хосте ничего не даёт, а сборку образа и его доступность узлам пришлось бы описывать отдельно. Цена HAProxy — свой язык конфигурации и фиксированное число слотов server-template (8).

Как устроено (infra/haproxy/haproxy.cfg, HAProxy 3.4 LTS):

  • реплики находятся через DNS Docker: имя сервиса api отвечает адресами всех работающих реплик, HAProxy раскладывает их по 8 слотам. Новая и пропавшая реплика видны за 1–2 с без перезагрузки LB;
  • активная проверка GET /health/ready (200 — Postgres отвечает) раз в секунду, fall 2, rise 2. Слот, получивший адрес из DNS, начинает в DOWN (init-state down) и получает запросы только после проверок: Docker регистрирует адрес при старте контейнера, раньше, чем uvicorn слушает порт;
  • balance roundrobin, без cookie и stick-table: запросы одной сессии чередуются между репликами (evidence/replicas/distribution.md);
  • повтор в LB — только retry-on conn-failure, retries 2, option redispatch 1 (каждый повтор — на другую реплику): запрос до реплики не дошёл, повтор безопасен для любого метода. Оборванный или долгий ответ не повторяется;
  • ответы самого LB (502/503/504) — в формате ошибки контракта с code unavailable, request_id = X-Request-Id, без X-Instance-Id (evidence/replicas/lb-errors.md);
  • статистика и /lb/ready — frontend monitor на :8404, только внутри сети compose; оператору — make lb_stats. Healthcheck контейнера LB — /lb/ready: 200, пока есть готовая реплика.

Цепочка таймаутов (change graceful-failover, design, решение 1; числа — в infra/haproxy/haproxy.cfg, config_example.toml, docker-compose.yml, src/utils/constants.py). От клиента к PostgreSQL; «было» — до change:

Звено Значение Было Соотношение и почему
Клиент tests/resilience.py 2 с — задан skeleton; всё, что LB делает при отказе соединения, укладывается раньше
Клиент k6 профиля failover 15 с — > timeout server: клиент видит 504 от LB, а не свой таймаут
HAProxy timeout client / http-request 30 / 10 с — соединения клиентов; на отказ реплики не влияют
HAProxy timeout http-keep-alive 10 с — простаивающий сеанс клиента, а с http-reuse never — и его соединения с репликами; < keep-alive реплики (60 с)
HAProxy http-reuse never safe соединение с репликой живёт не дольше сеанса клиента и не уходит в общий пул: простаивающее соединение закрывает LB, а не реплика (evidence/failover/keep-alive.md)
HAProxy timeout connect, retries, redispatch 500 мс, 2, каждый повтор — 0,5 × 3 = 1,5 с < 2 с клиента. Живая реплика в сети Docker принимает соединение за доли миллисекунды; 500 мс ограничивают ожидание пропавшего адреса
HAProxy timeout server 10 с — > [database] request_timeout_seconds (6 с) + KDF входа под лимитом 1 CPU (до 1,6 с)
HAProxy inter / downinter 1 с / = inter — период проверок /health/ready, в том числе исключённой реплики
HAProxy fastinter 500 мс = inter повторная проверка после первой неудачи и до возврата
HAProxy fall / rise 2 / 2 — одна неудача — ещё не отказ; возврат — после двух успехов подряд
HAProxy timeout check 2,5 с 3 с > таймаута SELECT 1 внутри /health/ready (2 с) на 0,5 с: медленный PostgreSQL даёт 503 от реплики, а не таймаут проверки
Таймаут соединения проверки 0,5 с — min(timeout connect, inter), правило HAProxy
resolvers docker hold 1 с — пропавший адрес уходит из слота за 1–2 с
uvicorn timeout_keep_alive ([app] keep_alive_seconds) 60 с 5 с > timeout http-keep-alive LB (10 с)
/health/ready: SELECT 1 2 с — < timeout check; не меньше: проверка берёт соединение из общего пула, и заминка PostgreSQL вывела бы из LB все реплики разом
Пул: pool_timeout / connect_timeout 5 / 3 с — < request_timeout_seconds
PostgreSQL statement_timeout 5 с — < request_timeout_seconds: сервер прерывает долгую команду раньше, чем приложение рвёт соединение
Работа запроса с БД (request_timeout_seconds) 6 с — < timeout server 10 с
PostgreSQL idle_in_transaction_session_timeout ([database] idle_in_transaction_timeout_ms) 10 с нет > request_timeout_seconds: транзакция живого запроса дольше не живёт. Прерывает транзакцию замороженной реплики и снимает блокировку её ключа идемпотентности (evidence/failover/hung-key.md)
uvicorn [app] graceful_shutdown_seconds 8 с — < stop_grace_period 10 с; запросы в полёте дорабатывают
scripts/stop-one.sh docker stop --timeout 9 — возврат hook < 10 с
compose stop_grace_period 10 с — SIGKILL после graceful

Период проверок и время обнаружения. Проверка /health/ready раз в секунду. Следующая начинается через интервал после конца предыдущей, а после первой неудачи — через fastinter. Худшее время по проверкам:

Режим Как выглядит для проверки Формула Было Стало
зависшая реплика (docker pause) соединение принято, ответа нет inter + timeout check + (fall − 1) × (fastinter + timeout check) 8 с 6,5 с
адрес пропал (docker stop после выхода, docker kill) таймаут соединения 0,5 с inter + 0,5 + (fall − 1) × (fastinter + 0,5) 3 с 2,5 с
сокет закрыт, адрес жив (окно graceful) отказ соединения inter + (fall − 1) × fastinter 2 с 1,5 с

Остановленный контейнер ещё и пропадает из DNS Docker: слот уходит в обслуживание за hold 1–2 с, действует то, что раньше. Возврат — ≤ downinter + fastinter = 1,5 с после готовности реплики. Замер под нагрузкой по режимам — раздел «Эксперименты и отказы».

Остановленная реплика (docker stop) сразу закрывает приёмный сокет: LB получает отказ соединения и перенаправляет запрос, клиент ошибок от недоступности не видит. Убитая (docker kill) рвёт запросы в полёте: LB отвечает 502, клиент повторяет с тем же ключом. Зависшая (соединение есть, ответа нет) исключается проверками за ≤ 6,5 с, а запрос, уже ушедший на неё, получает 504 через timeout server 10 с.

Роли и сервисы (infra/README.md):

Роль Сервис Версия / digest Health / readiness Volume Сеть: имя и порт Порт на хосте Credentials
load_balancer haproxy haproxy:3.4.6-trixie@sha256:e2739156… /lb/ready (есть готовая реплика) — haproxy: вход ${APP__PORT} (8080), монитор и /lb/ready — :8404; runtime API — 127.0.0.1:9999 внутри контейнера 127.0.0.1:${APP_OUT_PORT} (8080) нет
api × API_REPLICAS api образ из Dockerfile (mtusi-messenger:lab3) /health/ready (healthcheck образа и проверки LB) — api (DNS отвечает адресами всех реплик): ${APP__PORT} (8080) нет environment: пароли Postgres и Valkey мостами из .env
миграции migrate тот же образ, alembic upgrade head код выхода 0 — только клиент Postgres нет пароль Postgres
postgres postgres postgres:18.6-trixie@sha256:5a5a84b1… pg_isready по TCP postgres_data алиас ${POSTGRES_HOST} (postgres): ${POSTGRES_PORT} (5432) 127.0.0.1:${POSTGRES_OUT_PORT} (5433, консоль) POSTGRES_* из .env
кэш valkey valkey/valkey:9.1.2-trixie@sha256:418652cf… valkey-cli ping с паролем нет (persistence выключен) алиас ${VALKEY_HOST} (valkey): ${VALKEY_PORT} (6379) 127.0.0.1:${VALKEY_OUT_PORT} (6380, консоль) VALKEY_PASSWORD из .env

Сеть одна — default проекта (mtusi-lab3_default, bridge), в ней все сервисы; другой сети и network_mode нет. Postgres и Valkey видны в ней под алиасами из .env (networks.default.aliases), поэтому POSTGRES_HOST / VALKEY_HOST можно менять без правки compose. На хосте публикуются только адреса 127.0.0.1: API — через LB, Postgres и Valkey — для консольного режима (make run_dev).

Лимиты и соединения (deploy.resources.limits, evidence/replicas/stand.md):

Сервис CPU Память
api (на реплику) 1.0 512M
postgres 2.0 1G
valkey 0.5 128M
haproxy (nbthread 1) 1.0 256M
migrate 0.5 256M

При двух репликах — 6 CPU и 2,6 GiB из 12 CPU и 7,7 GiB ВМ Docker. Соединения Postgres: API_REPLICAS × (pool_size + max_overflow) + migrate = 2 × (10 + 0) + 1 = 21 ≤ max_connections 100 (пул без переполнения с change scaling-improvement; до него 10 + 5 давали 31). Граница — при 10 репликах (10 × 10 + 1 = 101 > 100; с пулом 10 + 5 была при 7). На время поочерёдной замены реплик на одну больше (API_REPLICAS + 1): 3 × 10 + 1 = 31 соединение (было 46), 7 CPU и 3,1 GiB лимитов.

Секреты по сервисам. Пароль Postgres — postgres, api, migrate; пароль Valkey — valkey и api; у haproxy секретов нет (окружение — только API_PORT). Окружение собрано из якорей x-db-env / x-cache-env в docker-compose.yml.

Состояние процесса. Просмотр src/ (уровень модулей): в памяти процесса только пул соединений Postgres, клиент Valkey с отметкой «пропускать кэш после отказа» (retry_after_seconds), лимитер и фиктивный хэш KDF, instance_id и логгер. От них не зависит корректность ответа: сессии, данные и ключи идемпотентности — в Postgres, карточки чатов неизменны, поэтому общий кэш не требует инвалидации между репликами.

Восстановление реплики после scripts/stop-one.sh: make replicas (docker compose up -d --no-deps --no-recreate --wait --scale api=$(API_REPLICAS) api) — тот же контейнер запускается снова, LB включает его после проверок.

Обновление без простоя и миграции (change rolling-update)

Compose сам rolling update не делает (это update_config Swarm), поэтому замена — свой скрипт scripts/rolling-update.sh, цель make rolling_update. Сторонний плагин не используется: это была бы ещё одна незакреплённая зависимость. Порядок (design rolling-update, решения 1–5):

  1. Предусловия — ничего не меняют, иначе код 2 и подсказка make replicas:
    • работает ровно API_REPLICAS реплик, остановленных нет;
    • все UP в LB;
    • для ещё одной реплики есть слот (≤ 8);
    • канал управления LB отвечает;
    • нет слотов в ручном drain / maint, оставленных прерванной заменой (их не видно в make lb_stats, скрипт читает show servers state); иначе он печатает команду, которая вернёт слот в ready.
  2. Сборка образа из рабочего дерева. COMMIT=<commit> — из файлов commit через git archive <commit> | docker build, рабочее дерево не трогается.
  3. Миграции — один раз, в контейнере сервиса migrate, на новом образе, до первой новой реплики. Ошибка (в том числе lock_timeout) — код 1, реплики не тронуты.
  4. Одна новая реплика рядом со старыми: up -d --no-deps --no-recreate --scale api=N+1 api.
  5. Ожидание готовности новой: healthy и UP в статистике LB по её адресу. Слот получает адрес из DNS и начинает в DOWN, в распределение попадает через ≤ 1,5 с проверок. Вывести старую по одному healthy — значит на эти 1,5 с остаться с N − 1 репликами.
  6. Вывод старой из LB и удаление:
    • runtime API HAProxy: drain — новых запросов нет, начатые дорабатывают;
    • ожидание, пока запросов в полёте не станет 0 (≤ 12 с, больше timeout server);
    • maint, docker stop (graceful, ≤ 10 с; код выхода — в строке скрипта), docker rm;
    • когда адрес ушёл из слота — ready.
  7. Шаги 3–5 для каждой старой реплики. В конце API_REPLICAS реплик нового образа, все UP.

Канал управления LB — stats socket ipv4@127.0.0.1:9999 level admin в haproxy.cfg. Он слушает только loopback контейнера LB. Из сети compose и с хоста его не достать (evidence/rollout/script-failures.md, случай 8), команды идут через docker compose exec haproxy. Страница статистики :8404 с stats admin не годится: она открыта всей сети compose. Альтернатива — readiness 503 по SIGTERM — отвергнута:

  • она меняет поведение остановки, после SIGTERM реплика ещё ≥ 1,5 с принимала бы запросы;
  • остановка удлиняется до 1,5 + 8 с — впритык к stop_grace_period;
  • ломается срок stop-one.sh.

Почему слот возвращается в ready. Ручное состояние — свойство слота, а не реплики. IPAM Docker сразу отдаёт адрес удалённой реплики следующей, и DNS кладёт её в тот же слот. Это видно в замере: новая реплика второго шага получила адрес и слот только что удалённой. Слот, оставленный в maint, не пустил бы к ней ни одного запроса.

Дренаж убирает одиночный 502 гонки keep-alive. Слот выведен, и LB не отправляет запросов в соединения, которые uvicorn закрывает по SIGTERM. Профиль rollout под 200 запросами в секунду — 0 ошибок (раздел «Эксперименты и отказы»). scripts/stop-one.sh и профиль failover дренаж не делают намеренно: они имитируют отказ, а не плановую остановку.

Сбой на середине. Новая реплика не стала UP за срок или замену прервали, пока она стартует (в том числе внутри up --scale, когда её ID скрипту ещё не известен), — она удаляется. Её слот, если DNS уже отдал его, сначала уходит в maint. Новая уже UP (в том числе при Ctrl+C) — вывод текущей старой доводится до удаления. В любом исходе работает API_REPLICAS готовых реплик, слоты без ручного состояния, повторный запуск доводит замену (evidence/rollout/script-failures.md). Автоматического отката нет. Откат — та же замена на образ прежнего commit без миграций: make rolling_update COMMIT=<commit> MIGRATE=0.

Миграции однократны и совместимы с работающей версией (expand / contract):

  • ревизия только расширяет схему: новая таблица, колонка с NULL или значением по умолчанию, индекс;
  • удаление и переименование — отдельной поставкой, когда прежнего кода не осталось.

Демонстрация — колонка messages.instance_id (text NULL, ревизия e656d6bbe1a4): реплика, записавшая сообщение. Наружу она не отдаётся, контракт не меняется:

  • новый код её пишет, без неё упал бы, поэтому миграция обязана идти до новых реплик;
  • прежний код её не знает: вставляет свои колонки (NULL), читает свои.

Первой строкой ревизии — SET LOCAL lock_timeout = '2s'. ADD COLUMN берёт ACCESS EXCLUSIVE на миллисекунды, но, пока ждёт блокировку, за ним в очереди стоят все запросы к messages. Чужая долгая транзакция без срока остановила бы запись всех реплик. Со сроком миграция падает без изменений, замена не начинается, повтор проходит. Срок меньше statement_timeout приложения (5 с): запросы из очереди дожидаются отказа миграции и выполняются. В apply срок был 5 с, равный statement_timeout, и verify поймал цену: под нагрузкой все 6 запросов, вставших в очередь, получили 503 вместе с отказом миграции; с 2 с — 0 ошибок, задержка до 2 с (evidence/rollout/script-failures.md).

Проверено на рабочем стенде с итогового commit 84161c0 (evidence/rollout/compatibility.md):

  • реплики образа c50b721 (до change) на схеме после новой миграции проходят make test и make student_test (131 passed);
  • make rolling_update, откат COMMIT=c50b721 MIGRATE=0 и снова вперёд — под tests/load.py, 0 неуспешных запросов из 16–21 тысячи на каждый прогон; старые реплики после дренажа завершаются за 0,1 с с кодом 0;
  • по колонке видно, какая версия записала каждое сообщение;
  • после замен (реплики api-7, api-8 и дальше) работают make instances, make test-failover в режимах stop и kill, make replicas, make test-persistence, make run_docker поверх заменённых реплик и make down + make run_docker; две замены подряд не оставляют слотов LB с ручным состоянием, свободных слотов — те же 6 из 8.

make run_docker и пересборка. Пункт KNOWN_ISSUES.md «не пересоздаёт работающие api» не воспроизвёлся (evidence/rollout/compatibility.md, шаг B и шаг 6 жизненного цикла):

  • compose пересоздаёт реплики, у которых изменилось содержимое образа, — все разом, с простоем;
  • пересборка без изменений кода реплики не трогает.

Хранилище образов Docker Desktop — containerd, и docker ps показывает у реплик digest конфигурации образа, а не имя тега. Отсюда была ошибка диагностики. Обновление без простоя — make rolling_update.

Стенд лабы 3

Проект compose — mtusi-lab3, образ — mtusi-messenger:lab3. Имя проекта задаёт имена volumes: с именем второй лабы стенд подключился бы к её базе. Данные второй лабы не переносились (они синтетические), volume mtusi-lab2_postgres_data не затронут, в том числе make wipe_data этого стенда (evidence/tests/stand-lab3.md).

X-Instance-Id

  • Значение — [app] instance_id. Пусто (по умолчанию) — hostname процесса, определённый один раз при загрузке настроек; в compose это короткий ID контейнера, то есть то, что показывает docker compose ps -q api. По нему scripts/stop-one.sh найдёт контейнер без таблицы соответствия.
  • Значение не задаётся ни в config.toml, ни в .env, ни в compose (environment, hostname:): эти источники общие у реплик, а значение должно различаться. В консоли его можно заменить APP__INSTANCE_ID. Формат проверяется при старте ([A-Za-z0-9._-]{1,64}): с api a сервис не стартует (evidence/idempotency/config-checks.md).
  • Заголовок ставит то же ASGI-middleware, что X-Request-Id; ответ 500 собирает ServerErrorMiddleware снаружи него, поэтому обработчик Exception ставит оба заголовка сам. То же значение — поле instance_id в каждой записи журнала, включая старт и shutdown (evidence/idempotency/instance-id.md).
  • docker restart сохраняет hostname, и значение остаётся прежним; новый контейнер — новое значение. В лабе 7 поле получит непрозрачный alias вместо hostname.

Идемпотентность отправки сообщения

Таблица idempotency_keys (миграция 7652184b7016, только добавляет таблицу): первичный ключ (user_id, chat_id, key) — область ключа контракта «пользователь + метод + путь чата + ключ», ключ принимает одна ручка; внешний ключ (chat_id, user_id) → chat_members; message_id → messages с проверкой на commit (DEFERRABLE INITIALLY DEFERRED); SHA-256 тела; created_at с индексом; CHECK формата и длины ключа.

Отправка (MessageService.send_message) — одна транзакция:

  1. Сессию проверила зависимость (401), сервис проверяет членство (404) — и при повторе тоже.
  2. Захват ключа одним выражением: INSERT … ON CONFLICT (user_id, chat_id, key) DO UPDATE … WHERE created_at < now − ttl RETURNING. Строка вернулась — ключ свободен (новый или просроченный, заменён тем же выражением): вставка сообщения, commit().
  3. Ключ занят — чтение сохранённого хэша и сообщения, commit() (снять блокировку строки). Хэш совпал — тот же 201 и то же Message из БД; не совпал — 409 conflict.

Почему это корректно, в том числе между репликами (READ COMMITTED): одновременная вставка того же ключа ждёт commit или отката чужой транзакции на уникальном индексе. После commit — конфликт и сохранённый результат, после отката — вставка проходит, то есть транзиентная ошибка результатом не фиксируется. Ключ вставляется раньше сообщения, поэтому повтор не пишет и не откатывает сообщение. Любая ошибка до commit откатывает и ключ, и сообщение (evidence/tests/failure-checks.md: сбой вставки сообщения, остановка Postgres).

«То же тело» — SHA-256 канонического JSON, собранного из разобранного тела (сортированные ключи, значения по умолчанию подставлены): пробелы, \u-экранирование и порядок полей на сравнение не влияют, другой текст — другой хэш. В журнале ключа нет: повтор виден по "replayed": true и тому же message_id.

Порядок кодов при нескольких ошибках — 401 → 400 → 404 → 409. Idempotency-Key объявлен параметром ручки (есть в /openapi.json), а FastAPI проверяет параметры после зависимостей: без сессии — 401, затем нет ключа или неверное тело — 400, затем не участник — 404, затем другое тело — 409. Битый JSON — 400 раньше 401. Это то самое расхождение порядка кодов FastAPI, согласованное с преподавателем 2026-09-26 (AGENTS.md, «Согласования с преподавателем»); smoke его не затрагивает, порядок закреплён тестами test_idempotency.py.

Соответствие переменных .env.example

.env.example skeleton предлагает «логические» имена и просит сопоставить их с настоящими. Критерий — кто читает значение: то, что читают compose и контейнеры зависимостей, живёт в .env, то, что читает только приложение, — в секциях config.toml (согласование 2026-09-29). Адреса и порты Postgres и Valkey в compose — только переменные .env.

Имя skeleton Где у нас Почему так
APP_HOST режим APP__RUN_MODE: console — 127.0.0.1, docker — 0.0.0.0 (литерал в environment compose и ENV в Dockerfile) адрес следует из режима; в .env режим не хранится, чтобы консоль и docker работали из одного файла
APP_PORT APP__PORT в .env (8080) — порт, на котором слушает каждая реплика, на нём же healthcheck образа и проверки HAProxy (API_PORT контейнера LB); APP_OUT_PORT (8080) — порт на 127.0.0.1 хоста, его публикует только HAProxy параметр приложения в формате настроек; внешний порт приложение не читает, поэтому без секции. Проверено на нестандартных портах (evidence/replicas/clean-clone-ports.md)
APP_ENV не используется окружение одно — учебный стенд
SESSION_TTL_SECONDS [auth] session_ttl_seconds в config.toml, по умолчанию 3600; разовая подмена — AUTH__SESSION_TTL_SECONDS (так «тесный» API make failure_checks получает 2 с) читает только приложение; мост из .env с этим именем окружение бы не перекрыло (.claude/rules/settings.md)
DATABASE_URL_FILE не используется: URL собирает приложение из [database], адрес и порт в docker — POSTGRES_HOST / POSTGRES_PORT из environment compose, пароль — мостом из POSTGRES_PASSWORD в .env пароль нужен ещё и контейнеру Postgres, поэтому один источник — .env; файл секрета с URL дал бы второй
SESSION_STORE postgres: таблица sessions, общая для всех реплик, без кэша — отзыв мгновенный. Отдельной настройки нет другого хранилища сессий нет; Valkey сессий не хранит (без persistence рестарт стёр бы их)
CACHE_URL_FILE не используется: адрес и порт Valkey — VALKEY_HOST, VALKEY_PORT (сеть compose) и VALKEY_OUT_PORT (консоль) в .env, пароль — мостом из VALKEY_PASSWORD в [cache] password; таймаут, окно пропуска, срок записей и пул — [cache] в config.toml как у Postgres: пароль нужен и серверу Valkey (--requirepass)
IDEMPOTENCY_TTL_SECONDS [idempotency] ttl_seconds в config.toml, по умолчанию 86400 (24 ч); разовая подмена — IDEMPOTENCY__TTL_SECONDS значение читает только приложение; как SESSION_TTL_SECONDS (.claude/rules/settings.md). Срок меньше 86400 нарушает контракт и применяется только в проверках (2 с у «тесного» API стенда отказов)
API_REPLICAS API_REPLICAS в .env (шаблон — 2), deploy.replicas: ${API_REPLICAS:-2} сервиса api; Makefile — API_REPLICAS ?= 2 (make replicas, EXPECT_REPLICAS тестов). Разово — make replicas API_REPLICAS=N приложение его не читает, поэтому имя без секции; без строки в .env действует 2 (.claude/rules/settings.md)

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

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test через LB на стенде make run_docker; make test_isolated (образ из a4ca9ef, временная база, один контейнер): make test + make student_test EXPECT_REPLICAS=1; make test через LB стенда из настоящего git clone на нестандартных портах PASS: lab3 public API scenario во всех трёх; в изоляции 127 passed, 4 теста реплик пропущены с причиной «one API process»; сверка покрытия на итоговом коде: 137 сценариев, 125 тестом (18 — make failure_checks), 12 исключений (на a4ca9ef было 135 / 123) evidence/tests/student-test-lb.md, evidence/tests/test-isolated.md, evidence/replicas/clean-clone-ports.md, evidence/tests/clean-clone-final.md
«3»: стенд одной командой, ≥2 API, одна точка входа, общие БД и сессии make run_docker (рабочий стенд и настоящий git clone); docker compose ps, docker port, docker compose config haproxy — единственный порт API на хосте (127.0.0.1:8080), api × 2 без портов и container_name; общие Postgres (сессии, данные, ключи) и Valkey; миграции — один прогон migrate на каждый up, в журналах реплик alembic нет; из клона стенд поднимается одной командой, .env и config.toml создаются сами evidence/replicas/stand.md, evidence/replicas/clean-clone-ports.md
«3»: разные запросы одного пользователя — разными репликами без повторного входа make instances (один вход, 12 × GET /users/me с одним токеном); test_load_balancing.py ответы чередуются 3681880fc55f / 8100f940a5fa по 6; 20 запросов сессии — по 10; запись через одну реплику видна в чтениях через другую evidence/replicas/distribution.md, evidence/tests/student-test-lb.md
«3»: отказ любой одной реплики — ≤10 с до новых чтений и записей; make test-failover make test-failover ACTION_SCRIPT=scripts/stop-one.sh для каждой реплики, make replicas и сдвиг очереди round-robin одним запросом между прогонами; STOP_ONE_LOG — какой TARGET_INSTANCE_ID выбрал тест; docker compose ps -a и StartedAt до и после 2 × PASS: остановлены 8100f940a5fa, затем 3681880fc55f; первая запись через 1,10–1,11 с, 0 неудачных попыток, по 2 запроса перенаправлены LB; ID остановленного контейнера = TARGET_INSTANCE_ID, остальные контейнеры с прежним StartedAt; через 20 с реплика всё ещё exited. С цепочкой таймаутов graceful-failover (commit 459f84c) — снова PASS для каждой реплики: stop — 0 неудачных попыток, первая запись через 1,62 с; kill — 1 неудачная попытка (запрос в полёте), повторена с тем же ключом, первая запись через 0,23 с evidence/failover/test-failover.md, evidence/tests/graceful-failover-checks.md
«3»: отказ процесса без graceful, реплика остаётся остановленной STOP_MODE=kill make test-failover …; через 15 с docker inspect; driver.py --port 8080 kill-inflight (kill во время входов по Basic) PASS, первая запись через 0,74 с; контейнер exited 137, RestartCount 0 через 15 с (restart: unless-stopped его не поднял); 3 входа в полёте — 502 от LB в формате контракта без повтора (SH--, повторов 0), 2 в момент kill — перенаправлены evidence/failover/test-failover-kill.md
«3»: make test-persistence с LB make test-persistence ACTION_SCRIPT=scripts/restart.sh; StartedAt до и после PASS за 6,4 с; перезапущены LB, обе реплики, Postgres и Valkey (те же ID, новый StartedAt), volume с прежней датой создания evidence/replicas/test-persistence.md
«3»: повтор POST с тем же ключом при переключении реплики test_idempotency.py::test_replay_on_other_replica через LB отправка через 8100f940a5fa, повтор через 3681880fc55f — тот же JSON; другое тело — 409 от обеих реплик evidence/tests/student-test-lb.md
Failover hook не трогает чужое scripts/stop-one.sh с пустым, не-hex, коротким ID, ID Postgres / Valkey / LB / migrate, несуществующим, контейнером mtusi-lab2, STOP_MODE=pause код 2 (неверное значение или режим, до вызова docker) или 3 (нет такой работающей реплики); состояние и StartedAt всех контейнеров не изменились evidence/failover/stop-one-refusals.md
«4»: лимиты CPU/RAM, порты API не наружу, секреты только где нужно, нет container_name docker inspect (NanoCpus, Memory), docker port, имена переменных из docker compose config лимиты у всех 6 контейнеров; порт API только у LB; пароль Valkey только у valkey и api, у LB секретов нет; container_name нет. Цена лимита 1 CPU для Argon2id измерена (раздел «Ограничения») evidence/replicas/stand.md
«4» (часть): LB исключает недоступный backend; период проверок make lb_stats, docker compose logs -t haproxy; все реплики остановлены; одна реплика заморожена docker pause; PostgreSQL остановлен период 1 с, fall 2, rise 2, timeout check 3 с; остановленные реплики DOWN / в обслуживании, вернувшиеся — после проверки; зависшая — DOWN через 7,7 с (формула худшего случая — 8 с), запрос в полёте — 504 в формате контракта; без PostgreSQL обе реплики отвечают на проверку 503 и исключаются за 1,2–1,8 с; без реплик LB отвечает 503 в формате контракта, healthcheck LB unhealthy. Замер обнаружения по режимам под нагрузкой — строка ниже (change graceful-failover; timeout check с тех пор 2,5 с и fastinter 500ms) evidence/replicas/lb-errors.md, evidence/failover/test-failover.md
«4»: health/readiness, таймауты и прекращение приёма при SIGTERM согласованы; период проверок и максимальное время обнаружения таблица цепочки таймаутов (раздел «Балансировщик и реплики»); make bench_failover FAILOVER_LABEL=baseline (commit 459f84c, хост проверен); driver.py --port 8080 idle-conns; driver.py --port 8080 hang-key; запуск с неверными сроками проверка раз в 1 с, fastinter 0,5 с, fall 2, rise 2, timeout check 2,5 с > 2 с готовности; худшее обнаружение — 2,5 с для остановленной и убитой реплики, 6,5 с для зависшей (было 8 с). Замер под нагрузкой: stop и kill — 0,79–1,81 с, pause — 5,83–6,00 с; возврат в LB — 1,2–1,8 с. Простаивающие соединения с репликами закрывает LB через 10,1 с (keep-alive реплики 60 с > timeout http-keep-alive 10 с, http-reuse never). Отвергнутый вариант — пул LB (http-reuse safe) при том же keep-alive 60 с — переснят на закоммиченном коде временным вторым HAProxy с одной изменённой строкой: последнее соединение закрыла реплика через 60,4 с. Транзакцию замороженной реплики PostgreSQL прерывает через 10 с простоя: повтор того же ключа — 201, одно сообщение; временный триггер сценария удаляется и при Ctrl+C или SIGTERM. Неверные сроки — сервис не стартует evidence/failover/detection.md, evidence/failover/keep-alive.md, evidence/failover/hung-key.md, evidence/failover/baseline/
«4»: последовательная остановка каждой реплики с восстановлением предыдущей: RPS, ошибки, время восстановления make bench_failover FAILOVER_LABEL=baseline: 100 записей с ключом и 100 чтений в секунду, каждая из двух реплик в режимах stop, kill, pause, возврат через 20 с 6 фаз. stop и kill: ~200 успешных ответов в секунду всё время, 0 ошибок, восстановление 0 с, всплеск p95 до 505 мс в секунду действия. pause: 602 и 584 ответа 504 (половина запросов ~6 с до исключения), доля успешных 0,5, восстановление 6 с. После возврата ошибок нет. Неуспешные записи повторены с тем же ключом: сообщений 30 005 = ключей 30 005, одинаковых текстов нет evidence/failover/baseline/summary.md, evidence/failover/detection.md
Регрессия на итоговом commit graceful-failover make test, make student_test через LB, make test-persistence, make test-failover (stop и kill), make test_isolated, make failure_checks, make bench_quick, make bench_restore_quick, make bench_failover_quick всё код 0: 131 passed через LB; 127 passed и 4 пропуска с причиной в изоляции; 15 проверок отказов; профили лабы 2 на стенде с HAProxy и одной репликой; быстрый профиль отказа — 4 фазы, сверка сошлась evidence/tests/graceful-failover-checks.md
Масштабирование без правки LB make replicas API_REPLICAS=3, затем make replicas третья реплика в распределении через 2 с без правки haproxy.cfg; обратно — две evidence/replicas/distribution.md
Порты из .env со стендом за LB настоящий git clone, make run_docker во временном проекте с APP_OUT_PORT=18090, APP__PORT=9090, портами Postgres и Valkey 5544 / 15545 и 6390 / 16391 реплики слушают 9090, LB проверяет их на 9090 (L7OK), API на хосте — только через LB на 18090; make test и make student_test (131 passed) через LB evidence/replicas/clean-clone-ports.md
Тесты реплик не выдают пропуск за успех make student_test против одного процесса без EXPECT_REPLICAS=1 4 теста реплик падают с saw 1 X-Instance-Id … EXPECT_REPLICAS=2, остальные 127 проходят evidence/tests/student-test-lb.md
Свои стенды на новом compose make test_isolated, make failure_checks, make bench_quick, make bench_restore_quick все код 0; рабочий стенд не тронут; лимиты в паспорте bench те же, что до change evidence/tests/test-isolated.md, evidence/tests/failure-checks.md, evidence/tests/bench-self-checks.md
«3»: повтор POST с тем же Idempotency-Key не создаёт дубль разовый HTTP-скрипт: отправка, повтор, повтор в \u-записи все 201 с одинаковым JSON, в истории одно сообщение evidence/idempotency/replay.md
«3»: другое тело с тем же ключом, нет и неверный ключ тот же скрипт 409 conflict; 400 без ключа и с a b, значение ключа в ответ не попадает; постороннему — 404, ключ у другого пользователя — новое сообщение evidence/idempotency/replay.md
«3»: повтор через другой процесс API отправка, docker compose up -d --force-recreate api, повтор с тем же ключом и токеном новый контейнер и X-Instance-Id, тот же Message (тот же id и created_at) evidence/idempotency/replay-after-restart.md
«3»: ключ переживает рестарт API и хранилищ отправка, scripts/restart.sh (api, Postgres, Valkey без удаления volumes), повтор с тем же ключом и токеном новый StartedAt у всех трёх; повтор — 201 и тот же Message, другое тело — 409, в чате одно сообщение evidence/idempotency/replay-after-storage-restart.md
«3»: неподтверждённую запись можно повторить; сбой не занимает ключ make failure_checks: триггер роняет вставку сообщения после вставки ключа; остановка Postgres 500 / 503, затем повтор с тем же ключом — 201, ровно одно сообщение evidence/tests/failure-checks.md
Срок ключа make failure_checks, «тесный» API с IDEMPOTENCY__TTL_SECONDS=2 в пределах срока другое тело — 409, после срока — 201 и новое сообщение evidence/tests/failure-checks.md
Настройки instance_id и срока ключа API в консоли с APP__INSTANCE_ID=api-a; запуск с APP__INSTANCE_ID="api a", IDEMPOTENCY__TTL_SECONDS=abc и 0 X-Instance-Id: api-a и instance_id = api-a во всех 14 записях журнала; недопустимые значения — код 1 до старта, ошибка называет поле evidence/idempotency/config-checks.md
«4»: идемпотентность под параллельными запросами с одним ключом test_race.py::test_same_key_through_replicas через LB: 10 клиентов за threading.Barrier, одно тело и один ключ 10 × 201 с одним Message, одно сообщение в истории; ответы обеих реплик (5 + 5), есть пара пересекающихся по времени запросов разных реплик; то же на стенде из клона. Против одного процесса — test_same_key_at_once evidence/tests/student-test-lb.md, evidence/replicas/clean-clone-ports.md, evidence/idempotency/keys-table.md
X-Instance-Id на каждом ответе, instance_id в журнале тесты api-conventions, curl, docker compose logs api заголовок у 2xx, 4xx, health, 404, 405, 500; значение = короткий ID контейнера; 85 из 85 записей журнала с instance_id, включая старт и shutdown; ключей и текста в журнале нет evidence/idempotency/instance-id.md
Стенд лабы 3 не трогает данные лабы 2 make run_docker, make wipe_data, снова make run_docker; docker volume inspect до и после wipe_data удалил только контейнеры, сеть и volume mtusi-lab3; mtusi-lab2_postgres_data с прежней датой создания evidence/tests/stand-lab3.md
Сборка из чистого clone git clone, docker build -t mtusi-messenger:lab3 . до make env_setup; стенд на этом образе, make test сборка без .env и config.toml, в образе их нет, процесс от UID 10001; PASS: lab3 public API scenario evidence/tests/clean-clone.md
Итоговая проверка из чистого clone по разделу «Запуск из чистого clone» (COURSE.md, «Что сдавать»: PR должен собираться из чистого clone по инструкции автора) настоящий git clone commit 8fa12f5 (2026-10-13, итоговый код fix-known-issues; прошлая проверка — dbb9150, в истории файла), проект mtusi-lab3 на портах по умолчанию: make env_setup, make run_docker, make check, make validate, make test, make instances (python3 3.11 и системный 3.9.6), make test-persistence, make test-failover для каждой реплики (stop, затем make replicas; плюс kill), make student_test, make failure_checks, make test_isolated; docker build --no-cache все команды — код 0 без правки файлов клона: PASS у публичных проверок, instances: 2, остановлены по очереди bbddd2338014 и 4c914e2e525f (ID = TARGET_INSTANCE_ID), первая запись через 0,96–1,21 с (stop, неудачных попыток 0) и 0,23 с (kill, одна попытка в полёте повторена с тем же ключом); после restart.sh те же ID с новым StartedAt у LB, реплик, Postgres и Valkey; 133 passed через LB (сверка ссылок исключений зелёная), 17 проверок отказов и журнал PostgreSQL стенда без признаков аварии, 129 passed + 4 пропуска с причиной в изоляции; образ без .env и config.toml, UID 10001 evidence/tests/clean-clone-final.md
Стенд bench/: отправки с ключом при восстановлении make bench_restore_quick (самопроверка, не замер) 1000 отправок во время backup на каждом размере, 0 неудачных; сообщений в исходной базе = подтверждённых отправок; сверка баз прошла evidence/tests/bench-restore-quick.md
«4»: rolling update (поочерёдная замена) проверен под нагрузкой make bench_rollout ROLLOUT_LABEL=baseline (commit 9dcea0b, код de654a1, хост проверен, рабочий стенд остановлен): 100 записей с ключом и 100 чтений в секунду, две реплики образа c50b721 заменяются на образ текущего checkout тем же scripts/rolling-update.sh; на рабочем стенде (итоговый код 84161c0) — make rolling_update, откат COMMIT=c50b721 MIGRATE=0, снова вперёд и две замены подряд под tests/load.py; быстрый профиль make bench_rollout_quick на 84161c0 замена 8,9 с; 0 ошибок из 24 002 запросов, доля успешных 1,0 в каждой секунде, p95 5 → макс. 11 мс; по шагам: новая UP в LB через 2,0–2,1 с после старта, дренаж старой 0,14–0,16 с, остановка 0,3–0,4 с; после вывода из LB старая не получила ни одного запроса; сообщений 12 001 = ключей 12 001. Рабочий стенд: 0 неуспешных из 21 043 / 16 687 / 18 480 / 27 278 запросов tests/load.py; старые реплики завершаются за 0,1 с с кодом 0 («Finished server process»); контейнеров прежних реплик после замены нет. Быстрый профиль на итоговом коде: замена 8,1 с, 0 ошибок, 7 301 = 7 301 evidence/rollout/baseline/summary.md, evidence/rollout/compatibility.md, evidence/tests/rolling-update-checks.md
«4»: CPU и память профилей отказа и замены (COURSE.md: CPU/RAM в отчёте о нагрузке) make bench_failover FAILOVER_LABEL=resources, make bench_rollout ROLLOUT_LABEL=resources (код 2d267bf, хост проверен, Swapouts без прироста, рабочий стенд остановлен): тот же профиль и сэмплер cgroup в режиме scan (0,25 CPU / 128 МиБ, без сети) на всё время нагрузки; самопроверки — быстрые профили, сторож (docker rm -f сэмплера посреди фазы) failover, фазы 1–5: до действия реплика 0,28–0,31 ядра, PostgreSQL 0,09–0,10, ВМ 1,03–1,16 из 12; в окне отказа выжившая 0,37–0,43, цель 0 (у pause — 0 CPU при той же памяти); после возврата — запуск до 1,06 ядра; CPU на запрос до действия — API 2 810–3 136 мкс, PostgreSQL 432–478. rollout: API всего 0,57 → 0,82 ядра и 176 → 279 МиБ на пике замены (три реплики), ВМ 1,0 → 2,8 ядра на сборке; CPU на запрос до / после 2 876 / 2 895 мкс. Доступность та же, что у baseline: обнаружение в границах, восстановление ≤ 7 с, у замены 0 ошибок и 0 ответов старой после дренажа. Наблюдатель — 0,003 ядра, 2–3 МиБ, к стенду не обращается; сторож — код 1 с фазой, стенд убран evidence/failover/resources/, evidence/rollout/resources/ (summary.md, resources.csv, samples.csv), evidence/tests/profile-resources-checks.md
«4»: миграции однократно и совместимы с работающей версией реплики образа c50b721 + миграция нового образа в контейнере сервиса migrate (команда скрипта), без замены; make test, make student_test; замена; SELECT instance_id, count(*) по сообщениям; миграция под чужой блокировкой и нагрузкой новая ревизия e656d6bbe1a4 (колонка messages.instance_id, NULL) при прежних репликах: PASS, 131 passed; запись прежней версии — NULL, новой — её X-Instance-Id; при замене одна миграция в контейнере migrate до первой новой реплики, в журналах реплик alembic нет; повторный запуск — no-op; откат кода без отката схемы (после отката migrate прежнего образа падает на новой ревизии — ограничение, описано); под чужой транзакцией lock_timeout 2 с → миграция падает с кодом 1, схема и реплики не тронуты, 6 запросов из очереди за ней — успешны за 2,0 с (с 5 с в apply — все 6 получили 503), повтор проходит evidence/rollout/compatibility.md, evidence/rollout/script-failures.md
Замена при сбое и неготовом стенде остановленная реплика, API_REPLICAS=3, слоты в ручном maint / drain, ROLLOUT_READY_TIMEOUT=1, настоящий Ctrl+C (^C в псевдотерминал под make) во время дренажа и внутри up --scale под нагрузкой, порт 9999 LB из сети и с хоста код 2 до сборки (для слотов — с командой возврата в ready); неготовая новая реплика удалена, работают 2 реплики UP; Ctrl+C во время дренажа — вывод старой доведён до удаления, внутри up --scale — новая реплика найдена и удалена (до исправления в verify оставалась третья реплика), 0 неуспешных запросов, повтор довёл замену; слоты LB без ручного состояния; канал управления LB из сети и с хоста — отказ соединения evidence/rollout/script-failures.md
make run_docker после пересборки реплики на образе прежнего commit, docker compose build api, docker compose --dry-run up -d; make run_docker поверх заменённых реплик compose пересоздаёт реплики с изменившимся образом, без изменений — не трогает (те же ID); пункт KNOWN_ISSUES.md не воспроизвёлся и закрыт evidence/rollout/compatibility.md
Регрессия на итоговом коде rolling-update (84161c0) make test, make student_test, make instances, make test-failover (stop и kill, обе реплики), make replicas, make test-persistence, make run_docker, make down + make run_docker, две замены подряд — на репликах после замены; make test_isolated, make failure_checks, make bench_failover_quick, make bench_rollout_quick всё код 0 (131 passed через LB, 127 + 4 пропуска в изоляции, 15 проверок отказов, быстрые профили на чистом дереве); apply нашёл дефект шага миграций (контейнер migrate прежнего образа ломал restart.sh, исправлен в de654a1), verify — уборку при Ctrl+C внутри up --scale и lock_timeout, равный statement_timeout (5e102e6, 84161c0) evidence/tests/rolling-update-checks.md, evidence/rollout/compatibility.md
Выбранный трек 5, если заявлен трек 1 «Цена масштабирования»: make bench_scaling SERIES=a|b|pool|ab (bench/run.py, профили scaling_*), методика и гипотезы — раздел «Цена масштабирования (трек 1)» гипотезы H1–H3 закоммичены до первой серии (02fd3d8 старше меток); 4 метки на коде 712d245, хост проверен, брака генератора нет evidence/bench/scaling-*/, evidence/plots/scaling/, evidence/tests/scaling-bench-checks.md
«5», трек 1: 1/2/4 реплики при фиксированном суммарном CPU/RAM make bench_scaling SERIES=a: 4 CPU / 2 ГиБ на приложение — 1 × 4, 2 × 2, 4 × 1, по 3 повтора на свежем стенде, открытая модель 70/20/10, поиск R* по SLO (p95 ≤ 200 мс, ошибок ≤ 1 %) R* 630 (630–704), 1 101 (1 041–1 164), 1 819 (1 539–1 819) запросов/с; 1 × 4 ≈ 1 × 1 (0,95): один процесс занимает ≤ 1,00 ядра из 4 (посекундный максимум за серию), троттлинг 0 evidence/bench/scaling-a/summary.md, samples.csv
«5», трек 1: серия с ростом ресурсов make bench_scaling SERIES=b: 1…6 реплик по 1 CPU / 512 МиБ, PostgreSQL 2 CPU / 1 ГиБ, 3 повтора R* 666 → 1 164 → 1 539 → 1 819 → 2 034 → 2 034; эффективность 1,00 → 0,51 evidence/bench/scaling-b/summary.md, evidence/plots/scaling/rstar-by-replicas.svg
«5», трек 1: точка насыщения и почему рост реплик перестаёт помогать make bench_plots LABELS="scaling-a scaling-b"; метрики ступени R*: CPU каждого контейнера и ВМ, PSI, PostgreSQL (pg_stat_activity по wait_event, commit, WAL), HAProxy k_sat = 5 по правилу (R*(6) < 1,1 × R*(5)), но на границе разрешения сетки: в её пределах k_sat ∈ {4, 5}. Общий ресурс стенда не насыщен: PostgreSQL — 1,1 ядра из 2, ожидания WAL — 22 % активных (порог 30 %), блокировок нет; HAProxy — 0,25 ядра из 1, очередь 0; отказов пула нет, признак pool не сработал, но пул каждой реплики на R* заполнен до 15. Растёт цена запроса в CPU у всех компонентов вместе с занятыми ядрами ВМ (реплики ×1,91, PostgreSQL ×2,03, HAProxy ×2,24, k6 ×1,56 от k = 1 к 6; host_cost 2,12): предел задаёт хост, механизм удорожания этим замером не разделён evidence/plots/scaling/summary.md (разделы «Точка насыщения», «Цена запроса и общие ресурсы на R*»), evidence/bench/scaling-b/runs.csv
«5», трек 1: граница пула make bench_scaling SERIES=pool: 4 × 1 при max_connections 100 и 50 (пул 10 + 5 на реплику) при 50 — «too many clients» в журнале PostgreSQL с 1 455/с, R* 1 539 (1 539–1 627) против 1 819 (1 720–1 819), разбросы не пересекаются; клиенту — 500 на измеренном коде 712d245 (серия снята до правки 53300); при 100 отказов нет, а за R* реплики отдают 503 после 5 с ожидания пула evidence/bench/scaling-pool/summary.md, raw/*-errors.log
«5», трек 1: точка насыщения БД make bench_scaling SERIES=db: 1, 2, 4 реплики по 1 CPU при PostgreSQL 0,5 CPU и контроль 4 × 1 при 2 CPU, 3 повтора, код 95539a1, хост проверен; лимит — по калибровке db_quick (design) R* 630 → 1 101 → 931: от 2 к 4 репликам R* падает на 15 %; на 984/с у 4 реплик PostgreSQL выбирает квоту (троттлинг 68 %, до 100 % выше), CPU на запрос 279 → 441 мкс, признаки db_cpu и db_wal; контроль при 2 CPU — 1 627. Рубрика: БД и пул — управляемыми опытами, LB не насыщен (≤ 0,30 ядра из 1), на дефолтах рост останавливает хост evidence/bench/scaling-db/summary.md, evidence/plots/scaling-db/
Отказ PostgreSQL «too many clients» (53300) — 503, а не 500 правка 68edc66 (53300 в UNAVAILABLE_SQLSTATES); make failure_checks: hook fill-connections занимает все слоты max_connections и обрывает соединения API; проба тем же способом через LB на рабочем стенде без правки — 500 internal_error (тест красный); с правкой — 503 unavailable в формате контракта с X-Instance-Id реплики за 3–4 мс, без Retry-After (в контракте он только у 429), в журнале API — warning «Database is unavailable»; после освобождения слотов — 200 без рестарта; 16 проверок отказов прошли evidence/storage/too-many-clients.md, evidence/tests/scaling-bench-checks.md
«5», трек 1: исходные данные и графики make bench_plots; таблицы меток R* от числа реплик, p95 от интенсивности (лог. шкала, линия SLO), CPU по компонентам на R*; строка на ступень, на ячейку и посекундные отсчёты evidence/plots/scaling/*.svg, evidence/bench/scaling-*/runs.csv, searches.csv, samples.csv
«5», трек 1: уровень шума для улучшения make bench_scaling SERIES=ab SCALING_LABEL=scaling-aa; make bench_compare BEFORE=scaling-b AFTER=scaling-aa, BEFORE=scaling-b AFTER=scaling-a шум между сессиями (B → A/A, тот же код 712d245): 1 × 1 666 (666–704) → 704 (666–704), +5,7 % — одна ступень деления; 6 × 1 2 034 (1 923–2 034) → 2 034 (2 034–2 034), Δ в пределах одной ступени (< 5,7 %); разбросы пересекаются. Согласованность серий: 4 × 1 серии a и k = 4 серии b — 1 819 и 1 819. Для scaling-improvement scaling-aa как AA не годится: код после правки 53300 другой, A/A снимается заново evidence/compare/scaling-b__scaling-aa.md, evidence/compare/scaling-b__scaling-a.md
«5», трек 1: одно подтверждённое улучшение — пул без переполнения (change scaling-improvement) H4 закоммичена до замеров (0b0421a, набор ячеек — 1bb8ea6, попытка 2 — a676a52); изменение 9c3959d (дефолт max_overflow 5 → 0) откачено; в одной сессии хоста: A/A make bench_scaling SERIES=db4 SCALING_LABEL=scaling-db-aa2, затем make bench_ab BEFORE=scaling-db-before2 AFTER=scaling-db-nooverflow2 REAPPLY=5c07923 SERIES=db4; make bench_compare … AA=scaling-db-aa2 CHANGE=scaling-improvement. Попытка 1 — те же команды с метками без 2, откат 62fa575 попытка 2 (окончательная, тихий хост): основная 4x1-pg0.5 R* 931 (931–984) → 1 101 (1 101–1 101), +18,3 %, «эффект», шум A/A 5,4 %; механизм: новых сессий на первой нарушившей 102 → 4, соединений 60 → 40, CPU PostgreSQL на запрос там 416 → 336 мкс; контроль 4x1-pg2 +5,7 % (в пределах шума). Подтверждено с оговоркой: по букве критерия проверка дрейфа (CPU на запрос при 500/с ±5 %) у основной ячейки −5,4 % из-за двух ячеек «до» (переполнения при 500/с нет ни в одной метке); против A/A2 той же сессии (make bench_compare BEFORE=scaling-db-aa2 AFTER=scaling-db-nooverflow2 AA=scaling-db-before2 CHANGE=scaling-improvement) дрейфа нет — 1 940 → 1 936 мкс, R* 984 → 1 101, +11,9 % (две ступени), «эффект»; засчитано решением автора после результатов. Попытка 1: +32 %, но шум A/A 20 % из-за помех macOS (iCloud, Zoom) — не прошла дрейф evidence/compare/scaling-db-before2__scaling-db-nooverflow2.md, evidence/compare/scaling-db-aa2__scaling-db-nooverflow2.md, evidence/compare/scaling-db-aa2__scaling-db-before2.md, evidence/bench/scaling-db-{aa2,before2,nooverflow2}/, попытка 1 — evidence/compare/scaling-db-before__scaling-db-nooverflow.md и метки без 2, evidence/tests/scaling-improvement-checks.md
Пул без переполнения: соединения не переоткрываются make failure_checks: тест test_pool_keeps_connections (48 потоков × 5 запросов, пачки больше пула 10, счётчик pg_stat_database.sessions через hook db-sessions); рабочий config.toml с max_overflow 5 и 0 10 + 5 — красный: 18–21 новая сессия PostgreSQL за 720 запросов; 10 + 0 — 0, 17 проверок отказов прошли (4 прогона); регрессия на коде 80e64cd: make test, make student_test (131 passed), make test_isolated, make test-persistence, make test-failover для обеих реплик — PASS; соединений приложения на рабочем стенде 17 ≤ 2 × 10 evidence/tests/scaling-improvement-checks.md
«4»: остановка реплики во время старта (docker stop до готовности) driver.py stop-at-start --image <образ>: контейнеры образа с лимитами реплики, docker stop --timeout 10 через 0,2–0,4 с после старта (импорт), по строке «Started server process» и в работающий сервер; «до» — образ кода 628bbfa, «после» — edad1fd; ветка сбоя rolling-update.sh (ROLLOUT_READY_TIMEOUT=1 и 2) «до»: во время импорта SIGTERM потерян — docker stop 10,1 с, код 137, сервер после сигнала дошёл до «Uvicorn running on»; «после»: 0,06 с, код 0, запись info «Stopped API before startup» с signal SIGTERM; сигнал на старте сервера и работающей реплике — uvicorn, ≤ 0,5 с, код 0 в обоих; неготовая новая реплика со слотом LB — maint и штатная остановка с кодом 0; окно запуска интерпретатора (десятки мс) — ограничение evidence/failover/stop-at-start.md
Исключения сверки покрытия на стенде лабы 3 (кэш, пароли и токены) make test_isolated, затем driver.py --port 8080 cache-check; driver.py --port 8080 auth-storage (код драйвера 5372d20, приложение edad1fd); сверка ссылок исключений test_exclusion_evidence_exists 50 чтений карточки через обе реплики — таблица chats прочитана 1 раз, keyspace_hits +49, промахов +1; TTL 3600 с = настроенному, чтения его не продлевают; ключи рабочей и тестовой базы — 78 и 74 под разными префиксами. password_hash — $argon2id$v=19$m=65536,t=3,p=4$…, у одного пароля хэши разные; token_hash — 32 байта SHA-256, ни токена, ни пароля в pg_dump. Без этих файлов сверка падает и называет 5 сценариев и 2 пути evidence/cache/hits.md, evidence/auth/passwords-and-tokens.md
Регрессия fix-known-issues (итоговый код 949bea4) сверка событий failover поток против буфера демона (временный commit и git revert), без помех и под шумом docker exec; make failure_checks до и после init: true; консоль (SIGTERM / SIGINT на старте, reload); make test, make student_test, make test-persistence, make test-failover (stop для обеих, kill), make test_isolated, make failure_checks, make bench_failover_quick, make bench_rollout_quick без помех моменты совпали до наносекунды (4 фазы), под шумом ~24 docker exec/с буфер потерял события всех 4 фаз, поток — ни одного; красный failure_checks — «untracked child process … exit code 2», «reinitializing», код ненулевой; зелёный — crash markers 0 дважды; консоль — код 0 без traceback; всё остальное — код 0: 133 passed через LB, 129 + 4 пропуска в изоляции, 17 проверок отказов evidence/tests/fix-known-issues-checks.md
Цена нового соединения PostgreSQL и пинга микропроба в реплике рабочего стенда (cd88b48): проверка сессии и страница истории через repo, из пула с пингом, без пинга и с новым соединением на итерацию новое соединение — 11,7–11,8 мс CPU реплики (SCRAM-SHA-256 asyncpg в event loop) и 2,7 мс CPU PostgreSQL против 0,6 и 0,15 мс из пула; пинг при выдаче — +0,13 мс реплики и +0,05 мс PostgreSQL на запрос evidence/storage/connection-cost.md

Сверка с рубрикой README. Каждому пункту — строка с командой, наблюдением и файлом:

Уровень Пункт README Строки таблицы выше
3 стенд одной командой, ≥2 API, одна точка входа, общие БД и сессии «3»: стенд одной командой…; итоговая проверка из чистого clone
3 разные запросы одного пользователя — разные реплики без повторного входа, X-Instance-Id, LB — основной маршрут «3»: разные запросы одного пользователя…; X-Instance-Id на каждом ответе
3 отказ любой одной реплики: ≤10 с до новых чтений и записей, подтверждённые сообщения доступны, ошибки измерены «3»: отказ любой одной реплики…; «3»: отказ процесса без graceful; «4»: последовательная остановка каждой реплики
3 повтор с тем же Idempotency-Key без дублей: конкурентный, при переключении реплики, неподтверждённая запись «3»: повтор POST…; другое тело с тем же ключом; повтор через другой процесс; при переключении реплики; ключ переживает рестарт; неподтверждённую запись можно повторить; «4»: идемпотентность под параллельными запросами
3 make test, persistence и failover проходят, ≥2 наблюдаемых реплики; hook подтверждён составом перезапущенных процессов публичный smoke; «3»: make test-persistence с LB (StartedAt всех контейнеров до и после); «3»: отказ любой одной реплики (STOP_ONE_LOG, docker compose ps -a); failover hook не трогает чужое
4 health/readiness, таймауты, SIGTERM согласованы; LB исключает недоступный backend; период проверок и максимальное время обнаружения «4» (часть): LB исключает недоступный backend; «4»: health/readiness, таймауты и прекращение приёма при SIGTERM; «4»: остановка реплики во время старта (SIGTERM не теряется и до старта сервера)
4 каждая реплика по очереди с восстановлением: RPS, ошибки, время восстановления; идемпотентность параллельными запросами «4»: последовательная остановка каждой реплики…; «4»: CPU и память профилей отказа и замены; «4»: идемпотентность под параллельными запросами
4 лимиты CPU/RAM, порты API не наружу, секреты только где нужно, нет container_name «4»: лимиты CPU/RAM…; порты из .env со стендом за LB
4 rolling update под нагрузкой; миграции однократно и совместимы «4»: rolling update…; «4»: CPU и память профилей отказа и замены; «4»: миграции однократно и совместимы; замена при сбое и неготовом стенде
5, трек 1 1/2/4 реплики при фиксированном бюджете; серия с ростом ресурсов «5», трек 1: 1/2/4 реплики…; серия с ростом ресурсов
5, трек 1 точка насыщения БД / LB / пула и почему рост перестаёт помогать «5», трек 1: точка насыщения…; граница пула; точка насыщения БД
5, трек 1 исходные данные, графики, одно подтверждённое улучшение; гипотеза, методика, ограничения «5», трек 1: исходные данные и графики; уровень шума; одно подтверждённое улучшение (с оговоркой); раздел «Цена масштабирования»

Пункты «Что сделать» README закрыты так же: миграции — один прогон сервиса migrate до реплик (в журналах реплик alembic нет), sticky session нет (balance roundrobin без cookie и stick-table, ответы одной сессии чередуются), новые реплики LB видит через DNS Docker без правки конфига (строка «Масштабирование без правки LB»).

Что приложено к PR (README, «Что должно быть в PR»): docker-compose.yml, конфигурация LB infra/haproxy/haproxy.cfg, scripts/restart.sh, scripts/stop-one.sh (и scripts/rolling-update.sh), Dockerfile, миграции migrations/ с alembic.ini, результаты отказов — evidence/failover/, evidence/rollout/, evidence/replicas/, evidence/tests/. Файл compose (README: «compose.yaml или stack.yaml») — docker-compose.yml: Compose находит его сам, как compose.yaml.

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

Три вида экспериментов: ручные отказы на рабочем стенде (таблица ниже), профили нагрузки уровня «4» и серии трека 1. Все замеры под нагрузкой — на отдельном проекте compose mtusi-bench с теми же образами и haproxy.cfg, что у рабочего стенда, генератор k6 — в сети стенда через LB. Хост общий: Apple M3 Pro (6 + 6 ядер, 18 ГиБ), Docker Desktop 29.8.2, ВМ 12 vCPU / 7,7 GiB; перед каждым замером проверены питание от сети, свободная память, отсутствие посторонних контейнеров и выгрузок в swap (паспорта meta.json; у профиля failover счётчик выгрузок — в evidence/failover/detection.md, у rollout — только занятый swap, у меток попытки 2 улучшения — Swapouts 0 в начале и в конце, поле swapouts_delta не записано, дефект паспорта исправлен change fix-known-issues, метки не правились; у меток resources обоих профилей — Swapouts в начале и в конце равны: 129 588 у failover, 157 300 у rollout, host_warnings пусты; прогон rollout с выгрузкой 7 236 страниц отброшен и переснят, evidence/tests/profile-resources-checks.md). Версии — раздел «Запуск из чистого clone». Сырые итоги k6, журналы LB, скрипта замены и 5xx (raw/*.log, исключение из правила *.log в .gitignore) и посекундные таблицы лежат рядом со сводками, без токенов и паролей.

Отказ реплик (failover) Поочерёдная замена (rollout) Трек 1 (scaling_*)
Гипотеза stop и kill без ошибок недоступности, pause исключается ≤ 6,5 с, восстановление ≤ 10 с, без потерь и дублей 0 ошибок при плановой замене, старая реплика после дренажа запросов не получает H1–H4 (раздел «Цена масштабирования»), записаны до прогонов
Лимиты API 1 CPU / 512 МиБ × 2, PostgreSQL 2 CPU / 1 ГиБ, HAProxy 1 CPU / 256 МиБ, Valkey 0,5 CPU / 128 МиБ — как у рабочего стенда; k6 без лимита (.claude/rules/bench.md); у меток resources — сэмплер 0,25 CPU / 128 МиБ, сумма 5,75 CPU из 12 те же; на пике замены — три реплики, сумма с сэмплером 6,75 CPU / 3,0 GiB из 12 / 7,75 реплики 1 × 4 … 6 × 1, PostgreSQL 2 или 0,5 CPU; k6 2 CPU / 1 ГиБ, сэмплер 0,25 CPU; сумма ≤ 12 vCPU
Данные чат чтения из 1 000 сообщений, отдельный чат записи те же чат чтения из 10 000 сообщений, 10 чатов записи
Нагрузка открытая модель, постоянная интенсивность: 100 записей с ключом + 100 чтений истории в секунду та же открытая модель 70/20/10 (история / запись / users/me): 250 и 500/с, затем поиск R* по ступеням
Длительность, прогрев фаза 15 с до действия (опорное окно) + 20 с до возврата + 15 с; 6 фаз, ~6 мин 15 с до замены, замена 8,9 с, ≥ 15 с после; 24 002 запроса прогрев 15 с (5 с подъёма между ступенями), окно 20 с
Повторы один прогон на фазу один прогон 3 повтора каждой конфигурации, свежий стенд на ячейку, A/A для шума
Успешные RPS, ошибки stop, kill: ~200/с, 0 ошибок; pause: 99–100/с в окне, 584–602 × 504 200/с, 0 ошибок R* 630–2 034 запросов/с при ошибках ≤ 1 %
p50 / p95 / p99 фаза stop 1: 3,5 / 6,1 / 97,1 мс за прогон; p95 по секундам — до 505 мс в секунду действия 3,3 / 5,0 / 9,7 мс за прогон p50 / p95 / p99 на 500/с по конфигурациям — таблица R* (p50 1,7–2,1 мс у всех); на каждой ступени — runs.csv
CPU / RAM метка resources, фазы 1–5 (ср. ядер): до действия реплика 0,28–0,31 (API всего 0,56–0,63), PostgreSQL 0,09–0,10, HAProxy 0,03, Valkey 0,01, k6 0,11–0,14, ВМ 1,03–1,16 из 12; в окне отказа выжившая реплика 0,37–0,43 (макс. 0,47–0,52), цель — 0; после возврата перезапущенная реплика 0,32–0,35 (макс. на старте 0,99–1,06). Пики памяти: реплика 87–126 МиБ из 512, PostgreSQL до 268 из 1 024, k6 до 420. CPU на успешный запрос до действия: API 2 810–3 136 мкс, PostgreSQL 432–478, ВМ 5 159–5 806. Фаза 06 — отдельно: всплеск хоста в окне «до» (API 1,13), пики памяти выше (PostgreSQL до 292) метка resources (ср. ядер до / подготовка / замена / после): API всего 0,57 / 0,60 / 0,82 / 0,58 (макс. 1,64 в замене), миграция 0,08 за 1 с жизни, PostgreSQL 0,08–0,10, ВМ 1,02 / 2,77 / 2,34 / 1,03 (сборка образа); пик памяти API 176 → 279 МиБ при трёх репликах. CPU на запрос до / после: API 2 876 / 2 895 мкс, PostgreSQL 432 / 440 посекундно у каждого контейнера и ВМ (samples.csv), CPU на запрос по компонентам
Файлы evidence/failover/baseline/, ресурсы — evidence/failover/resources/ (resources.csv, samples.csv) evidence/rollout/baseline/, ресурсы — evidence/rollout/resources/ evidence/bench/scaling-*/, evidence/plots/, evidence/compare/

Ограничения каждого замера — в конце его раздела, сводно — «Ограничения и следующие шаги».

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
docker stop одной из двух реплик (stop-one.sh) во время записи раз в 0,1 с закрытый сокет → отказ соединения → LB перенаправляет, ошибок нет 0 неудачных попыток в 2 прогонах (по одному на реплику); по 2 отправки перенаправлены (+1 в журнале LB), одна — через timeout connect 500 мс к пропавшему адресу первая запись 1,10–1,11 с от старта hook; потерь и дублей нет (evidence/failover/test-failover.md)
docker kill реплики запросы в полёте рвутся, LB их не повторяет; клиент повторяет с тем же ключом при записи раз в 0,1 с в полёте не оказалось ни одной (0 ошибок); при входах по Basic (driver.py kill-inflight) 3 оборванных → 502 без повтора, 2 перенаправлены первая запись 0,74 с; дублей нет; реплика не поднимается сама (evidence/failover/test-failover-kill.md)
docker pause одной реплики (зависла), до graceful-failover проверка ждёт timeout check и исключает реплику не позже 8 с; запрос в полёте — 504 DOWN через 7,7 с; запрос на ней — 504 в формате контракта через 10 с (timeout server), без повтора; после разморозки — UP через 1,1 с 7,7 с до исключения; второй запрос сразу ушёл на живую реплику (evidence/replicas/lb-errors.md). С graceful-failover граница 6,5 с, замер — таблица ниже
реплика заморожена посреди отправки с ключом (driver.py hang-key) ключ занят её транзакцией; PostgreSQL прерывает транзакцию через 10 с простоя, повтор того же ключа проходит повтор через живую реплику — 503 по statement_timeout (ждёт блокировку), через замороженную — 504; через 12,1 с PostgreSQL прервал простаивающую транзакцию, следующий повтор — 201 одно сообщение в чате, ключ и сообщение замороженной транзакции откатились (evidence/failover/hung-key.md)
остановка PostgreSQL реплики отвечают 503 на /health/ready, LB исключает обе и отвечает 503 сам первые ~2 с — 503 от API, затем 503 от LB на всё, включая /health/live; после запуска PostgreSQL обе реплики UP 1,2–1,6 с после запуска PostgreSQL, без рестарта реплик и LB (evidence/replicas/lb-errors.md)
остановка всех реплик LB отвечает 503 в формате контракта, healthcheck LB — unhealthy так и есть; после make replicas — 200 через ~3 с данные в Postgres не затронуты (evidence/replicas/lb-errors.md)
scripts/restart.sh: LB, обе реплики, Postgres, Valkey данные и токен переживают рестарт PASS; до прохождения проверок LB отвечал 503, реплики начинают в DOWN 6,4 с на тест целиком; кэш пуст, данные целы (evidence/replicas/test-persistence.md)
make rolling_update под tests/load.py (4 клиента): вперёд, откат на c50b721, снова вперёд новая реплика в LB до вывода старой, старая выводится из LB до SIGTERM — ошибок нет 0 неуспешных из 21 043, 16 687 и 18 480 запросов (84161c0); замена 10–12 с; новая миграция при прежних репликах — make test и make student_test проходят простоя нет; по messages.instance_id видно, какая версия что записала (evidence/rollout/compatibility.md)
docker stop стартующей реплики (driver.py stop-at-start: сигнал через 0,25–0,45 с после старта контейнера, во время импорта приложения) процесс с PID 1 получает SIGTERM и выходит сразу: запросов ещё нет «до» (628bbfa): сигнал потерян, сервер после него дошёл до «Uvicorn running on», docker stop 10,1 с, SIGKILL, код 137; «после» (edad1fd): 0,06 с, код 0, запись «Stopped API before startup»; сигнал на старте сервера и в работе — как раньше, uvicorn, ≤ 0,5 с, код 0 без потерь: запросов у стартующей реплики нет; окно запуска интерпретатора (десятки мс) осталось (evidence/failover/stop-at-start.md)
миграция ждёт блокировку messages за чужой 20-секундной транзакцией, через LB идут запись и чтение миграция сдаётся по lock_timeout, запросы в очереди за ней выполняются lock_timeout 5 с (apply): все 6 запросов из очереди — 503 через 5,03 с (statement_timeout приложения 5 с истёк вместе с ним); 2 с (84161c0): 0 ошибок, те же 6 запросов — 2,01–2,02 с схема и реплики не тронуты, повтор после конца транзакции прошёл (evidence/rollout/script-failures.md, случай 7)

Отказ каждой реплики под нагрузкой (change graceful-failover)

Гипотеза (design graceful-failover, решения 1–3):

  • docker stop реплики не даёт ошибок от её недоступности: закрытый сокет и пропавший адрес — отказ соединения, LB перенаправляет запрос;
  • docker kill — то же, кроме запросов в полёте на убитой реплике: 502 без повтора LB;
  • зависшую реплику (docker pause) LB исключает не позже 6,5 с, а до этого половина запросов ждёт timeout server и получает 504;
  • время восстановления до ≥ 99 % успешных в секунде — не больше времени исключения, то есть ≤ 10 с во всех режимах;
  • после повтора неуспешных записей с тем же ключом нет ни потерь, ни дублей.

Методика. make bench_failover FAILOVER_LABEL=baseline (bench/run.py, профиль failover; правила — .claude/rules/bench.md):

  • стенд mtusi-bench: HAProxy 3.4.6 с тем же haproxy.cfg, две реплики API по 1 CPU / 512 МиБ, PostgreSQL 2 CPU / 1 ГиБ, Valkey 0,5 CPU / 128 МиБ — лимиты рабочего стенда;
  • k6 2.3.0 в сети стенда, через LB, открытая модель с постоянной интенсивностью: 100 записей сообщения с Idempotency-Key и 100 чтений страницы истории (50 сообщений, чат из 1 000) в секунду;
  • фаза — одна реплика в одном режиме: 15 с нагрузки, действие, 20 с, возврат (docker start того же контейнера или docker unpause), 15 с. Порядок: stop реплики 1, 2, kill 1, 2, pause 1, 2;
  • время — часы ВМ Docker: действие — событие Docker, исключение и возврат — журнал HAProxy, запросы — отметки k6 при отправке; секунда запроса — по отправке;
  • после фазы неуспешные записи повторяются с тем же ключом до 201, затем сверка в PostgreSQL: сообщений в чате записи = отправленных ключей, разных текстов столько же.

Commit 459f84c, чистое рабочее дерево. Хост: Docker Desktop 29.8.2, macOS arm64, ВМ 12 CPU / 7,7 GiB; питание от сети, свободной памяти 56 %, посторонних контейнеров нет (рабочий стенд остановлен), выгрузки в swap за прогон не было (Swapouts до и после одинаковы). Один прогон на фазу: замер показывает поведение, а не распределение.

Результат (evidence/failover/baseline/summary.md, evidence/failover/detection.md):

Фаза Исключение LB, с (граница) Успешных в секунду в окне отказа, мин. Ошибки в окне отказа Мин. доля успешных в секунде Восстановление ≥ 99 %, с p95 успешных: до / макс. в окне, мс Возврат в LB, с Ошибки после возврата Сверка: сообщений = ключей
stop, реплика 1 1,06 (2,5), DNS 200 0 1 0 5 / 505 1,73 0 5 001 = 5 001
stop, реплика 2 1,01 (2,5), DNS 200 0 1 0 4 / 505 1,21 0 10 002 = 10 002
kill, реплика 1 1,81 (2,5), DNS 199 0 1 0 4 / 505 1,16 0 15 002 = 15 002
kill, реплика 2 0,79 (2,5), DNS 200 0 1 0 5 / 505 1,75 0 20 003 = 20 003
pause, реплика 1 6,00 (6,5), проверки 99 602 × 504 0,5 6 5 / 104 1,53 0 25 004 = 25 004
pause, реплика 2 5,83 (6,5), проверки 100 584 × 504 0,5 6 4 / 150 1,53 0 30 005 = 30 005

Итог по гипотезе:

  • stop и kill — подтверждено, ошибок 0. Остановленную и убитую реплику LB убирал по DNS через 0,79–1,81 с, раньше проверок. Цена — задержка: запросы, назначенные на пропавший адрес, ждали timeout connect 0,5 с и уходили на другую реплику (p95 505 мс в секунду действия). Запросов в полёте на убитой реплике в этих двух фазах не оказалось (p50 запроса — 3 мс). В самопроверках быстрого профиля — 1–2 ответа 502 на фазу kill и одиночный 502 в части фаз stop (гонка keep-alive при SIGTERM, evidence/failover/keep-alive.md); доля успешных и там не ниже 99 %.
  • pause — подтверждено с ценой: 5,83–6,00 с до исключения при границе 6,5 с, всё это время половина запросов получала 504 через 10 с, восстановление — 6 с. Во второй фазе все записи этих секунд попали на замороженную реплику (записи и чтения идут вперемешку поровну, round-robin чередует реплики). Зависшая реплика — самый дорогой отказ: её не видно, пока не провалятся две проверки по 2,5 с.
  • Возврат реплики — 1,2–1,8 с до UP, ошибок после возврата нет (init-state down, два успеха проверки).
  • Потерь и дублей нет: 240 и 584 неуспешные записи фаз pause повторены с тем же ключом — 201, сообщений столько же, сколько ключей.

Ограничения замера. Один хост: генератор, LB, реплики и PostgreSQL делят ВМ Docker. Один прогон на фазу. Интенсивность — около половины потолка одной реплики, чтобы после отказа оставшаяся держала всю нагрузку; на пределе мощности одной реплики отказ дал бы ещё и ошибки перегрузки. Отказ узла, LB и PostgreSQL не воспроизводится («Ограничения»).

Ресурсы (change profile-resources, метка resources)

Методика. make bench_failover FAILOVER_LABEL=resources — тот же профиль (нагрузка, фазы, окна, лимиты и пороги совпадают с baseline по паспортам), плюс наблюдатель:

  • сэмплер bench/sampler.sh в режиме scan в своём контейнере (0,25 CPU / 128 МиБ без swap, без сети, без паролей): раз в секунду обходит cgroup всех контейнеров ВМ (cpu.stat, memory.current, cpu.pressure) и читает /proc/stat ВМ, на часах ВМ, как шкала фазы. К PostgreSQL и LB не обращается, процессов в контейнерах стенда не запускает; роли контейнерам назначает оркестратор по меткам compose, чужие cgroup отбрасываются;
  • окна фазы: до действия (от первого запроса + 2 с разгона k6), окно отказа (действие → возврат), после возврата (до последнего запроса). docker start после stop / kill — новая cgroup, её CPU считается с момента возврата; у pause CPU интервалов, задевающих заморозку, относится к её внешней части (моменты — события Docker);
  • ячейка — среднее CPU за окно (CPU-секунды / длина окна) и наибольшее посекундное, пик памяти cgroup (с кэшем файлов) по отсчётам. Наибольшее посекундное — CPU интервала между отсчётами / его длина, по всем интервалам, задевающим окно, включая граничный; строка граничного интервала в samples.csv помечена соседним окном (окно строки — по концу интервала), поэтому максимум строк samples.csv одного окна бывает меньше «макс.» сводки (у rollout в подготовке ВМ 3,16 против 1,14 в строках окна). CPU на успешный запрос — только до действия: в окне отказа CPU идёт на ошибки, ожидание зависшей реплики и повторы LB, после возврата — на запуск процесса, и делитель «успешные» с этим не связан;
  • бюджет: сумма лимитов стенда и сэмплера 5,75 CPU / 2,5 GiB из 12 / 7,75; k6 без лимита — его CPU в таблице.

Commit 309a00d (код 2d267bf), чистое дерево; хост проверен (питание от сети, давления нет, посторонних контейнеров нет; по паспорту свободно 60 % памяти в начале и 48 % в конце, Swapouts 129 588 в начале и в конце). Один прогон.

Результат (evidence/failover/resources/summary.md, resources.csv, samples.csv): средние ядра, «макс.» — посекундный максимум, после «;» — пик памяти cgroup в окне, МиБ. Все диапазоны — по фазам 1–5 (все окна), фаза 06 — отдельно, ниже:

Компонент До действия Окно отказа После возврата Пик памяти за фазу, МиБ (лимит)
реплика-цель 0,28–0,31 (макс. 0,34–0,54); 94–122 stop/kill — 0 (контейнера нет); pause — 0,000; 104 0,32–0,35 (макс. 0,99–1,06 — запуск); 87–126 87–126 (512)
вторая реплика 0,29–0,31; 98–109 0,37–0,43 (макс. 0,47–0,52); 102–114 0,31–0,33; 103–115 98–115 (512)
API всего 0,56–0,63; 200–221 0,37–0,43; 103–206 (у stop/kill — одна реплика) 0,64–0,68 (макс. 1,45–1,54); 190–229 103–229 (сумма)
PostgreSQL 0,09–0,10; 219–261 0,07–0,08; 199–262 0,09–0,12; 226–268 199–268 (1 024)
HAProxy 0,03; 59–60 0,02; 57–64 0,03; 60–63 57–64 (256)
Valkey 0,01; 47–48 0,01; 48 0,01; 48 47–48 (128)
k6 (без лимита) 0,11–0,14; 341–370 0,08–0,09; 397–405 0,10–0,12; 403–420 341–420
сэмплер 0,003; 2 0,002–0,003; 3 0,003; 2–3 2–3 (128)
ВМ, занятые ядра из 12 1,03–1,16 (макс. 1,58–2,45) 0,75–0,88 1,10–1,22 —

CPU на успешный запрос до действия (≈ 200 успешных в секунду), мкс, фазы 1–5: API всего 2 810–3 136, PostgreSQL 432–478, HAProxy 153–174, k6 554–690, ВМ 5 159–5 806. С трека 1 эти числа напрямую не сравниваются: другая смесь (50 % записи и 50 % чтения страницы чата из 1 000 сообщений против 70/20/10 и чата из 10 000).

Фаза 06-pause-r2: первые ~6 с окна «до действия» — всплеск у всех компонентов сразу (реплики по 0,8–0,97 ядра с троттлингом CFS, PostgreSQL до 0,46, k6 до 1,3, ВМ до 4,3 ядра), p95 до действия 729 мс при 0 ошибок. Сэмплер — 0,01 ядра, выгрузок в swap за прогон не было. Причина не установлена, похоже на хост; ни одно окно этой фазы в диапазоны выше не включено. До действия: API всего 1,13 (макс. 1,93), CPU на запрос 5 653 мкс. В окне отказа и после возврата CPU — как у фаз 1–5 (вторая реплика 0,43 и 0,33, макс. 0,58; цель после возврата 0,36, макс. 0,97), а пики памяти выше: реплики до 127 МиБ, API всего до 254, PostgreSQL до 292, Valkey до 56.

Доступность рядом с baseline (phases.csv обеих меток):

Фаза Исключение LB, с Ошибки в окне отказа Восстановление, с Возврат в LB, с Ошибки после Сообщений = ключей
stop 1 1,06 / 0,45 0 / 0 0 / 0 1,73 / 1,98 0 / 0 5 001 / 5 001
stop 2 1,01 / 0,96 0 / 0 0 / 0 1,21 / 1,29 0 / 0 10 002 / 10 002
kill 1 1,81 / 0,66 0 / 1 × 502 0 / 0 1,16 / 0,87 0 / 0 15 002 / 15 003
kill 2 0,79 / 1,02 0 / 1 × 502 0 / 0 1,75 / 0,98 0 / 0 20 003 / 20 004
pause 1 6,00 / 6,16 602 / 618 × 504 6 / 7 1,53 / 1,70 0 / 0 25 004 / 25 004
pause 2 5,83 / 6,23 584 / 624 × 504 6 / 7 1,53 / 1,77 0 / 0 30 005 / 30 005

Условия различаются: commit 459f84c → 2d267bf (код приложения с тех пор — колонка messages.instance_id, 503 на «too many clients», пул 10 + 0, runtime API в haproxy.cfg), другая сессия хоста (2026-10-10 → 2026-10-12), наблюдатель. Поведение то же: обнаружение в пределах границы (2,5 / 6,5 с), восстановление ≤ 7 с, после возврата ошибок нет, сверка сошлась. В kill 2 метки resources реплику исключила проверка (DOWN, Layer4 timeout, 1,02 с), а не пропажа адреса в DNS, как в остальных фазах stop/kill обеих меток: это в границе 2,5 с и разброс момента, когда пропадает адрес, относительно проверок (evidence/tests/profile-resources-checks.md). Одиночные 502 в фазах kill — гонка keep-alive (evidence/failover/keep-alive.md, 0–4 на фазу в самопроверках), восстановление pause 7 с против 6 — в пределах разброса одного прогона. Влияние наблюдателя этим сравнением не отделяется: различаются и код, и сессия хоста.

Накладные расходы наблюдения: 0,003 ядра и 2–3 МиБ (16 мкс из ~5 100 мкс ВМ на запрос), ни соединений, ни запросов к стенду.

Вывод. Запас до лимитов большой: реплика при 100 + 100/с берёт ~0,3 ядра из 1 и ~0,4 после отказа второй, ~100–126 МиБ из 512; PostgreSQL — 0,1 ядра из 2; ВМ занята на ~1 ядро из 12. Отказ реплики стоит выжившей +36…+46 % CPU у stop и kill и +19 % у pause (фазы 1–5, среднее до действия → окно отказа), а не вдвое: в окне отказа всего API тратит меньше (0,37–0,43 против 0,56–0,63) — почему, этот замер не разделяет (у pause к тому же половина запросов висит на замороженной). Перезапуск — около секунды на пределе 1 CPU (импорт и старт uvicorn); новый процесс начинает с ~87 МиБ против ~100 до остановки. Замороженная реплика (фазы 05 и 06) CPU не тратит, её память держится (104–106 МиБ, колебание ±2 МиБ — буферы сокетов входящих соединений в cgroup); после разморозки она растёт до 126–127 МиБ — разбор накопленных за 20 с соединений.

Ограничения: один прогон на фазу; разрешение 1 с (CPU после последнего отсчёта перед остановкой не виден, первый интервал после docker start — до 1,06 ядра: счёт cgroup начинается чуть раньше события start); память — memory.current cgroup с кэшем файлов, пик по отсчётам; пропорциональное деление граничных интервалов (в окнах ≤ 3 с заметно, в окнах 15–20 с — нет); генератор, стенд и наблюдатель делят один хост. Посекундная таблица метки снята кодом 2d267bf: у фаз 05 и 06 в samples.csv у цели в окне отказа есть по одной строке с CPU (t_s 0,14 и 0,23, 0,24 ядра). Это интервал, задевающий pause: строка получила окно по концу интервала, а его CPU — до заморозки. Агрегаты (resources.csv, сводка, таблица выше) эту долю уже относят к окну до действия, в окне отказа у цели 0 / 0. С f34cb9a строка такого интервала помечается окном незамороженной части; метка не переснималась.

Поочерёдная замена под нагрузкой (change rolling-update)

Гипотеза (design rolling-update, решения 2–4):

  • клиент не видит ни одной ошибки, в том числе 502 гонки keep-alive из профиля failover:
    • новая реплика получает запросы только после UP в LB;
    • старая выводится из LB раньше SIGTERM;
  • в каждой секунде отвечают только реплики, которые сейчас в LB;
  • после вывода старая не получает ни одного запроса;
  • записи не теряются и не дублируются.

Методика. make bench_rollout ROLLOUT_LABEL=baseline (bench/run.py, профиль rollout; .claude/rules/bench.md):

  • стенд mtusi-bench с лимитами рабочего стенда, как у профиля failover;
  • реплики стартуют на образе c50b721 (git archive, схема 7652184b7016);
  • k6 — постоянная интенсивность, 100 записей с Idempotency-Key и 100 чтений истории в секунду;
  • через 15 с — scripts/rolling-update.sh против проекта стенда: сборка текущего checkout, миграция e656d6bbe1a4, замена обеих реплик;
  • ещё ≥ 15 с нагрузки после замены;
  • время — часы ВМ Docker: события контейнеров проекта (поток docker events), журнал HAProxy, отметки k6;
  • после прогона неуспешные записи повторяются с тем же ключом, затем сверка в PostgreSQL.

Commit 9dcea0b (код de654a1), чистое дерево. Хост: Docker Desktop 29.8.2, ВМ 12 CPU / 7,7 GiB, питание от сети, свободной памяти 52–53 %, swap занят 920 МиБ и за прогон не менялся (meta.json, host_state); счётчик Swapouts профиль rollout в паспорт не пишет. Посторонних контейнеров нет, рабочий стенд остановлен. Один прогон.

Итоговый код change — 84161c0: после замера verify поменял пути сбоя скрипта (уборка при Ctrl+C, предусловие о слотах, код выхода в строке) и lock_timeout миграции (2 с вместо 5 с). Порядок замены и то, что видит клиент, они не меняют: lock_timeout действует только при чужой блокировке, а в замере миграция получает её за миллисекунды. Поэтому полный замер не переснимался; быстрый профиль на 84161c0 — замена 8,1 с, 0 ошибок, сверка 7 301 = 7 301 (evidence/tests/rolling-update-checks.md).

Результат (evidence/rollout/baseline/summary.md):

Шаг Новая: старт → UP в LB, с Дренаж старой, с Остановка старой, с Шаг целиком, с Ошибок Запросов старой после дренажа
1 2,08 0,16 0,42 3,21 0 0
2 2,03 0,14 0,33 3,13 0 0
  • Замена целиком (от создания контейнера миграции до удаления последней старой) — 8,9 с; сборка из кэша 0 с, миграция 2 с.
  • Ошибок нет ни до, ни во время, ни после замены: 0 из 24 002 запросов. В каждой секунде 200 успешных, доля 1,0. p95 — 5 мс до замены, максимум 11 мс во время.
  • Ответы по версиям: первый ответ новой реплики — через 4,05 с, последний ответ старой — 8,3 с. В секунду 4 — 114 старых и 86 новых, в секунду 8 — 20 и 180, с секунды 9 — только новые.
  • Сверка: сообщений 12 001 = ключей 12 001, одинаковых текстов нет, повторять было нечего.

Итог по гипотезе: подтверждено. В профиле failover docker stop под той же нагрузкой давал одиночный 502 в части фаз. При плановой замене с дренажём 502 нет ни одного: запрос в слот, выведенный в drain/maint, LB не отправляет. Новая реплика вступает в работу через ~2 с после старта (init-state down, rise 2). Число реплик в LB не опускается ниже двух.

Ограничения замера. Один хост, один прогон: замер показывает поведение, а не распределение. Нагрузка — около половины потолка одной реплики. Под нагрузкой выше потолка двух реплик третья на время замены добавила бы CPU-конкуренцию. Сборка образа шла из кэша. Холодная сборка займёт больше времени, но на шаги замены не влияет: она идёт до миграции.

Ресурсы (change profile-resources, метка resources)

Методика. make bench_rollout ROLLOUT_LABEL=resources — тот же профиль и тот же сэмплер scan, что у failover (раздел выше): обход cgroup видит третью реплику и контейнер миграции с первого тика после их запуска, без перезапуска наблюдения. Окна (секунды от начала замены — создания контейнера миграции):

  • до — от первого запроса + 2 с до первого обращения скрипта к стенду (exec_start в событиях проекта, кроме проверок здоровья);
  • подготовка — проверки скрипта и сборка образа из кэша до начала замены;
  • замена — до удаления последней старой реплики;
  • после — до последнего запроса.

CPU на запрос — только до и после: в подготовке и замене CPU идёт на сборку, миграцию, старт третьей реплики, дренаж и остановку — цену процедуры. Бюджет на пике (три реплики + сэмплер) — 6,75 CPU / 3,0 GiB из 12 / 7,75; k6 без лимита.

Commit 309a00d (код 2d267bf), чистое дерево; хост проверен (питание от сети, давления нет, посторонних контейнеров нет; по паспорту свободно 75 % памяти в начале и 73 % в конце, Swapouts 157 300 в начале и в конце). Первый прогон отброшен: во время него хост выгрузил в swap 7 236 страниц (host_warnings), замена шла 12,0 с, p95 во время замены — 337 мс; переснят после освобождения памяти хоста (evidence/tests/profile-resources-checks.md). Один прогон.

Результат (evidence/rollout/resources/summary.md, resources.csv), ср. / макс. ядер («макс.» — как у failover, по всем интервалам, задевающим окно, включая граничный); пик памяти, МиБ; в скобках — сколько секунд окна контейнер существовал:

Компонент До (−14,1…−1,1 с) Подготовка (−1,1…0 с) Замена (0…7,35 с) После (7,35…104 с)
старая 97e43c2595ec 0,29 / 0,33; 88 0,30 / 0,31; 89 0,27 / 0,31; 91 —
старая bc2139090257 0,29 / 0,37; 88 0,30 / 0,31; 89 0,15 / 0,30; 90 (4,2 с) —
новая 83ea4a71fb8d — — 0,25 / 0,84; 103 (6,2 с) 0,29 / 0,36; 119
новая 5ae2ed238ef5 — — 0,15 / 1,02; 72 (1,8 с) 0,29 / 0,38; 92
API всего 0,57 / 0,64; 176 0,60 / 0,62; 177 0,82 / 1,64; 279 0,58 / 0,71; 212
миграция (лимит 0,5 CPU / 256 МиБ) — — 0,08 / 1,52*; 97 (1,0 с) —
PostgreSQL 0,09 / 0,11; 225 0,08 / 0,08; 225 0,10 / 0,13; 236 0,09 / 0,16; 240
HAProxy 0,03 / 0,05; 59 0,06 / 0,06; 60 0,06 / 0,08; 61 0,03 / 0,07; 63
Valkey 0,01 / 0,02; 37 0,01 / 0,01; 36 0,01 / 0,02; 36 0,01 / 0,02; 37
k6 (без лимита) 0,11 / 0,28; 351 0,09 / 0,09; 350 0,09 / 0,28; 386 0,10 / 0,40; 459
сэмплер 0,00; 3 0,00; 2 0,00; 2 0,00; 2
ВМ, занятые ядра из 12 1,02 / 1,81 2,77 / 3,16 2,34 / 3,35 1,03 / 2,34

* Первый интервал миграции — доли секунды от события start до отсчёта: CPU запуска контейнера до события попадает в него, и посекундное значение завышено. Во второй секунде миграция упирается в свой лимит: 0,52 ядра, троттлинг CFS 424 мс/с (samples.csv).

CPU на успешный запрос (≈ 200 в секунду), мкс, до / после: API всего 2 876 / 2 895, PostgreSQL 432 / 440, HAProxy 156 / 126, Valkey 54 / 50, k6 559 / 488, сэмплер 16 / 16, ВМ 5 110 / 5 141. Новая версия (с колонкой messages.instance_id) обслуживает запрос за то же CPU, что прежняя: разница меньше 1 %, в пределах одного прогона.

Доступность рядом с baseline (rollout.csv, replicas.csv):

baseline (код de654a1) resources (код 2d267bf)
Замена целиком, с 8,9 7,35
Ошибки до / во время / после 0 / 0 / 0 0 / 0 / 0
p95 до / макс. во время, мс 5 / 11 5 / 7
Первый ответ новой / последний старой, с 4,05 / 8,3 3,95 / 6,74
Ответов старой после дренажа 0 0
Шаг 1: старт → UP / дренаж / остановка / целиком, с 2,08 / 0,16 / 0,42 / 3,21 1,77 / 0,14 / 0,31 / 3,07
Шаг 2 2,03 / 0,14 / 0,33 / 3,13 0,90 / 0,14 / 0,33 / 1,90
Сообщений = ключей 12 001 12 001

Условия различаются: код de654a1 → 2d267bf (пул 10 + 0, 503 на «too many clients», lock_timeout миграции 2 с, правки путей сбоя скрипта), сессия хоста, наблюдатель. Поведение то же: ни одной ошибки, старая реплика после дренажа запросов не получает, шаги не дольше. Шаг 2 короче — новая реплика прошла проверки LB за 0,9 с; это разброс момента первой проверки (inter 1 с), а не изменение.

Накладные расходы наблюдения — те же 0,003 ядра и 2–3 МиБ, к стенду не обращается.

Вывод. Цена замены — в ВМ, а не в репликах: на подготовке и замене ВМ занята на 2,3–2,8 ядра вместо ~1. Контейнеры стенда вместе (с третьей репликой и миграцией) берут из них 0,84 ядра в подготовке и 1,14 в замене; остальные ~1,9 и ~1,2 ядра идут вне контейнеров стенда — сборка образа из кэша в BuildKit, dockerd, containerd (в окнах до и после вне контейнеров ~0,2 ядра). Как они делятся между этими процессами, замер не разделяет: сэмплер видит только cgroup контейнеров и ВМ целиком. API всего — 0,82 ядра против 0,57 и 279 МиБ памяти на пике (три реплики) против 176. До лимитов далеко: новая реплика на старте берёт до 1 ядра из своего 1 CPU около секунды, PostgreSQL на миграции — 0,13 ядра из 2. В свой лимит упирается только миграция (0,5 CPU, троттлинг 42 % в её единственную полную секунду), но живёт она около секунды.

Ограничения: один прогон; окна подготовки (1,1 с) и миграции (~1 с) короче нескольких отсчётов, их средние грубые; холодная сборка не мерилась; остальное — как у failover. В resources.csv метки (код 2d267bf) у контейнеров, которых в окне нет (новые реплики и миграция до замены, старые реплики и миграция после), CPU на запрос — 0,0 вместо пустого поля, шесть строк; сводка и таблицы выше их не показывают. С f34cb9a при present_s 0 CPU на запрос не считается.

Цена масштабирования (трек 1, change scaling-bench)

Уровень «5», трек 1 README.md. Гипотезы записаны и закоммичены до первой серии (design scaling-bench, решение 10); результат каждой — ниже, как получился.

Гипотезы.

  • H1. Фиксированный бюджет (серия a, опора R*(1 × 1) — из серии b: в серии a конфигурации 1 × 1 нет). При бюджете приложения 4 CPU / 2 ГиБ одна реплика 1 × 4 использует около одного ядра: один процесс uvicorn, один поток event loop, GIL не даёт распараллелить Python-код и в потоках executor. Поэтому R*(1 × 4) ≈ R*(1 × 1), а 2 × 2 и 4 × 1 растут почти пропорционально числу процессов, пока не упрёмся в PostgreSQL, LB или хост.
    • Предсказание: R*(1 × 1) ≈ 550–700/с; R*(1 × 4) / R*(1 × 1) — 0,9–1,15; R*(2 × 2) ≥ 1,7 × R*(1 × 1); R*(4 × 1) ≥ 3 × R*(1 × 1) или признак общего ресурса на 4 × 1.
    • Механизм: CPU контейнера 1 × 4 по секундам на ступенях R* и выше — около 1,0–1,2 ядра (samples.csv), троттлинг 1 × 4 около 0.
    • Подтвердит — всё вместе: отношение в [0,9; 1,15]; посекундный максимум CPU 1 × 4 ≤ 1,3 ядра, среднее на перегрузке ≤ 1,2; 2 × 2 ≥ 1,7 × R*(1 × 1); 4 × 1 ≥ 3 × R*(1 × 1) или сработал признак db_* / pool / lb / host / host_cost.
    • Опровергнет — хотя бы одно: R*(1 × 4) ≥ 1,25 × R*(1 × 1) или CPU 1 × 4 ≥ 1,5 ядра на перегрузке (процесс параллелится, и workers — не единственный способ занять бюджет); R*(2 × 2) < 1,5 × R*(1 × 1) без признака общего ресурса.
  • H1б. Троттлинг 1 × 1. p99 у 1 × 1 хуже, чем у 1 × 4, из-за троттлинга CFS (квота 100 мс на период 100 мс). Наш разбор до прогона: один поток не выбирает больше 100 мс за период, троттлинг требует второго потока (executor, время ядра на сеть) или работы у самой квоты. Вероятный исход — на 250 и 500/с троттлинг < 1 % периодов (H1б опровергнется), на ступени R* — заметный.
    • Подтвердит: на 500/с троттлинг 1 × 1 ≥ 1 % периодов и p99 1 × 1 > p99 1 × 4, разбросы не пересекаются. Опровергнет: троттлинг < 1 % или разбросы p99 пересекаются.
  • H2. Рост ресурсов (серия b, k = 1…6 по 1 CPU, PostgreSQL 2 CPU / 1 ГиБ фиксирован). R*(k) растёт почти линейно, пока каждая реплика упирается в свой CPU; рост останавливается, когда PostgreSQL выходит на свой лимит CPU или на запись WAL и commit. Арифметика до прогона: PostgreSQL тратит 0,3–0,45 мс CPU на запрос (калибровка bench_quick), 2 ядра кончатся около 4 500–6 500/с, то есть при k ≈ 7–9, а производительных ядер у хоста 6. Поэтому сильна конкурирующая гипотеза H2-хост: рост остановит хост раньше PostgreSQL (признак host_cost — CPU реплики на запрос растёт при той же нагрузке на реплику; host — задачи ВМ ждут CPU).
    • Предсказание: эффективность R*(k) / (k × R*(1)) ≥ 0,85 при k ≤ 3; k_sat ∈ {4, 5}; на k_sat + 1 — host_cost (или host) либо db_cpu, вероятнее host_cost.
    • H2 подтвердит: на k_sat + 1 (или k = 6 без k_sat) срабатывает db_cpu или db_wal, а CPU реплики падает ниже 0,9 — реплики ждут базу.
    • H2 опровергнет: на k_sat + 1 CPU PostgreSQL < 1,4 ядра и нет db_wal / db_lock — причину называет другой признак (host_cost, host, lb, pool); либо k_sat нет, и эффективность при k = 6 ≥ 0,8.
  • H3. Граница пула (серия pool). Пул приложения — 10 + 5 = 15 на реплику, пользователь приложения — суперпользователь (резерв superuser_reserved_connections его не держит), сэмплер занимает 1 соединение. На дефолтах граница — k = 7 (пул 10 + 5 того времени; с 10 + 0 change scaling-improvement — k = 10), вне серии b; опыт — 4 реплики при max_connections 100 (61 ≤ 100) и 50 (61 > 50).
    • Предсказание: при 100 отказов «too many clients» нет, на R* и выше pool_busy_share > 0, db_conn_replica_max доходит до 15; при 50, когда пулы вместе вырастают за 49 соединений, — отказы в журнале PostgreSQL и 5xx клиенту, R*(50) < R*(100), разбросы не пересекаются. По коду отказ даст 500 internal, а не 503: SQLSTATE 53300 нет в UNAVAILABLE_SQLSTATES (src/infra/db/errors.py), а спек data-storage требует 503.
    • Подтвердит: при 50 есть отказы и ошибки ≥ 1 % на уровне, который при 100 проходит; R*(50) < R*(100) без пересечения; при 100 отказов нет.
    • Опровергнет: при 50 отказов нет ни на одном уровне до нарушения SLO — реплики упираются в CPU раньше, чем копятся соединения.

H4. Пул без переполнения (change scaling-improvement, design решение 5). Записана после серий scaling-bench и до замеров «до/после» этого change: коммит с H4 (0b0421a) старше меток попытки 1 (scaling-db-aa, scaling-db-before, scaling-db-nooverflow), а план попытки 2 с тем же критерием (a676a52) — старше её меток (scaling-db-aa2, scaling-db-before2, scaling-db-nooverflow2).

  • Утверждение. У насыщенного PostgreSQL рост реплик вредит из-за переполнения пула (10 + 5). Под нагрузкой реплики открывают соединения сверх 10, а каждое новое стоит PostgreSQL ~2,4 мс CPU и реплике ~11 мс. База раньше уходит в троттлинг. Пул без переполнения (10 + 0, дефолт [database] max_overflow 5 → 0) отодвигает этот излом.

  • Механизм — откуда гипотеза (пробы при выборе на bbd6f65, не замер для отчёта; пробные метки в git не идут):

    • исходники SQLAlchemy (QueuePool._do_return_conn): возвращённое соединение закрывается, если в очереди пула уже pool_size простаивающих. Соединения сверх 10 живут, только пока заняты, и при спросе около 10 открываются снова и снова;
    • db_sessions_new серий — прирост pg_stat_database.sessions за окно 20 с: на 250 и 500/с у k ≥ 2 — 3–4 (фон); на R* scaling-b — от 103 (k = 1) до 283 (k = 6); у 4 × 1 при 0,5 CPU (scaling-db) на R* 931/с — 12–24, на 984/с — 79–144, там же соединений 60 и CPU PostgreSQL на запрос 412–496 мкс против 278–292 на 931/с;
    • микропроба цены соединения (рабочий стенд, PostgreSQL 2 CPU, реплика 1 CPU, итерация — проверка сессии и страница истории через функции repo): из пула с пингом при выдаче — 552–590 мкс CPU реплики и 130–138 мкс PostgreSQL; новое соединение на итерацию — 11 225–11 318 и 2 378–2 386 мкс. Почти вся цена реплики — SCRAM-SHA-256: asyncpg считает PBKDF2 на 4 096 итераций циклом hmac.new() в потоке event loop;
    • проба основной ячейки 4 × 1 при 0,5 CPU (один повтор, пул задан окружением): 10 + 5 — R* 931, на 1 041/с CPU PostgreSQL 482 мкс на запрос и 51 новая сессия за окно; 10 + 0 — R* 1 164, ~300 мкс до 1 164/с и 3–4 новые сессии на всех ступенях; 15 + 0 — R* 1 041.
  • Предсказание для 4x1-pg0.5 (основная ячейка):

    • медиана R* 931 → 1 101–1 301 (+18…+40 %), не меньше двух ступеней сетки (≥ 1 041);
    • новых сессий за окно «после» — не больше 10 и на R*, и на первой нарушившей ступени; «до» на первой нарушившей — не меньше 40;
    • соединений на R* «после» — не больше 40;
    • CPU PostgreSQL на запрос на R* «после» — не больше 330 мкс.
  • Предсказание для контроля 4x1-pg2: |Δ R*| меньше двух ступеней; CPU реплик на запрос на 500/с у 4x1-pg0.5 и 4x1-pg2 — в пределах ±5 % (переоткрытия там нет и до изменения).

  • Какие ячейки снимаются. Только основная 4x1-pg0.5 и контрольная 4x1-pg2, по 3 повтора, профиль scaling_db4 (SERIES=db4; те же поля, что у серии db) — у меток A/A, «до» и «после» одинаково. 1x1-pg0.5 и 2x1-pg0.5 не снимаются: пользователь решил сократить замеры (около 25 мин на метку вместо 50). Поэтому R*(4 × 1) «после» сравнивается с R*(2 × 1) = 1 101 из scaling-db только как справка (другая сессия), а не как критерий.

  • Порог — две ступени сетки: R* «после» / R* «до» ≥ √1,25 ≈ 1,118 (шаг сетки после двух делений 1,25^¼ ≈ 5,7 %; 931 → 1 041 — ровно две ступени).

  • Подтверждено, если выполнено всё:

    1. у 4x1-pg0.5 вывод make bench_compare … AA=scaling-db-aa (в попытке 2 — AA=scaling-db-aa2) — «эффект», и медиана «после» ≥ медиана «до» × 1,118;
    2. механизм по таблице «PostgreSQL на R* и первой нарушившей ступени»: «после» новых сессий за окно ≤ 10 на обеих ступенях, соединений на R* ≤ 40; «до» на первой нарушившей — ≥ 40 новых сессий;
    3. дрейфа сессии нет: CPU реплик на запрос на 500/с в пределах ±5 % у 4x1-pg0.5 и 4x1-pg2; шум A/A меньше двух ступеней.

    Если контроль сдвинулся на две ступени и больше, а пункт 3 выполнен, эффект основной ячейки засчитывается, а предсказание для контроля опровергнуто. Пункт 3 не выполнен — дрейф сессии хоста, не засчитывается ничего.

  • Опровергнет — хотя бы одно: у 4x1-pg0.5 разбросы пересекаются, Δ не больше шума A/A или меньше двух ступеней; переоткрытие «после» не исчезло (механизм не тот).

Методика (make bench_scaling SERIES=…, bench/run.py профили scaling_*, правила — .claude/rules/bench.md, раздел «Серии трека 1»):

  • Хост: Apple M3 Pro, 6 производительных и 6 энергоэффективных ядер, 18 ГиБ; ВМ Docker — 12 vCPU, 7,75 GiB. CFS-лимиты к ядрам не привязаны: при занятых больше 6 vCPU часть работы идёт на энергоэффективных ядрах.

  • Бюджет (сумма CPU стенда и генератора не больше CPU ВМ, иначе отказ до стенда):

    Контейнер CPU Память
    PostgreSQL 2 1 ГиБ
    HAProxy 1 256 МиБ
    Valkey 0,5 128 МиБ
    k6 2 1 ГиБ
    сэмплер 0,25 128 МиБ
    без реплик 5,75 2,5 ГиБ
    Серия Конфигурации Σ CPU
    a 1 × 4 / 2 ГиБ, 2 × 2 / 1 ГиБ, 4 × 1 / 512 МиБ 9,75
    b k × 1 / 512 МиБ, k = 1…6 6,75…11,75
    pool 4 × 1 / 512 МиБ при max_connections 100 и 50 9,75
    ab 1 × 1 и 6 × 1 (как в b) 6,75 и 11,75

    Серия b — до 6 реплик: при 7 сумма лимитов 12,75 CPU > 12 vCPU, и лимит перестал бы быть гарантией.

  • Профиль — открытая модель k6 (k6/mixed.js): 70 % — страница истории (limit=50, курсор из пула) читаемого чата из 10 000 сообщений, 20 % — отправка с новым Idempotency-Key в один из 10 чатов записи, 10 % — GET /users/me. Вход по Basic — до ступеней.

  • Ступень — один запуск k6: прогрев (15 с с нуля у первой ступени и после паузы, иначе 5 с подъёма от прежнего уровня) и окно 20 с. Сначала 250 и 500 запросов/с, затем поиск: начало — ступенька 100 × 1,25^i ≥ max(300 × реплик, пройденный фиксированный); подъём до первой нарушившей (если нарушена первая — спуск), затем два деления по среднему геометрическому. Разрешение — не грубее 6 %.

  • SLO ступени: p95 успешных ≤ 200 мс и (ошибки + неполные страницы + недосланные генератором) / запланированные ≤ 1 %. R* — наибольший прошедший уровень поиска.

  • Ячейка — конфигурация × повтор, 3 повтора, каждая на свежем стенде; порядок — круги с перемешиванием (зерно 20261011). В отчёт — медиана и min–max.

  • Метрики ступени — посекундный сэмплер (cgroup каждого контейнера: CPU, троттлинг, память; загрузка и PSI ВМ; статистика HAProxy; PostgreSQL: соединения по репликам и wait_event, commit/s, WAL), итог k6 по окну и распределение по X-Instance-Id. Узкое место называется признаками с порогами, заданными до прогонов (THRESHOLDS в bench/scaling.py): app, db_cpu, db_wal, db_lock, pool, lb, host, host_cost, generator. После коммита гипотез, но до первой серии, на самопроверках уточнены два определения (design, «Найдено в apply»): host_cost — по наклону CPU реплик от запросов в секунду, а не по CPU на запрос на 500/с, и минимум 1 активного соединения для признаков ожиданий (db_active_min). По исходному определению host_cost (CPU на запрос на 500/с, runs.csv) отношения к 1 × 1 — 1,00 / 1,07 / 1,16 / 1,23 / 1,29 / 1,41 для k = 1…6: признак тоже растёт с k, вывод тот же.

  • Точка насыщения k_sat серии b — наименьшее k ≤ 5, при котором медиана R*(k + 1) < 1,1 × R*(k); причина — признак общего ресурса на k_sat + 1, не сработавший на k_sat − 1.

Метки и графики. Серии сняты на commit с кодом приложения 712d245 (метки — на последующих commit документов, dirty: false), хост проверен перед каждой серией: питание от сети, свободно 49–55 % памяти (паспорта, host_state в начале и в конце), посторонних контейнеров нет, рабочий стенд остановлен, выгрузок в swap за серии 0 (evidence/tests/scaling-bench-checks.md, раздел «Проверки хоста перед сериями»). Брака генератора нет ни в одной ячейке: CPU k6 на вершине серии B — 0,7–0,8 ядра из 2, троттлинг 0.

Метка Серия Ячеек Время Файлы
scaling-a бюджет 4 CPU 9 37 мин evidence/bench/scaling-a/
scaling-b рост 1…6 18 74 мин evidence/bench/scaling-b/
scaling-pool граница пула 6 24 мин evidence/bench/scaling-pool/
scaling-aa A/A (1 × 1 и 6 × 1) 6 21 мин evidence/bench/scaling-aa/

Сводная таблица и графики — make bench_plots LABELS="scaling-a scaling-b" PLOTS=scaling → evidence/plots/scaling/: summary.md, R* от числа реплик, p95 от интенсивности, серия a, серия b, CPU по компонентам на R*. Исходные данные — runs.csv (строка на ступень), searches.csv (строка на ячейку), samples.csv (посекундные CPU, троттлинг и память каждого контейнера и загрузка ВМ) и итоги k6 в raw/ каждой метки.

Результат: R по конфигурациям* (медиана (min–max) трёх повторов, evidence/plots/scaling/summary.md):

Серия Конфигурация R*, запросов/с R* / (k × R*(1 × 1)) p50 / p95 / p99 на 500/с, мс Предельный CPU реплик на запрос, мкс host_cost
a 1 × 4 630 (630–704) 0,95 2,1 / 62,0 / 91,8 1 436 1,05
a 2 × 2 1 101 (1 041–1 164) 0,83 1,9 / 3,2 / 5,5 1 766 1,29
a 4 × 1 1 819 (1 539–1 819) 0,68 1,9 / 2,9 / 4,3 2 166 1,58
b 1 × 1 666 (666–704) 1,00 2,0 / 54,1 / 87,7 1 370 1,00
b 2 × 1 1 164 (1 164–1 231) 0,87 1,7 / 2,8 / 5,0 1 644 1,20
b 3 × 1 1 539 (1 539–1 539) 0,77 1,8 / 2,7 / 4,1 1 918 1,40
b 4 × 1 1 819 (1 819–1 819) 0,68 1,9 / 2,9 / 4,1 2 168 1,58
b 5 × 1 2 034 (1 923–2 034) 0,61 1,9 / 2,9 / 4,2 2 463 1,80
b 6 × 1 2 034 (1 923–2 034) 0,51 2,1 / 3,0 / 4,2 2 906 2,12
pool 4 × 1, max_connections 100 1 819 (1 720–1 819) — 1,9 / 2,9 / 4,2 2 198 —
pool 4 × 1, max_connections 50 1 539 (1 539–1 627) — 1,9 / 2,9 / 4,2 2 243 —

Задержки — медиана трёх повторов на фиксированной ступени 500/с (столбцы p50_ms, p95_ms, p99_ms строк step_kind = fixed в runs.csv метки; там же 250/с и каждая ступень поиска). У одной реплики (1 × 1, 1 × 4) на 500/с медиана почти та же, что у нескольких, а хвост p95 / p99 — примерно в 20 раз длиннее: 500/с — 75–79 % её R*, и часть запросов, по-видимому, уже ждёт в очереди единственного event loop.

Предельный CPU на запрос — наклон CPU реплик от успешных запросов в секунду по ступеням ячейки, прошедшим SLO (без постоянных расходов реплики: проверки LB, простой event loop); host_cost — он же относительно 1 × 1 серии b.

Точка насыщения — k_sat = 5 по правилу решения 9 (R*(6) = 2 034 < 1,1 × R*(5) = 2 237), но на границе разрешения сетки. Прирост на реплику: +75 %, +32 %, +18 %, +12 %, +0 %; эффективность падает с первой же добавленной реплики (0,87 при k = 2). Разрешение поиска после двух делений — шаг ≈ 5,7 %: истинный R*(4) лежит в [1 819; 1 923), R*(5) — в [2 034; 2 151), и прирост 4 → 5 — от +6 до +18 % при пороге 10 %. Один повтор 5 × 1 из трёх дал 1 923; будь таких два, правило дало бы k_sat = 4. Поэтому в пределах разрешения k_sat ∈ {4, 5}. «+0 %» между 5 и 6 значит |Δ| < 5,7 %: у k = 5 и k = 6 одно дерево поиска (L0 = 1 819, затем 2 274 нарушена, деления 2 034 и 2 151), и оба R* — в одной ступени. Порог k_sat устойчиво не пройден только парой 5 → 6. Предсказание H2 (k_sat ∈ {4, 5}) от этого не меняется.

Узкое место — по метрикам ступени R*: таблица ниже — раздел «Цена запроса и общие ресурсы на R*» в evidence/plots/scaling/summary.md (make bench_plots, медианы по повторам серии b; рост — к k = 1):

k CPU реплик на R*, ядер на реплику CPU на успешный запрос на R*, мкс: реплики / PostgreSQL / HAProxy / k6 Рост к k = 1 Занято ядер ВМ PSI CPU ВМ CPU PostgreSQL, ядер из 2 Соединений PostgreSQL Ожидания WAL, доля активных
1 0,97 1 440 / 266 / 55 / 219 — 1,8 0,4 % 0,18 15 0 %
2 0,97 1 654 / 324 / 60 / 229 ×1,15 / ×1,22 / ×1,08 / ×1,05 3,3 0,9 % 0,38 30 0 %
3 0,97 1 886 / 390 / 69 / 247 ×1,31 / ×1,47 / ×1,24 / ×1,13 4,6 1,7 % 0,60 45 0 %
4 0,96 2 106 / 432 / 81 / 272 ×1,46 / ×1,62 / ×1,47 / ×1,24 5,8 3,4 % 0,79 60 5 %
5 0,95 2 332 / 495 / 97 / 310 ×1,62 / ×1,86 / ×1,75 / ×1,42 7,1 6,6 % 1,01 73 18 %
6 0,93 2 754 / 540 / 124 / 342 ×1,91 / ×2,03 / ×2,24 / ×1,56 8,1 11,6 % 1,10 89 22 %

Почему рост реплик перестаёт помогать. Каждая реплика на R* занята своим процессом почти полностью (0,93–0,97 ядра, признак app у всех конфигураций), а общий ресурс стенда — PostgreSQL, LB, пул — не насыщен:

  • PostgreSQL на k = 6 занимает 1,1 ядра из 2. Ожидания WAL — 15–28 % активных соединений по повторам (медиана 22 %, порог признака 30 %), блокировок нет. Крупнейший класс — прочие ожидания (other: Client, IPC, Timeout и остальное; 0,35–0,9 соединения), их состав не записывался: в runs.csv только сумма класса;
  • HAProxy — 0,25 ядра из 1, очередь 0, ошибок соединения и ответа нет;
  • пул: отказов нет, признак pool не сработал (pool_busy_share ≤ 0,1), но пул каждой реплики на R* заполнен до 15 соединений, а за R* запросы ждут его до 5 с и получают 503 (серия pool, ниже).

Растёт другое: цена того же запроса в CPU у всех компонентов сразу. От k = 1 к k = 6 запрос стоит репликам ×1,91, PostgreSQL ×2,03, HAProxy ×2,24, генератору ×1,56 CPU-времени, а на 250 и 500/с, где ВМ занята на 0,8–1,7 ядра, цена запроса у PostgreSQL от k не зависит (220–300 мкс). HAProxy и k6 от кода приложения не зависят, а дорожают тоже. Значит, дорожает не код и не база, а секунда CPU хоста под нагрузкой: чем больше vCPU ВМ занято (1,8 → 8,1 из 12), тем меньше работы она даёт.

Механизм этим замером не разделяется. Один и тот же признак — рост CPU на запрос с числом занятых vCPU — дают:

  • vCPU на энергоэффективных ядрах M3 Pro (6 P + 6 E);
  • снижение частоты производительных ядер под многоядерной нагрузкой;
  • накладные расходы гипервизора и сетевого стека ВМ, учтённые в cgroup;
  • конкуренция за кэш и память;
  • у k6 — ещё и рост числа занятых VU (медианы по повторам на ступени R* 66 → 249, максимум 309).

Ни одна метрика не показывает, на каких физических ядрах шла работа. Проверено и исключено: генератор (≤ 0,88 ядра из 2 посекундно, троттлинг 0, недосланных на ступенях R* нет), HAProxy (≤ 0,30 ядра из 1, очередь 0) и переоткрытие соединений LB → реплика (проба verify: keep-alive-сессия держит своё соединение к каждой реплике, 200 запросов — 2 новых соединения и 198 повторных использований).

Это признак host_cost (сработал уже с k = 2, 1,20 → 2,12), а не host: очереди к vCPU внутри ВМ почти нет (PSI ≤ 12 %, порог 20 %). Проверка порядка величины (арифметика над числами сводки, не таблица команды): R*(k) ≈ k × CPU реплики / предельный CPU на запрос; для k = 6 — 6 × 0,93 / 2 906 мкс ≈ 1 920/с при измеренных 1 923–2 034. Прирост числа реплик съедается ростом цены запроса, и после k = 5 R* стоит.

Итог: на этом стенде с дефолтными лимитами точку насыщения задаёт хост — общий CPU ноутбука для реплик, PostgreSQL, LB и генератора, а не БД, LB или пул; каким механизмом секунда CPU дешевеет, замер не разделяет. Границы пула и БД достижимы управляемыми опытами (серии pool и db, ниже): на дефолтах граница пула — k = 7 (пул 10 + 5 того времени; с 10 + 0 — k = 10), за пределом бюджета ВМ, а PostgreSQL 2 CPU занят на 1,1 ядра.

Память нигде не была узким местом (раздел «Память» той же сводки, пики за серию): RSS процесса реплики — 106–135 МиБ при лимите 512 МиБ (у 1 × 4 — 106 МиБ из 2 ГиБ), PostgreSQL — до 411 МиБ из 1 ГиБ, k6 — до 253 МиБ из 1 ГиБ.

Граница пула (scaling-pool, 4 × 1, пул 10 + 5 на реплику):

  • max_connections 100: соединений не больше 60 (15 на реплику), отказов «too many clients» 0 на всех 20 ступенях (7 + 6 + 7). 5xx — только 503 от самих реплик на перегрузке (1–11 за окно на 2 034/с, 17–27 на 2 274/с): запрос ждал свободное соединение пула дольше pool_timeout 5 с (строки API "status": 503 с duration_ms ≈ 5 010 и строки LB api/api-N 0/0/0/50xx/50xx 503 в raw/*-errors.log); на ступенях с 503 LB реплики не исключал (lb_chkdown 0), одно исключение — на 1 923/с в 4x1-r1, без 5xx. При 50 на 1 819/с LB исключал реплики (по 2 раза в 4x1-c50-r1 и -r3) — на ступени с тысячами отказов «too many clients»; что проверку роняли именно они, журналы не показывают (строк проверок в raw/*-errors.log нет). Тот же механизм — у 503 серий a (4 × 1, 1–11 за окно) и b (2 × 1 — 1, 3 × 1 — 1–6, 4 × 1 — 1–8) за R*.
  • max_connections 50: пулы упираются в 49 соединений (50 − 1 слот сэмплера). Отказы начинаются уже на 1 455/с — 10–200 за окно при ошибках 0,03–0,7 % (ступень проходит SLO), на 1 627/с — 314–785 (0,97–2,4 %, в двух повторах из трёх — нарушение), на 1 819/с — 4 514–5 060 (24–29 %). R* = 1 539 (1 539–1 627) против 1 819 (1 720–1 819) при 100, разбросы не пересекаются, причина первого нарушения — errors.
  • Код ответа на отказ — 500, а не 503. Число ответов 500 в окне почти равно числу отказов в журнале PostgreSQL (25 и 25, 5 060 и 5 071). В журнале API — «Exception in ASGI application», asyncpg.exceptions.TooManyConnectionsError → sqlalchemy.exc.DBAPIError: SQLSTATE 53300 нет в UNAVAILABLE_SQLSTATES (src/infra/db/errors.py), и get_db_session не переводит отказ в 503. Так ведёт себя измеренный commit 712d245: серия pool снята до правки, спек data-storage требует 503. Доказательства окна — строки PostgreSQL, API и LB в evidence/bench/scaling-pool/raw/*-errors.log. Исправлено после серий в 68edc66: 53300 добавлен в UNAVAILABLE_SQLSTATES. Проба тем же отказом (все слоты max_connections заняты, соединения пула оборваны) даёт 503 unavailable в формате контракта с X-Instance-Id реплики — тест make failure_checks (test_connection_limit_reached, без правки он красный: 500) и запрос через LB на рабочем стенде (evidence/storage/too-many-clients.md). Серия pool не перемерялась: правка меняет код ответа, а не число отказов, и R*(50) определяется ошибками ≥ 1 % при любом коде.

Насыщение PostgreSQL (scaling-db, управляемый опыт после verify, решение пользователя): на дефолтах PostgreSQL не насыщался, поэтому его лимит CPU сужен до 0,5 при 1, 2 и 4 репликах по 1 CPU; контроль — 4 × 1 при прежних 2 CPU. 4 конфигурации × 3 повтора в одной метке, перемешанным порядком, на коде 95539a1 (после правки 53300, поэтому с метками b и pool не сравнивается: контроль снят заново). Лимит 0,5 выбран калибровкой db_quick и записан в design до серии (46e8f75): при нём БД упирается около 1 000–1 160/с — раньше потолка 4 реплик и около потолка 2. Ожидание до серии: R*(4) ≈ R*(2). Хост проверен, выгрузок в swap 0, брака генератора нет (evidence/tests/scaling-bench-checks.md, раздел 10).

Конфигурация R*, запросов/с Признаки на R* / на первой нарушившей CPU PostgreSQL на R* (доля лимита) Троттлинг PostgreSQL на первой нарушившей CPU PostgreSQL на запрос: R* → первая нарушившая, мкс Соединений
1 × 1, PostgreSQL 0,5 630 (630–630) app / app 0,19 (0,38) 0 298 → 284 15
2 × 1, PostgreSQL 0,5 1 101 (1 101–1 101) app / app 0,38 (0,77) 4,8 % 348 → 349 30
4 × 1, PostgreSQL 0,5 931 (931–931) host_cost / db_cpu db_wal host host_cost 0,26 (0,52) 68 % 279 → 441 41 → 60
4 × 1, PostgreSQL 2 (контроль) 1 627 (1 627–1 627) app host_cost / app host_cost 0,76 (0,38) 0 468 → 492 60

Таблица — разделы «PostgreSQL на R*» evidence/bench/scaling-db/summary.md и «Насыщение PostgreSQL» evidence/plots/scaling-db/summary.md (make bench_plots LABELS="scaling-db" PLOTS=scaling-db), график — R* от числа реплик.

  • Точка насыщения БД при 0,5 CPU — около 950–1 000 запросов/с при 4 репликах: на 931/с PostgreSQL занят на 0,26 ядра и p95 3,8 мс, а уже на 984/с (+5,7 %, следующая ступень) он выбирает квоту — 0,43 ядра, троттлинг 68 % периодов (на 1 041–1 455/с — 0,48–0,50 ядра и до 100 %), p95 244 мс, срабатывают db_cpu и db_wal. CPU реплик при этом — 2,2–2,4 ядра из 4: реплики ждут базу.
  • Рост реплик перестаёт помогать — и вредит. 1 → 2 реплики: R* растёт (630 → 1 101), узкое место — CPU реплик, PostgreSQL на 77 % лимита. 2 → 4: R* падает на 15 % (1 101 → 931), разбросы не пересекаются (во всех повторах одно и то же значение). Ожидание «почти не растёт» подтвердилось сильнее, чем предполагали: у 4 реплик за R* CPU PostgreSQL на запрос растёт с 279 до 441 мкс. Главная причина — переполнение пула 10 + 5 (установлено change scaling-improvement): 4 реплики набирают до 60 соединений против 30, соединения сверх 10 на реплику после возврата закрываются и открываются снова — новых сессий за окно 79–144 на 984/с против 12–24 на 931/с, а новое соединение стоит ~2,7 мс CPU PostgreSQL и ~11,7 мс CPU реплики (evidence/storage/connection-cost.md). С пулом 10 + 0 R*(4 × 1) — 1 101, столько же, сколько R*(2 × 1) здесь (другая сессия, справка), новых сессий на первой нарушившей 102 → 4. Предел, который остаётся, — квота CPU PostgreSQL 0,5: выше излома база выбирает её при любом пуле (336 мкс на запрос на первой нарушившей против 277–293 на R*; раздел «Улучшение…»). Тот же лимит при 2 репликах держит 1 101/с при 348 мкс на запрос.
  • Контроль: 4 × 1 при 2 CPU PostgreSQL — 1 627/с, PostgreSQL на 38 % лимита, узкое место — реплики и хост, как в серии b. С scaling-b (1 819) не сравнивается: другая сессия и другой код.

Saturation point БД / LB / пула (рубрика «5», трек 1):

  • БД — показана управляемым опытом scaling-db: при 0,5 CPU PostgreSQL насыщается около 950–1 000/с, добавление реплик с 2 до 4 снижает R* на 15 %. На дефолтах (2 CPU) в пределах бюджета ВМ БД не насыщается: 1,1 ядра из 2 при 6 репликах.
  • Пул — показан управляемым опытом scaling-pool: при max_connections 50 отказы «too many clients» с 1 455/с и R* 1 539 против 1 819; на дефолтах граница — k = 7 (пул 10 + 5 того времени; с 10 + 0 — k = 10), за бюджетом ВМ. За R* реплики ждут свободное соединение пула до 5 с (503).
  • LB — не насыщен ни в одной серии: HAProxy ≤ 0,30 ядра из 1, очередь 0, ошибок соединения нет.
  • Хост — на дефолтах именно он останавливает рост реплик (k_sat ∈ {4, 5}, host_cost), механизм не разделён.

Одно подтверждённое улучшение (рубрика «5», трек 1) — закрыто с оговоркой.

  • Изменение: пул без переполнения, change scaling-improvement.
  • При насыщенном PostgreSQL R* 4 реплик вырос 931 → 1 101 (+18,3 %, «эффект», шум A/A 5,4 %), переоткрытие соединений пропало.
  • Оговорка: по букве заранее записанного критерия проверка дрейфа нарушена на 0,4 п. п. Против A/A2 той же сессии дрейфа нет, сдвиг R* +11,9 %, две ступени. Засчитано решением автора после результатов.
  • Раздел «Улучшение по найденному узкому месту: пул без переполнения».

Итог по гипотезам.

  • H1 — по заранее записанным критериям не подтверждена целиком. «Подтвердит» требовало выполнения всех условий, и одно не выполнено.

    • Механизм подтверждён: R*(1 × 4) / R*(1 × 1) = 630 / 666 = 0,95 ∈ [0,9; 1,15]; посекундный максимум CPU реплики 1 × 4 за всю серию — 1,00 ядра, среднее на ступенях перегрузки — 1,00 ядра (пороги 1,3 и 1,2), троттлинг 1 × 4 — 0. Один процесс uvicorn из 4 ядер лимита занимает одно, и бюджет занимают только процессы: 4 × 1 = 1 819 (2,73 × R*(1 × 1), сработал host_cost 1,58 — условие для 4 × 1 выполнено).
    • Не выполнено условие «2 × 2 ≥ 1,7 × R*(1 × 1)»: 2 × 2 = 1 101, то есть 1,65 × — на один шаг сетки ниже порога (1 101 → 1 164 — +5,7 %).
    • Опровержение тоже не наступило: 2 × 2 < 1,5 × R*(1 × 1) нет, и на 2 × 2 сработал признак общего ресурса host_cost (1,29).
    • Чувствительность к опоре: с R*(1 × 1) из A/A (704) 2 × 2 — 1,56 ×, а 1 × 4 / 1 × 1 — 0,89, то есть ниже 0,9; по медиане шести повторов 1 × 1 (685) — 1,61 и 0,92.

    4 × 1 серии a и k = 4 серии b совпали (1 819, ниже — сравнение).

  • H1б — опровергнута на фиксированных уровнях, как и ожидал наш разбор. На 500/с троттлинг 1 × 1 — медиана 0 (0–1,1 % периодов), p99 1 × 1 87,7 (86,3–87,8) мс против 1 × 4 91,8 (86,6–102,5) — разбросы пересекаются. На ступени R* троттлинг 1 × 1 заметен — 2,1 (1,1–6,9) % периодов (1 × 4 — 0), на нарушивших ступенях до 21 %, но p99 на R* (183–262 мс у 1 × 1 и 203–234 мс у 1 × 4) не разделяются (таблица троттлинга в evidence/plots/scaling/summary.md, раздел «Фиксированный бюджет»).

  • H2 — опровергнута; подтвердилась конкурирующая H2-хост. k_sat = 5 ∈ {4, 5}, как предсказано (в пределах разрешения сетки — тоже {4, 5}), но на k_sat + 1 = 6 CPU PostgreSQL — 1,10 ядра (< 1,4), признаков db_cpu, db_wal, db_lock нет; CPU реплики не падает (0,93 ядра) — реплики не ждут базу. Причину называет host_cost: цена запроса растёт у всех компонентов вместе с занятыми ядрами хоста. Предсказание эффективности ≥ 0,85 при k ≤ 3 тоже не выполнено (0,87 и 0,77): дорожание начинается сразу. Строгое правило причины решения 9 («сработал на k_sat + 1 и не срабатывал на k_sat − 1») ни один признак не выполняет: host_cost нарастает постепенно с k = 2 — насыщение плавное, а не ступенька.

  • H3 — подтверждена. При max_connections 50 отказы «too many clients» и ошибки ≥ 1 % на 1 627–1 819/с, где при 100 ошибок меньше 0,1 % и ступени проходят SLO (кроме одной 1 819/с по p95); R*(50) < R*(100) без пересечения разбросов; при 100 отказов нет. Первая часть предсказания — «до границы растёт ожидание свободного соединения» — тоже видна: при 100 на R* пул каждой реплики заполнен до 15 во всех повторах, а за R* ожидание пула доходит до pool_timeout 5 с, и реплика отвечает 503. Код ответа на отказ — 500 на измеренном commit 712d245 (серия pool снята до правки), как и предсказывал разбор кода; после правки 68edc66 — 503 unavailable (тест make failure_checks и проба через LB, evidence/storage/too-many-clients.md).

  • H4 — подтверждена с оговоркой.

    • Окончательная попытка 2: R* основной ячейки 931 → 1 101 (+18,3 %), вывод команды «эффект», шум A/A 5,4 %, механизм подтверждён.
    • По букве критерия проверка дрейфа нарушена: −5,4 % при пороге ±5 %, из-за двух ячеек «до».
    • Против A/A2 той же сессии дрейфа нет (1 940 и 1 936 мкс). Там R* 984 → 1 101, +11,9 %, две ступени, «эффект». Засчитано решением автора после результатов.
    • Попытка 1 не прошла из-за помех на хосте.

    Подробно — раздел «Улучшение по найденному узкому месту: пул без переполнения» ниже.

Уровень шума и согласованность серий (make bench_compare):

  • A/A — метка scaling-aa (профиль scaling_ab: 1 × 1 и 6 × 1 серии b, тот же код, другая сессия): 1 × 1 — 666 (666–704) → 704 (666–704), +5,7 %; 6 × 1 — 2 034 (1 923–2 034) → 2 034 (2 034–2 034), Δ медиан 0, то есть |Δ| < 5,7 % (одна ступень сетки). CPU на запрос — в пределах 1 %; p95 — до 3,3 % (6 × 1 на 500/с 3,0 → 3,1 мс), p99 на 250/с — до 7 % (1 × 1 5,6 → 6,0 мс, 6 × 1 4,3 → 4,1 мс; evidence/compare/scaling-b__scaling-aa.md). Шум R* ≈ 5,4–5,7 % (5,4 % — compare.py с AA, Δ относительно A/A; 5,7 % — b → aa) — одна ступень деления. Оценён по двум конфигурациям × 3 повтора. Сдвиг на одну ступень при непересекающихся разбросах команда назовёт эффектом, но он в пределах разрешения: эффект R* засчитывается при сдвиге не меньше двух ступеней (× 1,118, +11,8 %; порог уточнён до замеров change scaling-improvement) или с оговоркой (bench.md). Для scaling-improvement scaling-aa как AA не годится: правка 53300 (68edc66) изменила код приложения после неё, поэтому A/A снимается заново на коде «до» (design, «Найдено в verify»).
  • 4 × 1 серии a против k = 4 серии b (одна конфигурация в разных сериях и сессиях): 1 819 (1 539–1 819) и 1 819 (1 819–1 819), Δ 0 % (evidence/compare/scaling-b__scaling-a.md).

Улучшение по найденному узкому месту: пул без переполнения (change scaling-improvement)

Итог: H4 подтверждена с оговоркой (решение автора работы после результатов; design change, «Найдено в apply», п. 4).

  • Механизм подтверждён в обеих попытках.
  • В окончательной попытке 2, на тихом хосте, R* основной ячейки вырос 931 → 1 101 (+18,3 %, три ступени). Команда называет это «эффект»: шум A/A 5,4 %, разбросы не пересекаются.
  • По букве заранее записанного критерия H4 не подтверждена: проверка дрейфа (CPU реплик на запрос при 500/с, ±5 %) у основной ячейки дала −5,4 % — на 0,4 п. п. больше порога, и только из-за двух ячеек «до».
  • Оговорка: та же проверка против A/A2 той же сессии (тот же код «до») дрейфа не показывает — 1 940 против 1 936 мкс. Там R* 984 → 1 101, +11,9 % (две ступени), «эффект».
  • Попытка 1 не прошла проверку дрейфа из-за помех на хосте (шум A/A 20 %).

Ниже — как получилось.

Как искали узкое место.

  • Серия db (scaling-db): у насыщенного PostgreSQL (0,5 CPU) рост реплик с 2 до 4 снизил R* 1 101 → 931. Счётчик db_sessions_new (прирост pg_stat_database.sessions за окно 20 с) у 4 × 1 на 931/с — 12–24, на 984/с — 79–144, соединений 60 вместо 41, CPU PostgreSQL на запрос 412–496 мкс вместо 278–292. На R* серии b — 103–283 новых сессий за окно.
  • Исходники SQLAlchemy (QueuePool._do_return_conn): соединение, возвращённое в пул, закрывается, если в очереди уже pool_size простаивающих. Соединения переполнения (сверх 10) живут, только пока заняты, и при спросе около 10 открываются снова и снова.
  • Цена нового соединения — микропроба evidence/storage/connection-cost.md: 11,7 мс CPU реплики (SCRAM-SHA-256 asyncpg — PBKDF2 на 4 096 итераций в потоке event loop) и 2,7 мс PostgreSQL против 0,6 и 0,15 мс у запроса из пула.
  • Проба основной ячейки до change (один повтор, метки в git не идут): 10 + 5 — R* 931, 10 + 0 — 1 164, 15 + 0 — 1 041; новых сессий за окно 9–52 против 3–4 (evidence/tests/scaling-improvement-checks.md).

Фон 3–4 сессии за окно — healthcheck PostgreSQL: pg_isready -h 127.0.0.1 раз в 5 с проходит аутентификацию (trust), 20 / 5 = 4.

Почему было 10 + 5. Design лабы 2 (архив 2026-10-01-postgres-storage, таблица настроек): «ограниченный пул (уровень 4)». Требование — граница соединений и таймауты; цену переполнения и нового соединения тогда не мерили, а пинг при выдаче записан как «один короткий round trip».

Что изменено. Только дефолт [database] max_overflow 5 → 0 (src/config/settings.py, коммит 9c3959d; то же в config_example.toml), pool_size 10. У реплики постоянный набор из 10 соединений: возвращённое не закрывается, сверх 10 новое не открывается, лишний запрос ждёт в очереди пула не дольше pool_timeout 5 с, затем 503 unavailable, как и раньше при занятых 15. Пинг при выдаче, рестарт PostgreSQL («БД вернулась»), «too many clients» (53300) — без изменений, контракт и HTTP-поведение не меняются. Соединений рабочего стенда — до 21 вместо 31. Свойство проверяет тест fault test_pool_keeps_connections: на 10 + 5 — 18–21 новая сессия за 720 запросов пачками по 48, на 10 + 0 — 0.

Предсказание — H4 выше, закоммичена до замеров (0b0421a); набор ячеек сокращён до замеров решением пользователя (1bb8ea6); план попытки 2 с тем же критерием — до её замеров (a676a52).

Методика.

  • Попытка — три метки профиля scaling_db4 (ячейки серии db: основная 4x1-pg0.5 и контроль 4x1-pg2, по 3 повтора, чередуются) в одной сессии хоста подряд: A/A на коде «до», затем make bench_ab — «до» (тот же код) и «после». Между «до» и «после» в src отличается только src/config/settings.py.
    • Попытка 1, 11:10–12:30 UTC: scaling-db-aa (62fa575), scaling-db-before (3df111c), scaling-db-nooverflow (53eb38e). Хост перед A/A и make bench_ab: питание от сети, свободно 47–52 % памяти, посторонних контейнеров нет, выгрузок 0.
    • Попытка 2 (окончательная, решение пользователя после разбора попытки 1; план закоммичен до замеров — a676a52), 13:32–14:47 UTC, после перезагрузки: scaling-db-aa2 (5c07923), scaling-db-before2 (45a0ad7), scaling-db-nooverflow2 (7a38c5d). Хост перед A/A и make bench_ab и раз в минуту во время прогонов: питание от сети, Zoom не запущен, средняя нагрузка за 5 мин < 8 (≤ 7,88), Spotlight < 15 % CPU (≤ 12,6 %), выгрузок 0 (проверка хоста; в паспортах — Swapouts 0 в начале и в конце, поле swapouts_delta не записано, дефект паспорта исправлен change fix-known-issues, метки не правились).
  • Эффект — вывод make bench_compare … AA=scaling-db-aa (попытка 1) / AA=scaling-db-aa2 (попытка 2): разбросы не пересекаются и Δ больше шума A/A; плюс сдвиг не меньше двух ступеней сетки (× 1,118); плюс механизм по таблице PostgreSQL и отсутствие дрейфа (CPU реплик на запрос на 500/с ±5 %, шум A/A меньше двух ступеней).

Попытка 1 (evidence/compare/scaling-db-before__scaling-db-nooverflow.md):

Конфигурация R* до R* после Δ R* Вывод CPU на запрос на 500/с, мкс
4x1-pg0.5 (основная) 745 (745–931) 984 (881–1 041) +32,1 % в пределах шума 2 178 → 2 096
4x1-pg2 (контроль) 1 455 (1 301–1 627) 1 376 (1 231–1 720) −5,4 % в пределах шума 2 062 → 2 104

Уровень шума (A/A scaling-db-aa → scaling-db-before, тот же код): 20,0 % — 4x1-pg0.5 931 (833–931) → 745 (745–931); контроль 1 539 → 1 455, −5,5 % (evidence/compare/scaling-db-aa__scaling-db-before.md).

PostgreSQL на R* и первой нарушившей ступени, «до → после»:

Конфигурация Ступень Уровень CPU PostgreSQL на запрос, мкс Новых сессий за окно Соединений
4x1-pg0.5 R* 745 → 984 293 → 289 7 → 4 40 → 40
4x1-pg0.5 первая нарушившая 788 → 1 041 646 → 420 102 → 4 60 → 40
4x1-pg2 R* 1 455 → 1 376 388 → 322 190 → 4 45 → 40
4x1-pg2 первая нарушившая 1 539 → 1 455 491 → 531 118 → 4 60 → 40

Попытка 1: H4 по заранее записанному критерию не подтверждена:

  1. Вывод сравнения для основной ячейки — «в пределах шума»: медиана выросла на 32 % (745 → 984, пять ступеней сетки, больше порога × 1,118), но разбросы пересекаются (931 у «до» > 881 у «после»).
  2. Механизм — подтверждён: «после» новых сессий 4 на обеих ступенях (≤ 10), соединений на R* 40 (≤ 40); «до» на первой нарушившей — 102 (≥ 40). Переоткрытие исчезло и у контроля (190 → 4 на R*). CPU PostgreSQL на запрос на первой нарушившей ступени — 646 → 420 мкс.
  3. Дрейф — есть: CPU реплик на запрос на 500/с в пределах ±5 % (−3,8 % и +2,0 %), но шум A/A — 20 %, больше двух ступеней. В метке «до» три ячейки из шести (r2 и r3 основной, r3 контроля) шли на более медленном хосте: CPU реплик на запрос уже на 250 и 500/с выше медианы A/A той же конфигурации на 7–38 % (на 250/с — +10…+24 %, на 500/с — +7…+38 %), — R* 745, 745 и 1 301. В A/A и «после» таких ячеек нет (кроме «после» 4x1-pg0.5-r2, +20 % к медиане A/A на 500/с). Сверка с журналом питания macOS: на окнах этих ячеек — всплески синхронизации iCloud, смена аудиоустройства, запущенный Zoom, у одной — 37 % свободной памяти. Помехи были вне ВМ Docker, стенд их не видит.

По правилу design (решение 5) при дрейфе не засчитывается ничего. Против чистой базы того же кода (scaling-db 931 ×3, медиана A/A 931) «после» 984 — +5,7 %, одна ступень: +32 % получились в основном из-за заниженного «до». Пользователь решил переснять замер на тихом хосте с тем же критерием и без третьей попытки.

Попытка 2 — окончательная (evidence/compare/scaling-db-before2__scaling-db-nooverflow2.md, evidence/compare/scaling-db-aa2__scaling-db-before2.md):

Конфигурация R* до R* после Δ R* Вывод CPU на запрос на 500/с, мкс
4x1-pg0.5 (основная) 931 (931–984) 1 101 (1 101–1 101) +18,3 % эффект 2 046 → 1 936 (−5,4 %)
4x1-pg2 (контроль) 1 627 (1 539–1 720) 1 720 (1 627–1 923) +5,7 % в пределах шума 1 912 → 1 956 (+2,3 %)

Уровень шума (A/A2 → «до», тот же код): 5,4 % — одна ступень (4x1-pg2 1 720 → 1 627, 4x1-pg0.5 984 → 931).

Конфигурация Ступень Уровень CPU PostgreSQL на запрос, мкс Новых сессий за окно Соединений
4x1-pg0.5 R* 931 → 1 101 278 → 277 5 → 3 40 → 40
4x1-pg0.5 первая нарушившая 984 → 1 164 416 → 336 102 → 4 60 → 40
4x1-pg2 R* 1 627 → 1 720 473 → 339 224 → 4 60 → 40
4x1-pg2 первая нарушившая 1 720 → 1 819 466 → 391 94 → 4 60 → 40

Журнал питания на окнах попытки 2: запусков приложений, смен питания и сна нет. Синхронизация iCloud — четыре коротких эпизода (1–15 задач), CPU на запрос в этих ячейках в норме.

Попытка 2 по критерию H4:

  1. Выполнен: «эффект», 1 101 / 931 = 1,183 ≥ 1,118 (три ступени), разбросы не пересекаются (931–984 и 1 101 во всех трёх повторах), Δ 18,3 % больше шума 5,4 %.
  2. Выполнен: «после» новых сессий 3 на R* и 4 на первой нарушившей (≤ 10), соединений на R* 40 (≤ 40); «до» на первой нарушившей — 102 (≥ 40). CPU PostgreSQL на запрос на первой нарушившей 416 → 336 мкс: излом сдвинулся, база держит ~280–340 мкс на запрос до 1 164/с.
  3. Не выполнен, на 0,4 п. п.: CPU реплик на запрос при 500/с у контроля +2,3 %, у основной ячейки — −5,4 % при пороге ±5 %. Шум A/A — одна ступень, это условие выполнено.

Вердикт по букве критерия — H4 не подтверждена: пункт 3 нарушен. Порог и критерий после результатов не менялись. Факты, которые относятся к нарушению:

  • при 500/с переполнения нет ни в одной метке: соединений 40, у реплики — 10, новых сессий 3–4 (фон);
  • медиана A/A2 на той же ступени — 1 940 мкс, «после» — 1 936 мкс;
  • отклонились две ячейки «до»: r2 и r3 — 2 046 и 2 054 мкс против 1 914 у r1.

То есть на этой ступени чуть медленнее был хост в «до», а не стало дешевле «после».

Оговорка: «после» против A/A2 той же сессии (анализ после результатов, решение автора работы засчитать улучшение; исходный критерий не меняется). Пункт 3 нужен, чтобы исключить эффект, который создал дрейф хоста. A/A2 — тот же код «до» в той же сессии, без отклонившихся ячеек. Команда: make bench_compare BEFORE=scaling-db-aa2 AFTER=scaling-db-nooverflow2 AA=scaling-db-before2 CHANGE=scaling-improvement (evidence/compare/scaling-db-aa2__scaling-db-nooverflow2.md):

Конфигурация R* A/A2 R* после Δ R* Вывод CPU на запрос на 500/с, мкс
4x1-pg0.5 984 (931–984) 1 101 (1 101–1 101) +11,9 % эффект 1 940 → 1 936 (−0,2 %)
4x1-pg2 1 720 (1 627–1 720) 1 720 (1 627–1 923) +0,0 % в пределах шума 1 964 → 1 956 (−0,4 %)

Шум («до» ↔ A/A2, тот же код) — 5,7 %. CPU на запрос — в пределах ±0,4 %: дрейфа нет. Сдвиг 1 101 / 984 = 1,119 ≥ × 1,118 (две ступени), разбросы не пересекаются (984 < 1 101). Новых сессий на R* 93 → 3, соединений 60 → 40. Эффект нельзя объяснить дрейфом хоста, поэтому H4 — подтверждена с оговоркой: вердикт по букве критерия (пункт 3 нарушен на 0,4 п. п.) и эта проверка стоят рядом. Контроль 4x1-pg2 сдвинулся на одну ступень (+5,7 %, в пределах шума), то есть меньше двух — как и предсказано. «После» R*(4 × 1) 1 101 — столько же, сколько R*(2 × 1) в scaling-db (1 101, другая сессия; справка, не критерий): рост с 2 до 4 реплик перестал снижать R* при насыщенной базе.

Изменение оставлено: ни одна конфигурация не стала хуже, переоткрытие соединений и задержки event loop ~10 мс на каждое ушли.

Что осталось узким местом. Выше излома насыщенная база (0,5 CPU) выбирает квоту при любом пуле: CPU PostgreSQL на запрос на первой нарушившей ступени 4x1-pg0.5 — 416 «до» и 336 «после» в попытке 2 (646 и 420 в попытке 1), против 277–293 на R* (evidence/compare/scaling-db-before2__scaling-db-nooverflow2.md). Изменение отодвигает момент, когда база туда сваливается, но насыщенную базу дешевле не делает. На дефолтных лимитах рост реплик останавливает хост, и переоткрытие на R* там — около 2 % CPU (design change, решение 3): контроль 4x1-pg2 сдвинулся меньше чем на две ступени.

Ограничения сравнения.

  • Две ячейки вместо всей серии db (решение пользователя сократить замеры): про 1 × 1 и 2 × 1 при 0,5 CPU выводов нет.
  • Три повтора.
  • Помехи macOS вне ВМ (iCloud, Zoom, Spotlight) стенд не видит. Они испортили попытку 1. В попытке 2 они ограничены условиями хоста, но не исключены: CPU реплик на запрос между ячейками одной метки расходится до 7,3 % у основной ячейки и до 12,2 % у контроля (scaling-db-before2, 4x1-pg2, 500/с: 1 898–2 130 мкс).
  • LB не исключал реплики ни на одной ступени: lb_chkdown 0 во всех 239 ступенях шести меток, отказов «too many clients» 0. На R* и ниже error_codes пуст во всех метках; 503 (ожидание пула дольше 5 с) — только выше R* и в обеих версиях: на коде «до» (метки A/A и «до») — 1–13 за окно, «после» — 23 и 8 у 4x1-pg2-r3 на 2 274 и 2 034/с (R* ячейки 1 923). Заранее записанная побочная проверка (design, решение 2 и Risks) выполнена (evidence/tests/scaling-improvement-checks.md, раздел 11).
  • Детектор дрейфа ±5 % оказался того же порядка, что и этот разброс.
  • Один хост, генератор на нём же.

Почему не workers. Масштабирование числом процессов внутри одного контейнера (uvicorn --workers) не используется: LB должен видеть каждый процесс отдельной репликой со своим X-Instance-Id, проверкой готовности и пулом соединений, а failover hook — останавливать процесс, а не контейнер с несколькими; поэтому 1 × 4 здесь — честный «один процесс с четырьмя ядрами», и бюджет занимают 2 × 2 и 4 × 1.

Ограничения замеров.

  • Один хост: генератор, LB, реплики и PostgreSQL делят ВМ Docker и CPU ноутбука; Docker Desktop — ВМ. Числа относятся к этому ноутбуку и профилю.
  • Разнородные ядра M3 Pro (6 производительных + 6 энергоэффективных): vCPU ВМ к ним не привязаны, «1 CPU» лимита при занятом хосте даёт меньше работы. Это одно из объяснений найденной точки насыщения, но не единственное (частота ядер, гипервизор, кэш и память — раздел «Почему рост реплик перестаёт помогать»). На хосте с однородными ядрами и свободным CPU насыщение, вероятно, наступило бы позже; это не проверялось.
  • Серия b — до 6 реплик: при 7 сумма лимитов (12,75 CPU) больше 12 vCPU ВМ. Граница пула на дефолтах (k = 7 при пуле 10 + 5 того времени; с 10 + 0 — k = 10) показана управляемым опытом (max_connections 50 при 4 репликах), а не ростом реплик.
  • Насыщение БД показано управляемым опытом: лимит PostgreSQL 0,5 CPU вместо 2 (серия db). Эффект соединений у насыщенной базы (CPU на запрос 279 → 441 мкс) измерен только при этом лимите и 2 / 4 репликах; гипотез для серии db в коммите до серий не было — она добавлена после verify, ожидание и лимит записаны в design перед её прогоном. Серия снята в другой сессии и на другом коде, чем a, b, pool: её контроль 4 × 1 при 2 CPU (1 627) с scaling-b (1 819) не сравнивается.
  • Окно 20 с и разрешение поиска ~6 %: превышение потолка на ~1 % окно не ловит; разброс R* между повторами — одна-две ступени деления (до 18 % у 4 × 1 серии a). Решения у порогов держатся на одном шаге сетки: k_sat = 5 — в пределах разрешения k_sat ∈ {4, 5} (прирост 4 → 5 — от +6 до +18 % при пороге 10 %); «+0 %» между k = 5 и 6 — |Δ| < 5,7 %; 2 × 2 = 1,65 × R*(1 × 1) — на шаг ниже порога H1 1,7.
  • Шум A/A (5,4–5,7 %, одна ступень сетки) оценён по двум конфигурациям × 3 повтора.
  • Первая ячейка серии a (4x1-r1, сразу после остановки рабочего стенда) дала R* 1 539 против 1 819 у двух других повторов. Возможен прогрев хоста в начале сессии; в других сериях первая ячейка в норме, доказательства слабые. Для будущих серий — отбрасываемая ячейка прогрева.
  • lb_qtime_ms … lb_ttime_ms — скользящее среднее HAProxy по последним 1 024 запросам на конце окна (около 0,5 с при 2 000/с), а не среднее окна: для разбора задержек не используются.
  • Признаки и пороги — до прогонов, но определения host_cost и db_active_min уточнены на самопроверках после коммита гипотез (методика выше).
  • Автоочистка и контрольные точки PostgreSQL внутри ячейки одинаковы для всех конфигураций по времени, но не исключены.

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

Сводно.

  • Выдерживается: отказ процесса API — остановка, убийство или зависание любой одной реплики при второй живой (измерено: stop и kill без ошибок недоступности, pause — 504 до исключения за ≤ 6,5 с); рестарт всего стенда с volumes; отказ Valkey (обход в PostgreSQL); плановая замена реплик под нагрузкой без ошибок; повтор отправки с тем же ключом через любую реплику.
  • Не выдерживается: отказ хоста, HAProxy и PostgreSQL — это единые точки отказа, устойчивость к ним не заявляется (трек 2 не выбран). Отказ PostgreSQL — 503 на всё, данные целы, после его возврата стенд работает без рестарта.
  • Не реализовано: уборка таблицы ключей идемпотентности (до worker лабы 5), автоматический откат замены, contract-миграции, 429/лимит частоты входа, HA для LB и БД.
  • Учебные упрощения: один Docker-host; все замеры — на нём же вместе с генератором; один прогон на фазу у профилей уровня «4»; X-Instance-Id — hostname контейнера (непрозрачный alias — лаба 7).
  • CPU / RAM уровня «4» (метки resources) — один прогон на фазу и одна замена, отсчёты раз в секунду: CPU последней доли секунды перед остановкой не виден, первый интервал после запуска контейнера завышен (счёт cgroup — с создания, начало интервала — событие start); память — memory.current cgroup с кэшем файлов, пик по отсчётам. Всплеск хоста в окне «до» фазы 06-pause-r2 не объяснён. В samples.csv метки failover/resources две строки интервала перед pause помечены окном отказа, в resources.csv метки rollout/resources шесть строк CPU на запрос 0,0 у отсутствующих контейнеров; агрегаты и сводки верны, разбор исправлен в f34cb9a, метки не переснимались. Хост между прогонами уходил в давление на память (18 ГиБ на ВМ 7,75 GiB и приложения пользователя): прогон rollout с выгрузкой в swap отброшен и переснят.
  • Подтверждено: цепочка таймаутов и время обнаружения (замер по режимам), отсутствие ошибок при плановой замене; в треке 1 — граница пула (H3), насыщение PostgreSQL управляемым опытом (серия db) и механизм H1 (один процесс не занимает больше ядра при лимите 4 CPU), хотя H1 по заранее записанным критериям целиком не подтверждена (2 × 2 = 1,65 × при пороге 1,7). H1б и H2 опровергнуты, вместо H2 подтвердилась конкурирующая H2-хост. Улучшение «пул без переполнения» — механизм подтверждён, R* +18,3 % при шуме 5,4 %, но по букве заранее записанного критерия дрейфа не прошло; засчитано решением автора с оговоркой (ниже).
  • Пока гипотеза: почему на дефолтных лимитах рост останавливает хост (энергоэффективные ядра, частота, гипервизор — замер не разделяет); выигрыш пинга только после простоя соединения; эффект пула 10 + 0 на дефолтных лимитах PostgreSQL.
  • Известные дефекты: открытых нет (KNOWN_ISSUES.md). Пять записей, найденных попутно, исправлены change fix-known-issues: SIGTERM на старте реплики терялся (теперь ранний обработчик до импорта приложения, evidence/failover/stop-at-start.md); fill-connections перезапускал PostgreSQL стенда отказов посреди набора (теперь init: true и проверка журнала в make failure_checks); исключения сверки покрытия ссылались на evidence, которого в репозитории не было (теперь доказательства сняты на стенде лабы 3, а сверка падает на ссылке на отсутствующий файл); профиль failover брал события Docker из буфера демона (теперь поток); паспорт метки не писал swapouts_delta при нуле (метки scaling-db-*2 не правились). Сводка проверок — evidence/tests/fix-known-issues-checks.md.
  • Окно запуска интерпретатора. В первые десятки миллисекунд жизни процесса, до первых строк src/__main__.py, SIGTERM реплике с PID 1 по-прежнему не доставляется: docker stop в этот миг ждёт 10 с и SIGKILL. Закрыть это окно может только init-процесс, а сервер должен оставаться PID 1. Запросов у такой реплики нет; rolling-update.sh убирает реплику без слота LB docker rm -f.

Следующие шаги: пинг соединения только после простоя (design scaling-improvement, решение 6); причинная проба хоста («грелка» на 6 vCPU); фоновая уборка ключей в worker лабы 5; повтор замеров уровня «4» с несколькими прогонами на фазу (и ресурсов — с распределением, а не одним значением); в лабе 4 — снять заново доказательства исключений сверки покрытия на её стенде (AGENTS.md, «Переход в следующую лабу»).

Идемпотентность:

  • Таблица ключей растёт. Строка на каждое сообщение, фоновой уборки нет до worker лабы 5. Просроченный ключ заменяется только при следующей отправке с ним же. Ручная очистка — по индексу created_at:

    docker compose exec postgres sh -c 'psql -U "$POSTGRES_USER" -d "$POSTGRES_DB" \
      -c "DELETE FROM idempotency_keys WHERE created_at < now() - interval '"'"'24 hours'"'"'"'
    

    Удаляются только ключи, сообщения остаются.

  • Замороженная реплика держит ключ до 10 с. Если процесс заморожен (docker pause) между захватом ключа и commit, повторы того же ключа на других репликах ждут его блокировку до statement_timeout (5 с) и получают 503. Через 10 с простоя PostgreSQL прерывает такую транзакцию (idle_in_transaction_session_timeout с change graceful-failover), и следующий повтор проходит: 201 через ~12 с после начала транзакции (evidence/failover/hung-key.md). Раньше ключ оставался занят до разморозки.

  • Каждая запись дороже на одну вставку и проверку отложенного внешнего ключа. Это цена контракта. Отдельно она не измерялась: запись ключа входит в стоимость записи всех меток лабы 3 (.claude/rules/bench.md). Кандидат «ключ и сообщение одним SQL-выражением» остался непроверенным.

  • После 24 ч повтор того же тела с тем же ключом создаст новое сообщение: контракт гарантирует повтор только в пределах срока.

  • В консоли X-Instance-Id — имя машины разработчика; для локальной разработки это допустимо, APP__INSTANCE_ID его заменяет.

Балансировщик и реплики:

  • Что стенд выдерживает и что нет. Один Docker-host, один HAProxy, одна PostgreSQL, один Valkey. Выдерживается отказ процесса API — любой одной реплики при второй живой. Не выдерживается отказ хоста, LB и PostgreSQL: это единые точки отказа, устойчивость к ним не заявляется. Отказ Valkey — деградация до Postgres, не отказ.
  • 8 слотов server-template. Девятую реплику LB не увидит; 8 — максимум серий трека 1. Число меняется в haproxy.cfg.
  • Граница пула Postgres. С пулом 10 + 0 (change scaling-improvement) соединений больше max_connections при 10 репликах (10 × 10 + 1 = 101 > 100); с прежним 10 + 5 граница была при 7 (106 > 100). Серия pool трека 1 при 50 снята на 10 + 5: под нагрузкой — отказы «too many clients», клиент тогда получал 500 вместо 503 (исправлено в fixes change scaling-bench). С 10 + 0 тот же опыт дал бы 41 < 50 соединений; серия не переснималась.
  • Зависшую реплику LB исключает за 6,5 с, а не мгновенно. timeout check 2,5 с, а не 1 с, как в плане: проверка не должна обрываться раньше таймаута готовности внутри API (2 с). Уменьшать и его нельзя: /health/ready берёт соединение из общего пула, и заминка PostgreSQL на 1–2 с вывела бы из LB все реплики разом. Худшее обнаружение зависшей реплики — inter + timeout check + fastinter + timeout check = 6,5 с (замер под нагрузкой — 5,8–6,0 с), всё это время половина запросов получает 504 через 10 с. Остановленную и убитую реплику LB исключает за 0,8–1,8 с (DNS, граница проверок 2,5 с). Пассивная проверка по ошибкам живого трафика зависшую реплику не ускорила бы: соединение с ней устанавливается, а ответ 504 приходит только через timeout server (design graceful-failover, решение 2).
  • Оборванный ответ при kill. Запросы в полёте на убитой реплике получают 502 от LB, LB их не повторяет (они уже дошли). Отправку сообщения клиент повторяет с тем же ключом; другие POST — на усмотрение клиента, прозрачных повторов контракт не допускает. Воспроизводится командой driver.py --port 8080 kill-inflight.
  • Отказ PostgreSQL выводит из LB все реплики сразу. /health/ready проверяет PostgreSQL, поэтому через 1–2 с после его отказа на всё, включая /health/live, отвечает сам HAProxy: 503 unavailable в формате контракта — тот же код, что отдал бы API. Liveness процесса без LB проверяет make failure_checks.
  • Выбор реплики в make test-failover. Тест останавливает реплику, ответившую на его первую отправку; число запросов до неё постоянно, и при round-robin по двум репликам после make replicas тест снова выбирает ту же. Для второй реплики очередь сдвигается одним запросом до теста (evidence/failover/test-failover.md).
  • Argon2id под лимитом 1 CPU. Один процесс API — один event loop, он больше 1 CPU не использует, а Argon2id (p=4) считает хэш в четырёх потоках. Под лимитом реплики проверка пароля подряд идёт около 0,14 с вместо 0,025 с, четыре одновременных — 0,8–1,6 с; одиночный вход через LB — около 50 мс. Пока на реплике идёт вход, её остальные запросы делят с ним квоту: при 8 потоках входа GET /users/me — медиана 46 мс вместо 2 мс, p95 101 мс (evidence/replicas/stand.md). make test_isolated (около 190 регистраций и 190 входов на одной реплике) идёт около минуты вместо 21 с. Лимит оставлен осознанно: вход редок, в замеры трека 1 не входит, серия B считает реплику в 1 CPU.
  • Одиночный 502 при docker stop под нагрузкой. Простаивающее соединение LB → реплика теперь закрывает LB (http-reuse never, timeout http-keep-alive 10 с < keep-alive реплики 60 с, evidence/failover/keep-alive.md). Но при SIGTERM uvicorn сразу закрывает простаивающие соединения, и запрос, который LB в тот же миг отправил в такое соединение, получает 502 без повтора. Под нагрузкой 200 запросов в секунду на закоммиченном коде — одиночный 502 в 1 из 4 фаз stop (регрессия и замер baseline), доля успешных в секунде не ниже 99 %. С пулом (safe) гонка та же: в разведке на рабочем дереве — 1 из 9 фаз против 2 из 10 с never, разница в пределах случайности (это история поиска, не доказательство, evidence/failover/keep-alive.md). Клиенты с новым соединением на запрос (make test-failover) его не встречают; отправку сообщения клиент повторяет с тем же ключом. README допускает краткие ошибки во время обнаружения отказа, если они измерены. Плановая остановка (make rolling_update, change rolling-update) сначала выводит реплику из LB через его runtime API и только потом шлёт SIGTERM. Под той же нагрузкой это 0 ошибок (профиль rollout). Одиночный 502 остаётся только у остановки без дренажа, то есть у имитации отказа (stop-one.sh, профиль failover).

Цена масштабирования (трек 1):

  • Один ноутбук и ВМ Docker. Генератор k6, LB, реплики и PostgreSQL делят 12 vCPU ВМ и CPU M3 Pro; числа — для этого хоста и профиля 70/20/10. Генератор ограничен 2 CPU и следит за собой (брак — нижняя граница R*), но работает на том же хосте.
  • Разнородные ядра и общий CPU хоста. 6 производительных и 6 энергоэффективных ядер, vCPU к ним не привязаны: при занятых больше ~6 vCPU «1 CPU» лимита делает меньше работы. Рост остановил хост (host_cost), но механизм не разделён: энергоэффективные ядра, частота ядер под многоядерной нагрузкой, гипервизор и сетевой стек ВМ, кэш и память дают один и тот же признак. На хосте с однородными ядрами и свободным CPU насыщение, вероятно, наступило бы позже, а какой общий ресурс стал бы первым (PostgreSQL занят на 1,1 ядра из 2 на k = 6), не проверялось. Причинная проба — 1 × 1 на 666/с с контейнером-«грелкой» на 6 vCPU и без него (verify W4) — не снималась.
  • Серия b — до 6 реплик (бюджет ВМ, 11,75 CPU лимитов); граница пула на дефолтах того времени (10 + 5, k = 7) показана управляемым опытом max_connections 50, а не ростом реплик. С пулом 10 + 0 граница — k = 10.
  • Окно 20 с, разрешение поиска ~6 %, 3 повтора: разброс R* — одна-две ступени деления; уровень шума между сессиями — A/A scaling-aa (5,4–5,7 %, одна ступень). Для улучшения A/A снимается заново: код приложения после scaling-aa изменён правкой 53300.
  • Улучшение по найденному узкому месту засчитано с оговоркой: по букве критерия не подтверждено, засчитано решением автора после результатов (change scaling-improvement, раздел «Улучшение по найденному узкому месту: пул без переполнения»).
    • Механизм подтверждён: переоткрытие соединений пропало, соединений 60 → 40.
    • В окончательной попытке 2 R* основной ячейки вырос на 18,3 % (вывод команды «эффект», шум A/A 5,4 %). Но заранее записанная проверка дрейфа (±5 % CPU на запрос при 500/с) дала −5,4 %.
    • Попытку 1 испортили помехи macOS: шум A/A 20 %.
    • Детектор ±5 % оказался того же порядка, что разброс CPU на запрос между ячейками одной метки на этом хосте (до 7,3 % у основной ячейки и до 12,2 % у контроля, scaling-db-before2, 4x1-pg2, 500/с).
    • Сказать, сдвигает ли изменение R* на дефолтных лимитах, нельзя: там рост останавливает хост, а переоткрытие на R* — около 2 % CPU (design change, решение 3).
  • Пинг при выдаче соединения (pool_pre_ping) — найденный, измеренный, но не применённый кандидат. В design лабы 2 он записан как «один короткий round trip»; на деле это 3 обмена (BEGIN, ;, ROLLBACK) и лишняя транзакция на каждый запрос: +0,13 мс CPU реплики и +0,05 мс CPU PostgreSQL (evidence/storage/connection-cost.md), в пробе основной ячейки без пинга R* 931 → 1 164. Не применён: без него первый запрос после рестарта PostgreSQL получает ошибку на мёртвом соединении (спек data-storage, «БД вернулась»). Запасной вариант — пинг только после простоя соединения (design change, решение 6).

Поочерёдная замена и миграции:

  • Автоматического отката нет. Сбой на середине оставляет API_REPLICAS готовых реплик, возможно, разных версий. Миграция только расширяет схему, так что обе версии работают; повторный запуск доводит замену. Откат — make rolling_update COMMIT=<прежний> MIGRATE=0: его миграции не знают новой ревизии, поэтому шаг пропускается явно, а схема остаётся новой. После отката тег mtusi-messenger:lab3 указывает на прежний образ: docker compose up без сборки пересоздал бы на нём migrate, и тот упал бы на новой ревизии. Вперёд — снова make rolling_update или make run_docker (evidence/rollout/compatibility.md, шаг E).
  • Contract-миграции нет в этой поставке. Удалить или переименовать колонку можно только отдельной миграцией, когда кода, который её пишет, не осталось. downgrade новой ревизии удаляет колонку и допустим только тогда же.
  • lock_timeout 2 с. Под тяжёлой записью или во время pg_dump (он держит ACCESS SHARE на все таблицы до конца) миграция может не дождаться блокировки и упасть. Тогда замена не начинается, повтор проходит. Это осознанный выбор: иначе очередь всех записей ждала бы за миграцией. Пока миграция ждёт, запросы к messages стоят в очереди до 2 с.
  • Сборка образа идёт на том же хосте, под нагрузкой. Из кэша слоёв — секунды CPU ВМ Docker.
  • Неготовая новая реплика при сбое замены (change fix-known-issues, решение 7). Слот LB уже есть — maint, затем штатная остановка (стартующая реплика выходит сразу по раннему обработчику SIGTERM, работающая дорабатывает запросы, отправленные на слот до maint) и docker rm -f; слота нет — сразу docker rm -f: запросов на ней не было, и это страховка на окно запуска интерпретатора, где SIGTERM ещё некому принять. Проверено ROLLOUT_READY_TIMEOUT=1 и 2: оба раза путь со слотом, код выхода 0 (evidence/failover/stop-at-start.md).
  • Замена только на одном хосте и только для api. LB, PostgreSQL и Valkey обновляются с простоем.
  • Профиль отказа — один прогон на фазу, один хост. Замер показывает поведение и порядок величин, а не распределение. Генератор, LB, реплики и PostgreSQL делят ВМ Docker (evidence/failover/baseline/).

Ответы на вопросы защиты

Чем отказ процесса отличается от отказа узла? Отказ процесса — остановлена, убита или зависла одна реплика API, а хост, сеть, LB и хранилища живы. Его стенд переживает, и это измерено под нагрузкой 200 запросов в секунду (evidence/failover/detection.md):

  • docker stop (SIGTERM) — процесс дорабатывает запросы в полёте и закрывает сокет; LB получает отказ соединения и перенаправляет запрос, через 1,0–1,1 с убирает реплику из распределения. Ошибок 0, только задержка до 0,5 с у запросов, попавших на пропавший адрес;
  • docker kill (SIGKILL) — то же, но запросы в полёте рвутся: 502 от LB без повтора, клиент повторяет отправку с тем же ключом. Исключение — 0,8–1,8 с;
  • зависание (docker pause) — процесс жив для сети, но не отвечает. Его видно только по проверкам: 5,8–6,0 с (граница 6,5 с), и всё это время половина запросов получает 504. Его открытую транзакцию PostgreSQL прерывает через 10 с простоя, ключ освобождается.

Вторая реплика обслуживает те же сессии и данные из PostgreSQL, подтверждённые сообщения не теряются, повтор с тем же ключом не даёт дублей. Отказ узла — пропал весь хост: вместе с ним LB, PostgreSQL, Valkey и все реплики, и переключаться некуда. Причём для остальных узлов отказ узла выглядит как зависание или пропавший адрес, а не как аккуратный отказ соединения: соединения висят до таймаутов. На одном хосте его не пережить, это трек 2, который мы не выбрали. Здесь хост, LB и PostgreSQL честно названы единой точкой отказа.

Почему depends_on и healthcheck сами по себе не являются балансировщиком? depends_on лишь упорядочивает старт контейнеров (postgres → migrate → api), а healthcheck только меняет статус контейнера на unhealthy: Docker Compose не перестаёт слать ему запросы и не распределяет их. Распределять некому: без LB клиент ходит на один опубликованный порт одного контейнера. Нужен отдельный процесс, который принимает соединения, выбирает готовую реплику, исключает неготовую по своей проверке и повторяет недошедший запрос — здесь это HAProxy с проверкой /health/ready раз в секунду. Healthcheck контейнера остаётся для make replicas --wait и docker compose ps. При поочерёдной замене видно, что одного healthy мало: реплика попадает в распределение LB только после его собственных проверок, через ≤ 1,5 с. Поэтому make rolling_update ждёт состояния UP в статистике HAProxy, а старую реплику выводит из LB явно, до остановки.

Дополнительно (уровень «4»): как обновить API без простоя и почему миграция не ломает работающие реплики? make rolling_update меняет реплики по одной:

  1. одна новая рядом со старыми;
  2. ожидание её UP в LB;
  3. старая выводится из LB (drain), дорабатывает запросы, останавливается и удаляется.

Реплик всё время не меньше API_REPLICAS, клиент ошибок не видит: профиль rollout под 200 запросами в секунду и публичный tests/load.py — 0 неуспешных. Миграция выполняется один раз, до первой новой реплики, и только расширяет схему (expand/contract). Старые реплики работают на новой схеме: это проверено make test и make student_test на образе прежнего commit после новой миграции. Откат кода не требует отката схемы. Удаление и переименование — отдельной поставкой, когда прежнего кода не осталось (evidence/rollout/compatibility.md).

Какие POST можно повторять после timeout и что защищает Idempotency-Key? После таймаута клиент не знает, выполнен ли запрос. Безопасно повторять только POST /api/v1/chats/{chat_id}/messages с тем же ключом и телом: ключ и сообщение пишутся одной транзакцией, повтор через любую реплику вернёт тот же 201 и то же Message, другое тело — 409, одновременные повторы дают одно сообщение. Регистрация, создание чата и вход ключа не имеют: повтор создаст второго пользователя (или 409), второй чат, вторую сессию. Поэтому и LB повторяет запрос сам только при отказе соединения, когда запрос до реплики точно не дошёл (retry-on conn-failure), а не по таймауту или обрыву ответа (evidence/failover/test-failover-kill.md).

Что сломается при увеличении числа API, если сессии находятся в локальной памяти? Токен, выданный одной репликой, другая не знает: round-robin отправит следующий запрос на другую реплику — 401, хотя пользователь вошёл. Logout отзовёт сессию только на одной реплике, и токен продолжит работать на остальных. Рестарт или отказ реплики стирает её сессии, make test-persistence и make test-failover упали бы. Sticky session это лишь маскирует и запрещена заданием. Поэтому сессии в Postgres (общие для реплик, переживают рестарт), как и ключи идемпотентности; в памяти процесса нет ничего, от чего зависит корректность (раздел «Балансировщик и реплики»).

Дополнительно (уровень «5», трек 1): почему одна реплика с 4 CPU не быстрее реплики с 1 CPU? Процесс uvicorn — один поток event loop, и GIL не даёт выполнять Python-код параллельно даже в потоках executor. Серия a: реплика с лимитом 4 CPU за всю серию не взяла больше 1,00 ядра в секунду, и её R* — 630/с против 666/с у 1 × 1. Бюджет 4 CPU занимают только процессы: 2 × 2 — 1 101/с, 4 × 1 — 1 819/с. Поэтому масштабирование — числом реплик за LB, а не лимитом CPU одной.

Почему рост реплик перестаёт помогать и где точка насыщения? Серия b: R* растёт до k = 5 (2 034/с) и дальше не растёт (k_sat = 5 по правилу, в пределах разрешения сетки — 4 или 5). Каждая реплика на R* занята почти на ядро, а PostgreSQL — только на 1,1 ядра из 2: ожидания WAL — около 22 % активных соединений (порог признака 30 %), блокировок нет. LB — 0,25 ядра из 1, очереди нет. Пул не отказывает, но на R* заполнен до 15 соединений на реплику, а за R* запросы ждут его до 5 с и получают 503. Растёт цена запроса в CPU у всех компонентов сразу — реплик, PostgreSQL, HAProxy, генератора — примерно вдвое от k = 1 к k = 6, вместе с числом занятых ядер хоста. Добавленная реплика делит тот же хост, и её вклад съедается удорожанием каждого запроса. На этом стенде с дефолтными лимитами предел задаёт хост, а не БД, LB или пул. Почему секунда CPU даёт меньше работы — энергоэффективные ядра M3 Pro, частота ядер, гипервизор или кэш и память, — замер не разделяет. Границы БД и пула показаны управляемыми опытами. Серия db: при PostgreSQL 0,5 CPU база насыщается около 950–1 000/с (троттлинг до 100 %, db_cpu), и 4 реплики дают R* на 15 % меньше, чем 2 (931 против 1 101): запрос в насыщенной базе дорожает с 279 до 441 мкс CPU. Главная причина спада — переполнение пула 10 + 5: у 4 реплик соединения сверх 10 на реплику закрываются и открываются снова (79–144 новых сессий за окно на 984/с), а новое соединение стоит ~2,7 мс CPU PostgreSQL. С пулом 10 + 0 (change scaling-improvement) R*(4 × 1) — 1 101, столько же, сколько R*(2 × 1) в scaling-db (другая сессия, справка), новых сессий на первой нарушившей ступени 102 → 4. Предел, который остаётся, — квота CPU PostgreSQL 0,5: выше излома база выбирает её при любом пуле (раздел «Улучшение по найденному узкому месту: пул без переполнения»). Серия pool: при max_connections 50 — отказы и падение R* на 15 % (после правки 53300 отказ — 503). LB не насыщался нигде: ≤ 0,30 ядра из 1.

Почему открытая модель нагрузки, а не фиксированное число клиентов? В закрытой модели клиент ждёт ответа перед следующим запросом: когда стенд замедляется, клиенты сами снижают интенсивность, и очередь не видна (coordinated omission). В открытой модели k6 отправляет запросы с заданной интенсивностью, а неотправленные из-за занятых VU считаются ошибками. Поэтому R* — максимальная интенсивность, которую стенд держит с p95 ≤ 200 мс и ошибками ≤ 1 %, а не число, подогнанное под скорость ответов.

Источники, библиотеки и использование ИИ

Документация (официальные страницы; где точный адрес раздела не указан — корень документации, раздел назван словами):

  • HAProxy 3.4 — https://docs.haproxy.org/: Configuration Manual (server-template, resolvers, init-state, option httpchk, inter / fastinter / downinter, fall / rise, timeout check, retry-on, option redispatch, http-reuse, http-error, monitor-uri), Management Guide (stats socket, set server … state, show servers state, CSV статистики).
  • PostgreSQL 18 — https://www.postgresql.org/docs/18/: клиентские параметры (statement_timeout, lock_timeout, idle_in_transaction_session_timeout), статистика (pg_stat_activity, pg_stat_database, pg_stat_wal, pg_stat_io), коды ошибок (53300), max_connections, INSERT … ON CONFLICT, отложенные ограничения (DEFERRABLE INITIALLY DEFERRED), явные блокировки ALTER TABLE.
  • SQLAlchemy 2.1 — https://docs.sqlalchemy.org/: Connection Pooling (QueuePool, pool_size, max_overflow, pool_pre_ping), asyncio extension; исходники QueuePool — почему соединения сверх pool_size закрываются при возврате.
  • asyncpg — https://magicstack.github.io/asyncpg/: параметры подключения; исходники аутентификации SCRAM-SHA-256 (цена нового соединения).
  • k6 — https://grafana.com/docs/k6/latest/: сценарии и executors constant-arrival-rate и ramping-arrival-rate (открытая модель), preAllocatedVUs, dropped_iterations, итоговый JSON.
  • FastAPI — https://fastapi.tiangolo.com/: параметры Header, зависимости, порядок валидации, обработчики исключений.
  • uvicorn — https://uvicorn.dev/settings/: timeout_keep_alive, timeout_graceful_shutdown, поведение по SIGTERM.
  • Docker Compose — https://docs.docker.com/reference/compose-file/: services (depends_on с условиями, stop_grace_period, healthcheck, start_interval), deploy (replicas, resources.limits); CLI docker compose up --scale --no-recreate --wait, docker events, docker stop / kill / pause — https://docs.docker.com/reference/cli/docker/.
  • Linux — cgroup v2 (cpu.stat, троттлинг CFS, memory.current) и PSI для сэмплера трека 1.
  • Из лабы 2 — alembic, argon2-cffi, redis-py, Valkey (источники перечислены в отчёте лабы 2).

Библиотеки и образы: FastAPI, pydantic, pydantic-settings, structlog, SQLAlchemy, asyncpg, alembic, argon2-cffi, redis-py, uvicorn (версии — раздел «Запуск из чистого clone»); тесты — pytest, httpx; стенд — HAProxy, PostgreSQL, Valkey, k6 в закреплённых образах. Чужой код не копировался. Логгер и форма Makefile перенесены из собственного учебного проекта автора (bp_proxies, .claude/rules/logging.md).

Использование ИИ. Инструмент — Claude Code, модель Claude Opus 5.5. Работа велась по changes OpenSpec (openspec/changes/archive/: семь changes лабы 3, седьмой — profile-resources, CPU и память профилей уровня «4», добавлен после закрытия лабы; все в архиве, спеки синхронизированы; восьмой — fix-known-issues, исправление записей KNOWN_ISSUES.md перед переносом в лабу 4). Каждый change проходил этапы propose → apply → verify → правки по verify и archive. Каждый этап выполнял отдельный субагент, основная сессия координировала: передавала этапы, проверяла итоги, присылала автору прогресс. Все commit после skeleton помечены Co-Authored-By: Claude Opus 5.5, кроме четырёх, которые сделал скрипт make bench_ab по ходу замера (dfd9ecc, 53eb38e, de6001c, 7a38c5d). Рабочий план лабы (PLAN.md: рубрика → changes, ключевые решения, трек 5, риски) удалён после закрытия всех changes; его решения перенесены в этот отчёт и в design архивных changes, последняя версия — git show 063eedb:PLAN.md (на неё ссылаются архивные changes).

Что делал ИИ:

  • код приложения, миграции, docker-compose.yml, haproxy.cfg, скрипты restart.sh, stop-one.sh, rolling-update.sh;
  • собственные тесты student-tests/ и стенды проверок отказов;
  • стенд замеров bench/ (профили failover, rollout, серии трека 1, сэмплер, графики, сравнение меток);
  • запуск замеров и проверок, evidence, этот отчёт, правила .claude/rules/ и спеки OpenSpec.

Что решал автор:

  • выбор трека 1 «Цена масштабирования» и Compose + HAProxy без Swarm (2026-10-07; сравнение вариантов — раздел «Балансировщик и реплики»);
  • согласования с преподавателем (FastAPI, config.toml);
  • по verify scaling-bench: исправить ответ на «too many clients» (500 → 503, правка 68edc66) и добавить серию db с насыщением PostgreSQL (scaling-db), потому что на дефолтных лимитах база не насыщалась;
  • сократить замеры улучшения до двух ячеек (4x1-pg0.5, 4x1-pg2, профиль db4) до начала замеров;
  • переснять улучшение на тихом хосте после помех macOS (iCloud, Zoom) в попытке 1;
  • засчитать улучшение с оговоркой по пункту дрейфа после результатов попытки 2 (design scaling-improvement, п. 4);
  • коммиты и замеры в автономном режиме — с условием: перед каждым замером проверка хоста, при плохом состоянии — остановка и вопрос;
  • исправить все пять записей KNOWN_ISSUES.md отдельным change fix-known-issues до переноса кода в лабу 4 (2026-10-13), а его быстрые профили-самопроверки разрешить от батареи и рядом с посторонним контейнером (это не замеры для отчёта).

Как проверялось:

  • verify каждого change отдельным субагентом: сверка с задачами, спеками и рубрикой; найденное правилось и evidence переснималось с закоммиченного кода (например, lock_timeout, равный statement_timeout, давал 503 запросам в очереди за миграцией; уборка при Ctrl+C внутри up --scale оставляла третью реплику; см. разделы выше);
  • публичные проверки skeleton (make test, make test-persistence, make test-failover) и собственные тесты (make student_test, make failure_checks, make test_isolated) на итоговом коде каждого change и из чистого clone;
  • гипотезы трека 1 и критерии улучшения закоммичены до замеров, шум отделён A/A той же сессии; хост проверялся перед каждой серией;
  • ошибки ИИ, найденные по ходу, описаны в отчёте как есть: ошибочный пункт KNOWN_ISSUES.md о make run_docker (диагноз по digest конфигурации образа containerd), 500 вместо 503 на 53300, первая попытка замера улучшения на зашумлённом хосте; исключения сверки покрытия ссылались на файлы доказательств, не перенесённые из репозитория прошлой лабы (теперь сверка это ловит).

Утверждения отчёта о поведении стенда подтверждены командами, выводы которых лежат в evidence/; решения, перечисленные выше, принимал автор.