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>
272 KiB
Отчёт — лабораторная 3
-
Автор, группа: Сафронов Роман Николаевич, БВТ2301
-
Целевая оценка 5; выбранный трек 5: трек 1 «Цена масштабирования» (серии сняты, change
scaling-bench; одно подтверждённое улучшение — пул без переполнения, changescaling-improvement, засчитано с оговоркой: раздел «Улучшение по найденному узкому месту: пул без переполнения») -
Commit/PR: ветка
solution/bvt2301-safronov, PR «ЛР 3 — БВТ2301 — Сафронов — на 5» — #6. Из чистого clone проверен commitebf080a(2026-10-16, итоговый код changestrict-id-validation,evidence/tests/clean-clone-final.md). Прошлая такая проверка —8fa12f5(2026-10-13, кодfix-known-issues). После неёDockerfile,pyproject.toml,uv.lock, compose, конфигурации, миграции иscripts/не менялись; код приложения — только в changestrict-id-validation(ниже). Изменились инструменты проверок, по verifyfix-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под системнымpython33.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(шаги последовательности ниже); python33.9+ для публичныхmake check,make test,make test-persistence,make test-failover,make instances,make test_isolated,make failure_checks. Драйверmake instances— только stdlib, проверен и на системномpython33.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— удалить контейнеры, volumepostgres_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) и п. 6Dockerfile.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) — в формате ошибки контракта с
codeunavailable,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):
- Предусловия — ничего не меняют, иначе код 2 и подсказка
make replicas:- работает ровно
API_REPLICASреплик, остановленных нет; - все
UPв LB; - для ещё одной реплики есть слот (≤ 8);
- канал управления LB отвечает;
- нет слотов в ручном
drain/maint, оставленных прерванной заменой (их не видно вmake lb_stats, скрипт читаетshow servers state); иначе он печатает команду, которая вернёт слот вready.
- работает ровно
- Сборка образа из рабочего дерева.
COMMIT=<commit>— из файлов commit черезgit archive <commit> | docker build, рабочее дерево не трогается. - Миграции — один раз, в контейнере сервиса
migrate, на новом образе, до первой новой реплики. Ошибка (в том числеlock_timeout) — код 1, реплики не тронуты. - Одна новая реплика рядом со старыми:
up -d --no-deps --no-recreate --scale api=N+1 api. - Ожидание готовности новой:
healthyиUPв статистике LB по её адресу. Слот получает адрес из DNS и начинает вDOWN, в распределение попадает через ≤ 1,5 с проверок. Вывести старую по одномуhealthy— значит на эти 1,5 с остаться с N − 1 репликами. - Вывод старой из LB и удаление:
- runtime API HAProxy:
drain— новых запросов нет, начатые дорабатывают; - ожидание, пока запросов в полёте не станет 0 (≤ 12 с, больше
timeout server); maint,docker stop(graceful, ≤ 10 с; код выхода — в строке скрипта),docker rm;- когда адрес ушёл из слота —
ready.
- runtime API HAProxy:
- Шаги 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) — одна транзакция:
- Сессию проверила зависимость (401), сервис проверяет членство (404) — и при повторе тоже.
- Захват ключа одним выражением:
INSERT … ON CONFLICT (user_id, chat_id, key) DO UPDATE … WHERE created_at < now − ttl RETURNING. Строка вернулась — ключ свободен (новый или просроченный, заменён тем же выражением): вставка сообщения,commit(). - Ключ занят — чтение сохранённого хэша и сообщения,
commit()(снять блокировку строки). Хэш совпал — тот же 201 и то жеMessageиз БД; не совпал — 409conflict.
Почему это корректно, в том числе между репликами (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,kill1, 2,pause1, 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 connect0,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 считается с момента возврата; уpauseCPU интервалов, задевающих заморозку, относится к её внешней части (моменты — события 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.
- Предсказание: эффективность R*(k) / (k × R*(1)) ≥ 0,85 при k ≤ 3;
k_sat ∈ {4, 5}; на k_sat + 1 —
- H3. Граница пула (серия
pool). Пул приложения — 10 + 5 = 15 на реплику, пользователь приложения — суперпользователь (резервsuperuser_reserved_connectionsего не держит), сэмплер занимает 1 соединение. На дефолтах граница — k = 7 (пул 10 + 5 того времени; с 10 + 0 changescaling-improvement— k = 10), вне серииb; опыт — 4 реплики приmax_connections100 (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), разбросы не пересекаются. По коду отказ даст 500internal, а не 503: SQLSTATE 53300 нет вUNAVAILABLE_SQLSTATES(src/infra/db/errors.py), а спекdata-storageтребует 503. - Подтвердит: при 50 есть отказы и ошибки ≥ 1 % на уровне, который при 100 проходит; R*(50) < R*(100) без пересечения; при 100 отказов нет.
- Опровергнет: при 50 отказов нет ни на одном уровне до нарушения SLO — реплики упираются в CPU раньше, чем копятся соединения.
- Предсказание: при 100 отказов «too many clients» нет, на R* и выше
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_overflow5 → 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.
- исходники SQLAlchemy (
-
Предсказание для
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 — ровно две ступени).
-
Подтверждено, если выполнено всё:
- у
4x1-pg0.5выводmake bench_compare … AA=scaling-db-aa(в попытке 2 —AA=scaling-db-aa2) — «эффект», и медиана «после» ≥ медиана «до» × 1,118; - механизм по таблице «PostgreSQL на R* и первой нарушившей ступени»: «после» новых сессий за окно ≤ 10 на обеих ступенях, соединений на R* ≤ 40; «до» на первой нарушившей — ≥ 40 новых сессий;
- дрейфа сессии нет: 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 a1 × 4 / 2 ГиБ, 2 × 2 / 1 ГиБ, 4 × 1 / 512 МиБ 9,75 bk × 1 / 512 МиБ, k = 1…6 6,75…11,75 pool4 × 1 / 512 МиБ при max_connections100 и 509,75 ab1 × 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_connections100: соединений не больше 60 (15 на реплику), отказов «too many clients» 0 на всех 20 ступенях (7 + 6 + 7). 5xx — только 503 от самих реплик на перегрузке (1–11 за окно на 2 034/с, 17–27 на 2 274/с): запрос ждал свободное соединение пула дольшеpool_timeout5 с (строки API"status": 503сduration_ms≈ 5 010 и строки LBapi/api-N 0/0/0/50xx/50xx 503вraw/*-errors.log); на ступенях с 503 LB реплики не исключал (lb_chkdown0), одно исключение — на 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_connections50: пулы упираются в 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. Так ведёт себя измеренный commit712d245: серияpoolснята до правки, спекdata-storageтребует 503. Доказательства окна — строки PostgreSQL, API и LB вevidence/bench/scaling-pool/raw/*-errors.log. Исправлено после серий в68edc66:53300добавлен вUNAVAILABLE_SQLSTATES. Проба тем же отказом (все слотыmax_connectionsзаняты, соединения пула оборваны) даёт 503unavailableв формате контракта с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_connections50 отказы «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_cost1,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, ниже — сравнение). - Механизм подтверждён: 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), сработал
-
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_connections50 отказы «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_timeout5 с, и реплика отвечает 503. Код ответа на отказ — 500 на измеренном commit712d245(серияpoolснята до правки), как и предсказывал разбор кода; после правки68edc66— 503unavailable(тест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 %; порог уточнён до замеров changescaling-improvement) или с оговоркой (bench.md). Дляscaling-improvementscaling-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 (проверка хоста; в паспортах —Swapouts0 в начале и в конце, полеswapouts_deltaне записано, дефект паспорта исправлен changefix-known-issues, метки не правились).
- Попытка 1, 11:10–12:30 UTC:
- Эффект — вывод
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 по заранее записанному критерию не подтверждена:
- Вывод сравнения для основной ячейки — «в пределах шума»: медиана выросла на 32 % (745 → 984, пять ступеней сетки, больше порога × 1,118), но разбросы пересекаются (931 у «до» > 881 у «после»).
- Механизм — подтверждён: «после» новых сессий 4 на обеих ступенях (≤ 10), соединений на R* 40 (≤ 40); «до» на первой нарушившей — 102 (≥ 40). Переоткрытие исчезло и у контроля (190 → 4 на R*). CPU PostgreSQL на запрос на первой нарушившей ступени — 646 → 420 мкс.
- Дрейф — есть: 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 101 / 931 = 1,183 ≥ 1,118 (три ступени), разбросы не пересекаются (931–984 и 1 101 во всех трёх повторах), Δ 18,3 % больше шума 5,4 %.
- Выполнен: «после» новых сессий 3 на R* и 4 на первой нарушившей (≤ 10), соединений на R* 40 (≤ 40); «до» на первой нарушившей — 102 (≥ 40). CPU PostgreSQL на запрос на первой нарушившей 416 → 336 мкс: излом сдвинулся, база держит ~280–340 мкс на запрос до 1 164/с.
- Не выполнен, на 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_chkdown0 во всех 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_connections50 при 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.currentcgroup с кэшем файлов, пик по отсчётам. Всплеск хоста в окне «до» фазы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). Пять записей, найденных попутно, исправлены changefix-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убирает реплику без слота LBdocker 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с changegraceful-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 changescaling-bench). С 10 + 0 тот же опыт дал бы 41 < 50 соединений; серия не переснималась. - Зависшую реплику LB исключает за 6,5 с, а не мгновенно.
timeout check2,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(designgraceful-failover, решение 2). - Оборванный ответ при
kill. Запросы в полёте на убитой реплике получают 502 от LB, LB их не повторяет (они уже дошли). Отправку сообщения клиент повторяет с тем же ключом; другиеPOST— на усмотрение клиента, прозрачных повторов контракт не допускает. Воспроизводится командойdriver.py --port 8080 kill-inflight. - Отказ PostgreSQL выводит из LB все реплики сразу.
/health/readyпроверяет PostgreSQL, поэтому через 1–2 с после его отказа на всё, включая/health/live, отвечает сам HAProxy: 503unavailableв формате контракта — тот же код, что отдал бы 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-alive10 с < 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, changerolling-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_connections50, а не ростом реплик. С пулом 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_timeout2 с. Под тяжёлой записью или во время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 меняет
реплики по одной:
- одна новая рядом со старыми;
- ожидание её
UPв LB; - старая выводится из 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); CLIdocker 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отдельным changefix-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/; решения, перечисленные выше, принимал
автор.