Files
mtusi2026lab3/REPORT.md
T
ricoromaandClaude Opus 5.5 ce89eba22d docs: record the clean clone check of ebf080a
Repeat the REPORT.md "Запуск из чистого clone" sequence from a real git
clone of the final strict-id-validation code on the default ports: env
setup, stand, no-cache build, check, validate, smoke, instances on two
Python versions, persistence, failover of each replica and kill, own
tests, fault checks and the isolated run. All steps exit 0. The clone ran
as compose project mtusi-lab3-cleancheck while the working stand was
only stopped, because removing its volume was refused by the agent's
auto mode; the previous checks ran as mtusi-lab3.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-16 13:32:33 +03:00

272 KiB
Raw Blame History

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

  • Автор, группа: Сафронов Роман Николаевич, БВТ2301

  • Целевая оценка 5; выбранный трек 5: трек 1 «Цена масштабирования» (серии сняты, change scaling-bench; одно подтверждённое улучшение — пул без переполнения, change scaling-improvement, засчитано с оговоркой: раздел «Улучшение по найденному узкому месту: пул без переполнения»)

  • Commit/PR: ветка solution/bvt2301-safronov, PR «ЛР 3 — БВТ2301 — Сафронов — на 5» — #6. Из чистого clone проверен commit ebf080a (2026-10-16, итоговый код change strict-id-validation, evidence/tests/clean-clone-final.md). Прошлая такая проверка — 8fa12f5 (2026-10-13, код fix-known-issues). После неё Dockerfile, pyproject.toml, uv.lock, compose, конфигурации, миграции и scripts/ не менялись; код приложения — только в change strict-id-validation (ниже). Изменились инструменты проверок, по verify fix-known-issues (824676b, 1758790, 8be58ce):

    • драйвер скилла: cache-check --require-test-keys, вход одним пользователем в auth-storage, уборка stop-at-start;
    • текст исключения «Временная база» в spec_coverage.py;
    • сообщение о непрочитанном журнале PostgreSQL в run_failures.py;
    • остановка потока docker events в bench/run.py.

    Изменились и документы, evidence и архив change. Проверки на коде fix-known-issues — make test, make student_test (133 passed), make test_isolated (129 + 4), make failure_checks (17, crash markers 0), быстрые профили failover и rollout, stop-at-start под системным python3 3.9.6: evidence/tests/fix-known-issues-checks.md, раздел «Правки по verify».

    После рецензии PR — change strict-id-validation (тесты c5d5a1a, исправление 628b5f2, проверка полей курсора вместо обратной сборки 8fe467a): курсор с подменённым ключом элемента давал 500, а вход с UUID был шире format: uuid контракта. Это единственное изменение кода приложения после 8fa12f5. Проверки на 8fe467a:

    • make test_isolated (138 + 4);
    • make student_test через LB (142 passed, 0 ответов 5xx);
    • make failure_checks (17, crash markers 0);
    • make rolling_update с 628b5f2;
    • git clone во временном проекте на нестандартных портах (142 passed).

    Затем полная проверка из чистого clone на портах по умолчанию на ebf080a — все шаги код 0 (evidence/tests/clean-clone-final.md; проверки change — evidence/tests/strict-id-validation-checks.md).

  • Использованные источники, библиотеки и помощь ИИ: раздел «Источники, библиотеки и использование ИИ» в конце отчёта.

Сделано по 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 — без открытых записей);
  • по рецензии PR — strict-id-validation: изменённый клиентом курсор (ключ элемента не строка или не в записи сервера, версия не ровно целое 1) — 400 вместо 500 и вместо страницы, незнакомые поля курсора игнорируются; UUID на входе (chat_id в пути, элементы member_ids) — только запись 8-4-4-4-12, как format: uuid.

Запуск из чистого 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 — 142 passed; make failure_checks — 17 passed и строка сводки журнала PostgreSQL стенда отказов [failure_checks] postgres log: … crash markers 0 (признаков аварийного перезапуска нет); make test_isolated — 138 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 во всех трёх; в изоляции на a4ca9ef 127 passed, 4 теста реплик пропущены с причиной «one API process» (на итоговом коде fix-known-issues — 129 passed + 4 пропуска: два новых теста сверки ссылок, evidence/tests/clean-clone-final.md; на 8fe467a после strict-id-validation — 138 passed + 4 пропуска, через LB — 142 passed); сверка покрытия: на fix-known-issues — 137 сценариев, 125 тестом, 12 исключений; на 8fe467a — 145 сценариев, 133 тестом (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, evidence/tests/strict-id-validation-checks.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 ebf080a (2026-10-16, итоговый код strict-id-validation; прошлые проверки — 8fa12f5 и dbb9150, в истории файла) на портах по умолчанию: make env_setup, make run_docker, make check, make validate, make test, make instances (python3 3.12 и системный 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. Проект compose — временный mtusi-lab3-cleancheck: удалить рабочий стенд с volume запретил режим auto агента, рабочий стенд на время проверки остановлен; прошлые проверки шли под mtusi-lab3. Имя проекта задаёт только имена контейнеров и volume все команды — код 0 без правки файлов клона: PASS у публичных проверок, instances: 2, остановлены по очереди 745885fa362c и 8ad8d07ffe26 (ID = TARGET_INSTANCE_ID), первая запись через 1,09–1,61 с (stop, неудачных попыток 0) и 0,23 с (kill, одна попытка в полёте повторена с тем же ключом); после restart.sh те же ID с новым StartedAt у LB, реплик, Postgres и Valkey; 142 passed через LB, 17 проверок отказов и журнал PostgreSQL стенда без признаков аварии, 138 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 проверок отказов. После правок по verify (f02694e) те же числа и быстрые профили повторены. stop-at-start под системным python3 3.9.6 — import за 0,06 с, код 0. cache-check --require-test-keys без ключей тестовой базы — код 1 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
Неверные данные в курсоре и UUID на входе — 400 (рецензия PR: повреждённый курсор давал 500) тесты black-box (test_pagination.py::test_tampered_cursor на оба списка, test_api_conventions.py — chat_id на трёх ручках и member_ids, test_chats.py) сначала без исправления (c5d5a1a), затем с ним (628b5f2, итоговый курсор — 8fe467a): make test_isolated; make rolling_update с прежнего кода, make test и make student_test через LB, make failure_checks, git clone во временном проекте на нестандартных портах без исправления — 3 красных: в выданном курсоре "i" = [], {}, 123, false → 500 (AttributeError в UUID()), тот же id без дефисов или в верхнем регистре, "v": true → 200; chat_id и member_ids без дефисов, с urn:uuid:, в {…} → 200 / 201. С исправлением — все 400: поля курсора проверяются по отдельности (v — ровно целое 1, t и i — строки, i — в записи сервера), незнакомые поля игнорируются — 200 и та же страница; UUID на входе — тип UuidIn (8-4-4-4-12, регистр любой). Первая реализация курсора (628b5f2, обратная сборка) заменена: она закрывала формат, и курсор реплики другой версии получал бы 400 при поочерёдной замене (design change, «Пересмотр в apply»). Расхождение с прежним поведением: нестрогие записи UUID раньше принимались, теперь — 400; smoke, наши тесты и k6 шлют только id из ответов. Зелёные на 8fe467a: 138 + 4 в изоляции, 142 через LB (0 ответов 5xx за прогон), 17 проверок отказов, 142 в клоне evidence/tests/strict-id-validation-checks.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). Все восемь в архиве, спеки синхронизированы, активных changes нет. Каждый 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/; решения, перечисленные выше, принимал автор.