Files
mtusi2026lab3/REPORT.md
T

59 KiB
Raw Blame History

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

  • Автор, группа: Боданюк Алексей, БВТ2302
  • Целевая оценка: 5, трек 1 «Цена масштабирования»
  • Ветка: solution/bvt2302-bodanyuk. Форк: https://gitea.privcloud.tech/wfa/mtusi2026lab3. PR: «ЛР 3 — БВТ2302 — Боданюк — на 5» в mtusi2026/mtusi2026lab3
  • Стек: Python 3.13.16, Starlette 1.7.0, uvicorn 0.54.0, psycopg 3.3.6 + psycopg-pool 3.3.3, redis-py 8.1.0, argon2-cffi 25.1.0; PostgreSQL 18.6, Valkey 8.1.3, HAProxy 3.2.26 (LTS); замеры — k6 2.3.0, py-spy 0.4.2. Все образы закреплены по тегу и digest, все Python-пакеты — по sha256 (requirements.txt, bench/track1/pyspy/requirements.txt)
  • Источники: README, COURSE, контракт (openapi.json, семантика), документация HAProxy 3.2 (server-template, resolvers, http-check, retry-on, http-error), Docker Compose (deploy, networks), PostgreSQL (INSERT … ON CONFLICT, PL/pgSQL, pg_stat_statements, libpq keepalives/tcp_user_timeout), psycopg 3 (pool, autocommit), k6 (constant-arrival-rate, dropped_iterations). Учтены все замечания преподавателя к PR lab3 и lab2 других студентов (раздел ниже); мой PR lab2 (#42) принят без замечаний
  • Помощь ИИ: код, тесты, скрипты экспериментов и черновик отчёта написаны с помощью ИИ-ассистента Claude Code (Anthropic). Все команды и замеры реально выполнены на стенде ниже; вывод — в evidence/. Ответы на вопросы защиты — docs/DEFENSE.md, запуск на Windows и сценарий защиты по шагам — docs/WINDOWS.md

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

Нужны Git, Docker с Compose v2 (проверено: Docker 29.8.0, Compose 5.5.1), Python 3.9+ и GNU make (на Windows — см. WINDOWS.md). Учётные данные в Git не хранятся, их создаёт скрипт.

git clone https://gitea.privcloud.tech/wfa/mtusi2026lab3 mtusi2026lab3 && cd mtusi2026lab3 && git checkout solution/bvt2302-bodanyuk
python3 scripts/init_secrets.py        # случайные локальные пароли -> ./secrets (git-ignored), идемпотентно
cp .env.example .env                   # API_REPLICAS=2, лимиты, таймауты; значения по умолчанию есть и в compose.yaml
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
#   postgres, valkey healthy -> migrate (один раз, exit 0) -> api x2 healthy -> lb healthy
curl -i http://127.0.0.1:8080/health/ready    # 200, X-Instance-Id: <container id>; Swagger /docs; LB: http://127.0.0.1:8404/
make check && make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && make restore
  • Windows: публичным тестам нужен PYTHONUTF8=1; Windows не исполняет .sh, поэтому хуки запускаются через обёртки scripts/restart.cmd и scripts/stop-one.cmd (тот же .sh в Git Bash); рецептам Makefile нужен sh из C:\Program Files\Git\usr\bin.
  • Свои тесты: python3 -m venv .venv, pip install --require-hashes --no-deps -r requirements.txt, pip install -r requirements-test.txt, затем make student-test (~8 мин, стенд должен быть поднят). Без стенда — make unit-test.
  • Все доказательства одной командой (на чистом clone, ~25 мин): python scripts/collect_evidence.py.
  • Миграции: только сервис migrate (python -m messenger.migrate, advisory lock, checksum файлов), до старта реплик. Повтор: make migrate → already applied, skipped.
  • Остановка: безопасно — docker compose down (volumes сохраняются). Намеренное удаление учебных данных — docker compose down -v и rm -rf secrets.

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

клиент ──127.0.0.1:8080──> lb: HAProxy 3.2 ──сеть edge──> api × N (Starlette/uvicorn, без состояния, X-Instance-Id = hostname)
                              │ check GET /health/ready 1 с, fall 2/rise 2                     │
                              │ Docker DNS `api` каждые 1 с (server-template, 8 слотов)        └──сеть data (internal)──> postgres 18.6 (источник истины)
                              └ свои 502/503/504 — JSON по контракту с X-Request-Id                                     valkey 8.1.3 (сессии, AOF always)
migrate (одноразовый) ──data──> postgres: миграции 0001–0003 до старта реплик
Роль Service Образ Health / readiness Volume Сеть / порт Credentials CPU / RAM
Точка входа lb haproxy:3.2.26-alpine@sha256:254e6370… haproxy -c + stats; бэкенды — активная проверка /health/ready — edge; 127.0.0.1:8080 и [::1]:8080 (loopback, см. ниже), 127.0.0.1:8404 (stats) нет 1.0 / 128m
API × 2 api (deploy.replicas) mtusi-messenger:lab3 из исходников Docker: /health/ready 2 с; LB: своя проверка — edge + data, только expose 8080 secrets database_url, cache_url 1.0 / 256m каждая
Миграции migrate тот же образ exit 0 — data secret database_url 0.5 / 256m
БД postgres postgres:18.6-bookworm@sha256:afc7e2d4… pg_isready pgdata data (internal) secret postgres_password 2.0 / 1g
Сессии valkey valkey/valkey:8.1.3-bookworm@sha256:fea8b3e6… valkey-cli ping valkeydata data (internal) secret valkey_password → include-файл 0.5 / 256m

Что перенесено из lab2 (отдельный коммит 4f6cfda, без изменений): API, PostgreSQL-схема 0001, сессии только в Valkey, Argon2id, keyset-cursor, строгая валидация, дедлайны БД/Valkey, собственные тесты. Что изменено в lab3:

  • Балансировка без sticky. Один Compose-сервис api масштабируется (--scale, deploy.replicas), без container_name и ports. HAProxy находит реплики через Docker DNS (server-template api 8 api:8080 … resolvers docker, hold valid 1s), поэтому scale up/down, новый IP после рестарта и полный restart стенда подхватываются без перезапуска LB (проверено тестами).
  • Readiness управляет маршрутизацией. option httpchk GET /health/ready, inter 1s fastinter 500ms fall 2 rise 2, timeout check 1s, без backup-слотов. Ready = PostgreSQL и Valkey отвечают и нет drain. Реплика, живая по /health/live, но без БД/Valkey, не получает ни одного бизнес-запроса.
  • Повторы в LB только безопасные. retry-on conn-failure + option redispatch: повторяется только запрос, который не удалось отправить реплике. Всё, что могло дойти до API (включая неидемпотентные POST создания чата/пользователя), повторяет клиент сам; отправку сообщения — с тем же Idempotency-Key.
  • Graceful shutdown. SIGTERM → readiness 503 сразу → DRAIN_SECONDS=3 реплика ещё обслуживает (LB успевает пометить её DOWN) → uvicorn закрывает сокет, запросы в полёте ≤ SHUTDOWN_TIMEOUT_SECONDS=8 → exit 0. 3 + 8 < stop_grace_period: 15s, SIGKILL не нужен.
  • X-Instance-Id = hostname контейнера (короткий container ID): стабилен для процесса, однозначно сопоставляется контейнеру (docker inspect), что использует scripts/stop-one.sh. Middleware ставит его и X-Request-Id на каждый ответ API, включая 404/405/413/500/503. Ошибки, созданные самим HAProxy, — без X-Instance-Id (их создал не API), но в формате контракта и с тем же X-Request-Id.
  • Общая идемпотентность (0002, 0003, repo.py, app.py). Таблица idempotency_keys (user_id, chat_id, key) → SHA-256 канонического тела → message_id. Ключ, часы чата, сообщение и «результат» — одна транзакция; отдельного pending-состояния нет, поэтому сбой не оставляет «висящий» ключ, а транзиентная 5xx не фиксируется. Конкурентный повтор ждёт на уникальном индексе завершения первой транзакции и затем видит её результат (READ COMMITTED). Тот же ключ и тело → тот же 201 и Message; другое тело → 409; постороннему — 404 всегда (членство проверяется до ключа); attachment_ids: [] = отсутствие поля, порядок ключей JSON не важен. Ключи хранятся ≥ 24 ч, старше — очищаются пачками раз в 10 мин под advisory-замком.
  • Миграции — только сервис migrate, до старта реплик; 0002 и 0003 только добавляют объекты и совместимы с работающей предыдущей версией (rolling update: сначала миграция новым образом, затем замена реплик). При docker compose start api (например, в restart.sh) Compose снова запускает migrate как зависимость — он берёт advisory-замок и отвечает already applied, skipped; реплики ждут его завершения (test-persistence.txt).
  • Порты только на loopback. LB опубликован на 127.0.0.1 и [::1]. На Windows localhost сначала разрешается в ::1, и отказ соединения по нему стоил ~2 с на каждый запрос (измерено: 2,0 с против 0,007 с). Публичные тесты по умолчанию ходят на http://localhost:8080, и в первом прогоне из чистого clone make test-failover из-за этого успел сделать лишь 8 записей за 15 с. После исправления — 0,013 с.
  • Сети. edge (lb, api) и internal data (api, migrate, postgres, valkey): LB не видит хранилища, у хранилищ нет выхода наружу. Secrets — каждому сервису только свои (проверяется тестом по docker compose config).
  • Дефект, найденный на lab3-сценарии рецензента. Если одной реплике отключить сеть data, по дедлайну задача psycopg отменялась, psycopg слал cancel-запрос, а libpq PQcancelStart синхронно резолвит имя хоста в потоке event loop — вся реплика, включая /health/live, зависала примерно на минуту и не возвращалась сама. Теперь по дедлайну запрос сразу получает 503, а задача не отменяется и завершается сама; мёртвые соединения рвёт TCP keepalive + tcp_user_timeout = 3 с (db.py). Повторная проверка: live отвечает за 0,00 с, ready 503 за 1,0 с, после восстановления сети реплика сама UP за ~2 с (тест test_lb_stops_routing_…[network]).
  • Улучшение трека 1 — запись сообщения одним вызовом SQL-функции post_message (подробно в треке); прежний путь доступен как MESSAGE_WRITE_PATH=multi, оба проходят одни и те же тесты.

Readiness-критичные зависимости: PostgreSQL (всё, кроме health) и Valkey (все защищённые запросы). Swagger/stats LB на readiness не влияют.

Соответствие .env.example реальной конфигурации (config.py, compose.yaml):

Переменная Значение Где используется
APP_HOST, APP_PORT, APP_ENV 0.0.0.0, 8080, lab bind uvicorn, стартовый лог
SESSION_TTL_SECONDS 3600 срок сессии (compose передаёт в каждую реплику)
DATABASE_URL_FILE, CACHE_URL_FILE /run/secrets/… строки подключения из secret-файлов
SESSION_STORE valkey (или postgres) хранилище сессий
API_REPLICAS 2 deploy.replicas сервиса api
IDEMPOTENCY_TTL_SECONDS 86400 (меньше нельзя) срок хранения результата ключа
MESSAGE_WRITE_PATH function (или multi) путь записи сообщения (трек 1, A/B)
DRAIN_SECONDS, SHUTDOWN_TIMEOUT_SECONDS 3, 8 graceful shutdown
DB_POOL_MIN/MAX, DB_TIMEOUT_SECONDS, CACHE_TIMEOUT_SECONDS, PASSWORD_HASH_CONCURRENCY 1/10, 3, 0.5, 2 пул, дедлайны, параллельность Argon2id
API_CPUS/MEMORY, PG_CPUS/MEMORY, VALKEY_CPUS, LB_CPUS, PG_MAX_CONNECTIONS 1.0/256m, 2.0/1g, 0.5, 1.0, 100 лимиты контейнеров
APP_PUBLISH_PORT, LB_STATS_PORT 8080, 8404 порты LB на 127.0.0.1 (API портов не публикует)
LOG_LEVEL, DOCS_ENABLED info, true логи, Swagger

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

Стенд: Windows 10 22H2, AMD Ryzen 5 3400G (4 ядра / 8 потоков), 30 ГБ RAM, Docker Desktop 29.8.0 (WSL2, 8 vCPU), Python 3.14 на хосте, GNU make 4.4.1. Все проверки уровней 3 и 4 ниже выполнены 2026-10-19 на стенде из чистого clone (новая папка, git clone, пустые volumes, secrets созданы заново) одной командой python scripts/collect_evidence.py, коммит 2708732. Вывод сохранён целиком.

Критерий README Команда / сценарий Наблюдаемый результат Файл
Чистый clone, secrets, миграции с нуля, одна команда запуска init_secrets.py, compose config --quiet, compose up -d --build --wait, compose logs migrate, git check-ignore все 5 сервисов healthy, migrate Exited (0): 0001…0003: applied; образы по digest; secrets/ и .env игнорируются Git clean-clone.txt
Контракт make check, make validate PASS, PASS make-check-validate-test.txt
3: публичный smoke make test PASS: lab3 public API scenario там же
3: ≥ 2 реплики, одна точка входа, общая БД и сессии lbctl.py replicas/status, test_one_session_is_served_by_every_real_replica, test_write_on_one_replica_is_read_on_the_other 2 контейнера api UP в HAProxy; один токен — ответы от обоих, X-Instance-Id = их hostname; запись на одной сразу читается на другой; logout сразу действует на обеих clean-clone.txt, student-tests.txt
3: остановка любой реплики, ≤ 10 с, подтверждённое на месте make test-failover ACTION_SCRIPT=scripts/stop-one.cmd → make restore → снова (по очереди обе) PASS для api-1 и для api-2: 131 / 132 успешных записи, 0 неудачных попыток, запись после хука — 5,9 / 5,7 с; остановленный контейнер exited (0), вторая реплика UP test-failover.txt
3: повтор POST без дубля, в т.ч. конкурентный и через другую реплику; неподтверждённую запись можно повторить test_idempotency.py (21 тест) + публичный failover-тест (повторяет неопределённый POST с тем же ключом) см. таблицу «ловушек» ниже; публичный тест: дублей нет student-tests.txt
3: persistence make test-persistence ACTION_SCRIPT=scripts/restart.cmd PASS; у lb, api-1, api-2, postgres, valkey новые PID и StartedAt, volumes те же, токен тот же test-persistence.txt
4: readiness, таймауты, SIGTERM согласованы; LB исключает недоступный backend test_lb_stops_routing_…[pg_hba/network × 2], test_graceful_stop_…[×2], test_graceful_shutdown_order_in_logs живая, но неготовая реплика выходит из ротации за 3–4 с, live 200 / ready 503, сама возвращается ≤ 15 с; graceful stop под нагрузкой — 0 ошибок; в логах drain_started → shutdown_requested → stopped, exit 0, в логе HAProxy — is DOWN для этой реплики student-tests.txt
4: период проверок и максимальное время обнаружения haproxy.cfg + серия отказов проверка раз в 1 с, fall 2/rise 2, timeout check 1s; максимум ≈ 3,5 с (заморозка); подробно — в следующем разделе failover/series.md
4: поочерёдная остановка каждой реплики: RPS, ошибки, восстановление bench/failover_series.py (stop / kill / pause × обе реплики) stop: 0 ошибок; kill: 3 оборванных запроса за ≤ 0,25 с; pause: 4 неудачные попытки за ≤ 3,2 с; потерь и дублей нет failover/series.md, series.json
4: общая идемпотентность параллельными запросами test_concurrent_same_key_through_different_replicas_creates_exactly_one, …_different_bodies_one_wins 24 одновременных → 24 × 201, одно тело, ≥ 2 реплики, 1 строка ключа и 1 сообщение (×3 раунда); разные тела → один победитель, остальные 409 student-tests.txt
4: лимиты CPU/RAM, нет портов в обход LB, secrets по месту, нет container_name test_compose_policy_limits_ports_secrets_images, test_running_containers_have_limits_and_no_bypass_ports лимиты у всех 5 сервисов (config и docker inspect); порты только у lb и только loopback; secrets: lb — нет, migrate — database_url, api — database_url+cache_url; сети edge/data там же
4: rolling update под нагрузкой bench/rolling_under_load.py → scripts/rolling-update.sh 57 с, 11 848 запросов, 0 ошибок; api-1/2 revision=dev → api-3/4 revision=2708732-…; 7119 подтверждённых сообщений, 0 потерь и дублей rolling-update/
4: миграции однократно и совместимы test_migrations_ran_once_by_the_migrate_service, test_migrations_rerun_is_a_noop применяет только migrate (в логах API миграций нет); повтор — already applied, skipped; 0002/0003 только добавляют объекты и применяются до замены реплик student-tests.txt, rolling-update/script-output.txt
Публичный генератор нагрузки tests/load.py --duration 30 --concurrency 4 5247 успешных, 0 ошибок, 174 req/s (closed-loop через порт Windows), p50/p95/p99 = 19 / 50 / 65 мс load.json
Свои тесты python -m pytest student-tests -v 201 passed (69 unit + 132 против стенда), 8 мин; все отказы восстанавливаются в finally student-tests.txt
Оба пути записи эквивалентны тесты идемпотентности, контракта и БД с MESSAGE_WRITE_PATH=multi 105 passed (режим function — весь набор выше) раздел трека 1
5: трек 1 `bench/track1/series.sh baseline improved ceiling, profile.py, analyze.py`

Первый прогон из чистого clone (тот же сценарий, коммит 2846cae) нашёл проблему: через localhost каждое соединение на Windows стоило 2 с (LB был опубликован только на 127.0.0.1), и make test-failover успел сделать 8 записей вместо ~130. Исправлено публикацией и на [::1] (коммит 2708732). Таблица выше — второй, полный прогон.

Проверки, на которых ловили другие работы

Замечания преподавателя к PR lab3 (#1–#19) и lab2 других студентов, проверенные на своём стенде:

Замечание к чужим PR У нас Где проверено
после сбоя ключ остаётся «pending»: повтор висит / 504 / 409 ключ и сообщение в одной транзакции; сбой триггером после вставки ключа → нет ни ключа, ни сообщения (n_tup_ins доказывает, что INSERT был), повтор → 201 test_failure_after_the_key_insert_rolls_everything_back
одновременные повторы дают 19×201 + 1×409 24 одновременных запроса через ≥ 2 реплики, три раунда → 24×201, одно тело, 1 сообщение, 1 строка ключа test_concurrent_same_key_through_different_replicas_creates_exactly_one
посторонний: 404, затем 409 всегда 404, и с чужим ключом, и с другим телом test_outsider_and_revoked_session_never_see_the_stored_result
attachment_ids: [] при повторе → 400 равно отсутствию поля, тот же 201; порядок ключей не важен test_key_order_and_missing_attachment_ids_are_the_same_body
X-Instance-Id: unknown; нет заголовков на 500 / 413 hostname контейнера; middleware на всех ответах, включая 500 из триггера и 413 Api.call проверяет каждый ответ; test_every_api_response_carries_…
LB шлёт запросы неготовой реплике (pg отнят, network disconnect, забит пул); fallback-слоты без проверки активная проверка /health/ready, без backup; реплика выходит из ротации за 3,2–4,1 с и сама возвращается test_lb_stops_routing_to_a_replica_that_is_alive_but_not_ready[pg_hba/network × 2 реплики]
после общего restart LB видит одну реплику re-resolve Docker DNS каждую секунду test_full_restart_lb_rediscovers_all_replicas
«обновление» останавливает обе API; нет проверки под нагрузкой +1 новая реплика, затем graceful stop старой; под нагрузкой 0 ошибок evidence/rolling-update/
миграции в каждой API только migrate; в логах API нет миграций test_migrations_ran_once_by_the_migrate_service
нет лимитов у LB, migrate, PostgreSQL, Redis лимиты у всех 5 сервисов; проверены и compose config, и docker inspect запущенных test_compose_policy_…, test_running_containers_have_limits_…
неидемпотентные POST повторяются LB retry-on conn-failure — только неотправленные запросы haproxy.cfg, DEFENSE.md
cursor с числом/null/[]/{}/false, пустой, пробел → 500 или 200 400 на обоих списках; курсор одного списка в другом → 400 test_malformed_cursor_values_are_400_on_both_lists, test_cursor_of_one_list_is_rejected_by_the_other
{"text":"first","TEXT":"second"}, дубли ключей, {"text":123}, хвост после JSON, байт FF 400, ничего не сохраняется test_bad_message_body_is_400_and_nothing_is_stored
Bearer é → 500; UUID в разном регистре → 503; тело при входе игнорируется 401; 400 (дубль после нормализации); 400 test_non_ascii_or_garbage_bearer_…, test_member_ids_are_compared_as_uuids_…, test_login_with_a_body_is_rejected
пароль "a" принят, "я:"×64 отклонён; пробельные Unicode-строки (U+00A0, U+2003) приняты; 1e1000 роняет API; 101 участник 400 / 201; 400; 400 и API живо; 400 test_password_range_…, test_unicode_whitespace_only_strings_are_400, test_odd_registration_bodies_…, test_more_than_100_members_is_400
текст обрезается по краям, длина считается после обрезки хранится как есть; 4001 code point → 400 test_text_is_stored_verbatim_and_length_counts_raw_text
трек 1: в «RPS» входят ошибки; неверное суммирование CPU реплик; бюджет в отчёте не совпадает с данными; на графике несопоставимые точки считаются только 201 (ok_messages), dropped отдельно; CPU реплик суммируется в каждый момент; фактические лимиты из docker inspect в каждом raw-файле; на графике серии одной конфигурации ресурсов analyze.py, run.py
трек 1: улучшение не воспроизвелось на другом хосте улучшение структурное (число обращений к БД на запрос, видно в pg_stat_statements), A/B на одном образе одной переменной серия D
lab2: отозванный токен «оживает» после восстановления Redis; БД упала → 401/500 сессии только в Valkey (нет второй копии); 503 test_failures.py, test_sessions.py (перенесены из lab2)

Сам Content-Type text/plain даёт 400, а не 415: в OpenAPI lab3 для POST /users и POST …/messages ответ 415 не объявлен, контракт требует отклонения — оно есть.

Эксперименты и отказы (уровень 4)

Поочерёдная остановка каждой реплики (bench/failover_series.py, series.md). Нагрузка — 4 closed-loop клиента с хоста через LB: POST сообщения (неопределённый результат → повтор тем же ключом) + GET последней страницы, таймаут клиента 3 с. Раунд: 6 с прогрева → остановка → 12 с без реплики → старт → ожидание UP в HAProxy → 6 с. Перед каждым раундом предыдущая реплика уже восстановлена.

Воздействие Что ожидаем Что наблюдали (api-1 / api-2) Восстановление / потери
docker stop (SIGTERM, drain) 0 ошибок: реплика сама уходит из ротации до закрытия сокета 3568 / 3565 запросов во время отказа, 0 ошибок; цель последний раз ответила через 1,28 / 1,24 с после SIGTERM (drain) возврат: UP через 3,3 / 1,4 с, снова обслуживает через 3,4 / 3,1 с; 0 потерь, 0 дублей
docker stop -t 0 (SIGKILL) обрываются только запросы «в полёте» на убитой реплике 3 неудачных попытки (обрыв соединения) за ≤ 0,25 с; новые запросы сразу идут на живую (retry-on conn-failure) возврат 2,8 / 3,6 с; неопределённые POST повторены тем же ключом, 0 дублей
docker pause (заморожен процесс — худший случай) запросы на замороженную реплику ждут до таймаута, пока проверки её не выключат 4 неудачные попытки, последняя через 3,2 / 3,1 с; ok-RPS во время отказа падает ~вдвое (часть клиентов ждёт) после unpause UP через 2,2 / 1,2 с; 0 потерь, 0 дублей
неготовая, но живая реплика (pg_hba reject / network disconnect сети data) LB исключает её по readiness, бизнес-запросы к ней не идут DOWN через 3,2–4,1 с, затем 40 из 40 чтений и 20 из 20 регистраций — через другую реплику; live 200 / ready 503, процесс отвечает сама UP ≤ 15 с после восстановления доступа (тест)
rolling update ≥ 2 реплики в каждый момент 57 с, 11 848 запросов, 0 ошибок, p95 53 мс обе реплики на новой ревизии; 0 потерь, 0 дублей
restart всего стенда (restart.sh) данные и токен на месте, LB находит новые IP сам PASS публичного теста; новые PID у всех 5 процессов LB видит обе реплики без своего рестарта (тест)

Период проверок и максимальное время обнаружения. HAProxy проверяет GET /health/ready каждую 1 с, после первой неудачи — каждые 0,5 с (fastinter), DOWN после 2 неудач подряд, UP после 2 удач, таймаут проверки 1 с.

Ситуация Максимум до DOWN
реплика сразу отвечает 503 (drain после SIGTERM) ≈ 1 + 0,5 = 1,5 с
ready отвечает медленно (отнят PostgreSQL/Valkey: ответ ≈ 1 с = таймаут проверки) ≈ 1 + 1 + 0,5 + 1 = 3,5 с
процесс заморожен (каждая проверка ждёт таймаут) ≈ 1 + 1 + 0,5 + 1 = 3,5 с
процесс убит или порт закрыт новые запросы получают отказ соединения, HAProxy сразу отправляет их на другую реплику (retry-on conn-failure + redispatch); проверка лишь фиксирует это

Измерения выше в эти пределы укладываются: при drain реплика выходит из ротации за ≈ 1,2–1,3 с, а 3,2–4,1 с (отнятая БД/сеть, заморозка) включают 0,1–0,5 с опроса через docker exec.

Ограничение измерения. Нагрузка closed-loop с хоста Windows через проброс порта Docker Desktop (~200–290 ok-RPS). Это проверка доступности и корректности, а не ёмкости — ёмкость меряет трек 1 с k6 внутри сети стенда. Неудачной попыткой считается любой не-2xx ответ или ошибка соединения/таймаут клиента.

Трек 1. Цена масштабирования

Все цифры ниже — из evidence/track1/summary.md (генерирует analyze.py из results.csv); сырые данные каждой ступени — evidence/track1/<серия>/<метка>/raw/*.json (k6 summary, CPU по контейнерам, ожидание пула, счётчики PostgreSQL и HAProxy, фактические лимиты из docker inspect). Полный план повторяется одной командой: bench/track1/series.sh.

Гипотезы

  1. Один процесс Python (uvicorn, 1 воркер) исполняет байткод на одном ядре (GIL). Поэтому при фиксированном суммарном CPU одна «толстая» реплика упрётся в одно ядро, а несколько «тонких» используют весь бюджет. Дробить сильнее, чем по ядру на процесс, бесполезно.
  2. Реплики API без состояния масштабируют пропускную способность линейно, пока не насытится общий ресурс — PostgreSQL (одна БД на все реплики). После этого добавление реплик не помогает, и потолок задаёт CPU БД. Если дать БД больше CPU, потолок сдвинется — это проверка причины, а не совпадения.
  3. LB (HAProxy) и пул соединений не являются узким местом на этих нагрузках: HAProxy тратит единицы процентов ядра на сотни запросов/с.
  4. Улучшение: основная цена запроса — накладные расходы на каждый SQL-оператор, а не сама работа БД (гипотеза из профиля). Если выполнить идемпотентную запись одним вызовом, сократятся CPU на сообщение и в API, и в PostgreSQL, и потолок вырастет в обоих режимах — и когда упираемся в API, и когда в БД.

Методика

  • Стенд. Ноутбук: AMD Ryzen 5 3400G (4 ядра / 8 потоков SMT), 30 ГБ RAM, Windows 10 22H2, Docker Desktop 29.8.0 (WSL2, ядро 6.18, 8 vCPU, 15,6 ГБ). «1 CPU» в лимитах = 1 vCPU = один аппаратный поток SMT, то есть примерно половина физического ядра.
  • Изоляция. На время серий основной стенд остановлен. Каждая конфигурация в каждом повторе — свежий стенд в отдельном compose-проекте mtusi-lab3-bench с пустыми volumes (down -v → up), чтобы размер истории не копился между конфигурациями. Роли закреплены за своими CPU (cpuset, compose.bench.yaml): k6 — 0–1, LB + Valkey — 2, PostgreSQL — 3–4, все реплики API — 5–7. Поверх набора CPU действуют квоты cpus из конфигурации (API_CPUS на реплику, PG_CPUS). Генератор и LB не отнимают CPU у API.
  • Код. Образ API собирается из коммита (git archive <sha> | docker build), а не из рабочей копии: базовые серии A–C — коммит 3f45eb1 (до улучшения), серии D–E — 4830be4 (с улучшением, старый путь доступен через MESSAGE_WRITE_PATH=multi). Фактический образ и лимиты записаны в каждом raw-файле.
  • Нагрузка. k6 2.3.0 в отдельном контейнере в сети edge идёт через LB, как внешний клиент, без проброса портов Windows. Open-loop constant-arrival-rate: итерации стартуют с заданной частотой независимо от ответов, поэтому нет coordinated omission. Итерации, которым не хватило VU, считаются в dropped_iterations как неудовлетворённый спрос. Одна итерация = POST /chats/{id}/messages с новым Idempotency-Key в один из 64 чатов (64 пользователя, у каждого свой чат), чтобы блокировка строки одного чата не доминировала. Пользователи и сессии создаются оркестратором до старта k6, файл с синтетическими токенами монтируется только для чтения и удаляется после серии.
  • Ступень: прогрев 10 с (не учитывается) + замер 20 с. Ступени по возрастанию предложенной нагрузки, 3 повтора. Таймаут запроса 10 с.
  • Метрики. Успешные = только ответы 201 (ok_messages). Ошибки и dropped — отдельно; задержки p50/p95/p99 — только успешных. CPU — docker stats каждые ~1–2 с, медиана за фазу замера; CPU реплик суммируется в каждый момент. Ожидание пула — счётчики psycopg-pool из лога реплик (STATS_LOG_SECONDS=2). PostgreSQL — pg_stat_database (транзакции, WAL) и pg_stat_statements (операторы на сообщение). HAProxy — show stat (переходы в DOWN, очереди).
  • Определения. Потолок конфигурации — наибольший успешный RPS по ступеням в повторе, затем медиана и разброс по 3 повторам. SLO-ёмкость — наибольшая предложенная нагрузка, обслуженная на ≥ 97 % с p95 ≤ 500 мс. Узкое место — компонент, чей CPU ≥ 90 % своего лимита на ступени потолка. Для API отдельно отмечается «одно ядро на процесс», когда CPU ≈ 100 % × число реплик при большей квоте.

Результаты

A. Фиксированный суммарный CPU API = 2,0 (768 МиБ), PostgreSQL 2,0 CPU (график):

Реплики × CPU Потолок, успешных/с (мин–макс) SLO-ёмкость CPU API / квота CPU БД / квота CPU LB Узкое место
1 × 2,0 214 (209–220) 200 101 % / 200 % 47 % / 200 % 9 % одно ядро на процесс (GIL)
2 × 1,0 289 (281–291) 250 198 % / 200 % 66 % / 200 % 14 % CPU API
4 × 0,5 239 (237–241) 150 195 % / 200 % 60 % / 200 % 13 % CPU API + флаппинг проверок

Гипотеза 1 подтверждена. Одна реплика с квотой 2,0 использует ~1 ядро, вторая половина квоты простаивает. Две реплики по 1,0 используют весь бюджет и дают +35 %. Четыре по 0,5 при том же бюджете хуже двух (−17 %): процесс с квотой 0,5 обрабатывает каждый запрос вдвое дольше, растёт задержка (p95 уже при 150/с — 460 мс). Кроме того, при перегрузке реплики не успевают ответить на /health/ready за 1 с: HAProxy выводит их из ротации — 78 переходов в DOWN за серию, до 11 % ответов 503 от LB. Дробление ниже ядра на процесс ухудшает и скорость, и стабильность.

B. Рост ресурсов API (1, 2, 3 реплики × 1,0 CPU) при узкой БД (PostgreSQL 0,5 CPU) (график):

Реплики Потолок, успешных/с (мин–макс) CPU API / квота CPU БД / квота Узкое место Ошибки при перегрузке
1 178 (177–180) 94 % / 100 % 39 % / 50 % CPU API до 26 %
2 210 (208–222) 145 % / 200 % 49 % / 50 % CPU PostgreSQL до 20 %
3 197 (197–205) 167 % / 300 % 49 % / 50 % CPU PostgreSQL до 42 %

Точка насыщения БД — около 200–210 успешных/с. Вторая реплика ещё помогает (+18 %), третья — нет: API простаивает (167 % из 300 %), CPU БД на квоте. При перегрузке выше этой точки запросы ждут соединения в пуле (до ~1 с), часть упирается в дедлайн 3 с (503). Readiness реплик тоже начинает отвечать дольше 1 с, и HAProxy выводит их из ротации (103 перехода в DOWN у 3 реплик). Больше реплик — больше конкурирующих соединений к той же БД и больше ошибок, а не больше пропускной способности.

C. Рост ресурсов БД при 3 репликах × 1,0 (график):

CPU PostgreSQL Потолок, успешных/с (мин–макс) CPU API / квота CPU БД / квота Узкое место
0,5 (из серии B) 197 (197–205) 167 % / 300 % 49 % / 50 % PostgreSQL
1,0 334 (316–337) 281 % / 300 % 94 % / 100 % API и PostgreSQL
2,0 347 (345–347) 293 % / 300 % 92 % / 200 % CPU API

Гипотеза 2 подтверждена причинно. Удвоение CPU одной только БД при тех же трёх репликах поднимает потолок на 70 % — значит, в B ограничивала именно БД. Следующее удвоение даёт только +4 %: узкое место вернулось в API (293 % из 300 %), БД загружена меньше чем на половину квоты. Узкое место переходит между компонентами (API → БД → API), и масштабировать имеет смысл только тот компонент, который сейчас насыщен.

LB и пул (гипотеза 3). HAProxy на всех ступенях занимает 4–24 % одного ядра. Очередь в LB появляется только на ступенях перегрузки, когда у реплики уже 200 одновременных запросов (maxconn 200 на сервер): qmax 200–576 при 250–400/с, ни разу ниже потолка конфигурации. Это защита реплики, а не причина насыщения; qmax — максимум с момента старта стенда. Пул (10 соединений на реплику) не ограничивает сам по себе: ожидание соединения вырастает (сотни мс) только после насыщения CPU API или БД, то есть это симптом, а не причина. Под перегрузкой первым «ломается» не LB, а readiness: проверка /health/ready идёт через тот же пул и event loop, и под перегрузкой реплика честно сообщает «не готова». В итоге LB сбрасывает избыточную нагрузку ответами 503 — это видно в B и A (4 × 0,5).

Улучшение: идемпотентная запись одним вызовом

Диагностика. Профиль одной реплики (2 × 1,0 CPU, 240 req/s, py-spy 20 с, profile-baseline-3f45eb1.txt) показал: 52,7 % сэмплов — в драйвере psycopg, 23 % — в event loop, 9,6 % — в нашем коде, по 2–4 % — в uvicorn, redis-py, логировании, Starlette. Время делят функции, через которые проходит каждый оператор: ожидание ответа (wait_async), отправка команды, подготовка prepared statement, разбор результата. На одно сообщение старый путь делает ~15 операторов в двух транзакциях (pg_stat_statements): проверка членства, BEGIN, захват ключа, часы чата, вставка, COMMIT, проверки соединений пулом.

Изменение (коммит 4830be4, 0003_post_message_function.sql, repo.py). Вся логика — та же проверка членства, тот же INSERT … ON CONFLICT, те же часы чата и вставка — перенесена в PL/pgSQL-функцию post_message. Её вызывает один оператор в autocommit, вызов и есть транзакция. Семантика не меняется: оба пути проходят одни и те же тесты идемпотентности, контракта и БД (105 тестов в режиме multi, весь набор — в режиме function).

A/B на одном образе одной переменной (серия D, MESSAGE_WRITE_PATH=multi|function, график; пунктир — старый путь, сплошная — новый):

Конфигурация multi, потолок (мин–макс) function, потолок (мин–макс) Прирост p95 на 450/с
2 × 1,0 CPU, БД 2,0 (упор в API) 283 (281–286) 489 (488–491) — не насыщен на сетке до 500/с ≥ +73 % multi — перегружен; function — 399 мс
3 × 1,0 CPU, БД 0,5 (упор в БД) 202 (200–203) 452 (444–462) +124 % multi — перегружен; function — 331 мс

Цена одного сообщения на ненасыщенных ступенях 200–250/с (медиана 3 повторов):

На одно сообщение multi function Изменение
CPU API 7,2–8,6 мс 4,3–4,9 мс −38…44 %
CPU PostgreSQL 2,3–2,6 мс 1,0–1,3 мс −50…60 %
SQL-операторов (pg_stat_statements) 15 3 −80 %
транзакций в pg_stat_database (с проверками пула) ~6 ~3 −50 %
WAL ~1,9 КБ ~1,9 КБ без изменений: пишутся те же строки, durability та же

Профиль после изменения при тех же 240 req/s (profile-function-4830be4.txt): доля psycopg 19,0 % вместо 52,7 %. Активных сэмплов реплики за те же 20 с — 2026 вместо 3889 (py-spy не считает простой), то есть −48 % CPU-времени на тот же поток запросов.

Механизм подтверждён измерением, а не только итоговым RPS: работа с данными (WAL) не изменилась, исчезли накладные расходы на операторы. Поэтому улучшение не зависит от конкретного ноутбука. Число операторов и транзакций на сообщение — свойство кода, оно воспроизводится на любом хосте через pg_stat_statements. Абсолютные RPS на другом железе будут другими.

Потолок нового пути (серия E, те же конфигурации, ступени 450–850/с, 3 повтора, график):

Конфигурация function, потолок (мин–макс) CPU API / квота CPU БД / квота Узкое место Итог против multi
2 × 1,0 CPU, БД 2,0 552 (530–552) 195 % / 200 % 66 % / 200 % CPU API 283 → 552: +95 %
3 × 1,0 CPU, БД 0,5 423 (395–440) 177 % / 300 % 50 % / 50 % CPU PostgreSQL 202 → 423–452: +110…124 %

В серии E DB-bound конфигурация начинает сразу со ступени 450 — это уже выше её потолка, поэтому её максимум здесь ниже, чем в D (452 при 450/с). Обе серии сходятся на ~420–460/с.

После улучшения узкие места остались на своих местах, но каждый компонент делает вдвое больше полезной работы на единицу CPU. В 2 × 1,0 потолок снова задаёт CPU API (два процесса по ядру), и следующий рост — снова реплики и ядра под API. В 3 × 1,0 при БД 0,5 потолок задаёт CPU PostgreSQL: прирост реплик API за пределами точки насыщения БД по-прежнему не помогает. Улучшение сдвинуло эту точку более чем вдвое.

Ограничения трека

  • Один хост и SMT: 8 vCPU — это 4 физических ядра. k6, LB, БД и API разнесены по cpuset, но делят физические ядра попарно и общий кэш, а Windows-хост создаёт фоновый шум. Абсолютные числа годятся только для сравнения конфигураций на этом стенде (одинаковые ресурсы, одинаковый профиль), универсального RPS нет.
  • Профиль нагрузки — только запись сообщений (новые ключи, 64 чата). Чтение истории, повторы ключей и вход (Argon2id) не нагружались. Профиль с горячим чатом (все пишут в один чат) упрётся в блокировку строки чата, а не в CPU — это отдельный эксперимент.
  • Сетка ступеней шагом 50/с. Потолок известен с точностью до ступени; для function в 2 × 1,0 потолок в серии D не достигнут, его ищет серия E.
  • CPU из docker stats — медиана выборок ~1–2 с. Это не точный учёт cgroup за окно. Окно замера определяется по времени выхода k6 (±1–2 с).
  • Замер 20 с после прогрева 10 с на пустой БД: эффекты роста таблиц (autovacuum, раздувание индексов) не исследовались.
  • py-spy с --nonblocking слегка замедляет профилируемую реплику, поэтому профиль показывает доли, а не абсолютный RPS.

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

Какие отказы выдерживаются (доказано на стенде):

  • остановка, SIGKILL или заморозка одной API-реплики из двух: запись продолжается, подтверждённые сообщения на месте, дублей нет;
  • потеря одной репликой связи с PostgreSQL/Valkey: реплика выходит из ротации, после восстановления сама возвращается;
  • рестарт всего стенда с сохранением volumes: данные и прежний токен на месте, LB находит новые адреса реплик;
  • поочерёдная замена реплик (rolling update) под нагрузкой — без ошибок;
  • отказ PostgreSQL или Valkey целиком: ограниченные по времени 503, без анонимного доступа; после восстановления всё работает (перенесено из lab2).

Какие не выдерживаются (честно):

  • Один Docker-host — это SPOF всего стенда: потеря хоста = потеря всего.
  • LB один. Отказ HAProxy = недоступность API, хотя реплики живы. Нужны два LB с VIP (keepalived) или DNS/anycast. В Compose на одном хосте это не даёт реальной устойчивости.
  • PostgreSQL и Valkey не реплицированы. Их отказ — 503 до восстановления, их диск — единственная копия данных (резервное копирование и PITR — тема трека 2 lab2, здесь не повторялось).
  • Обнаружение замороженной реплики (docker pause) — до ~3,5 с. Запросы, попавшие на неё раньше, ждут клиентский таймаут: в доказательной серии — 4 неудачные попытки, последняя через 3,1–3,2 с (в предварительном прогоне — 8 попыток, последняя через 6,2 с: клиент дважды подряд попал на замороженную реплику до её выключения). HAProxy не повторяет такие запросы сам — они могли дойти до API, а неидемпотентные POST повторять нельзя.
  • Под глобальной перегрузкой readiness всех реплик может стать 503 (проверка идёт через тот же пул и event loop), и LB отвечает 503 на всё. Это сброс нагрузки, но грубый. Следующий шаг — ограничение одновременных запросов на реплику ниже maxconn LB и отдельный лёгкий канал для readiness. Но рецензент требует исключать реплику с заблокированным пулом, поэтому зависимость readiness от пула сохранена сознательно.
  • X-Instance-Id = hostname контейнера: в lab7 его нужно заменить непрозрачным alias.

Учебные упрощения: HTTP без TLS (lab7), один uvicorn-воркер на контейнер (масштабирование — репликами), секреты — файлы Docker secrets на одном хосте, нет rate limiting. Ключи идемпотентности хранятся в PostgreSQL рядом с данными (так проще атомарность), очистка — пачками по расписанию.

Подтверждено измерениями: улучшение записи сообщения (серии D и E, по 3 повтора): −80 % SQL-операторов, −40 % CPU API и −55 % CPU БД на сообщение, потолок +95 % в конфигурации с упором в API и +110…124 % с упором в БД; узкое место после улучшения — снова CPU API и CPU БД соответственно. Пока гипотеза: что ограничение одновременных запросов на реплику (ниже maxconn LB) уберёт флаппинг readiness под перегрузкой; что несколько uvicorn-воркеров в одном контейнере дадут то же, что реплики того же суммарного CPU.