Files
mtusi2026lab3/REPORT.md
T
Alexey BodanyukandClaude Opus 5.5 b9f1ad58f9 bench: трек 1 — профили py-spy до/после, серия E (потолок нового пути), графики
Профиль при 240 req/s: доля psycopg 52.7 % -> 19.0 %, активных сэмплов
3889 -> 2026. Серия E: function в 2x1.0 CPU — потолок 552 (530–552)
успешных/с, упор в CPU API; в 3x1.0 / БД 0.5 — ~420–460, упор в БД.
analyze.py: линии без заливки, цвет = конфигурация, пунктир = multi,
подпись — максимум серии. REPORT: раздел трека 1 и ограничения.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-19 17:33:46 +03:00

45 KiB
Raw Blame History

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

  • Автор, группа: Боданюк Алексей, БВТ2302
  • Целевая оценка: 5, трек 1 «Цена масштабирования»
  • Ветка: solution/bvt2302-bodanyuk. Форк: <URL форка>. 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 <URL форка> 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, 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: сначала миграция новым образом, затем замена реплик).
  • Сети. 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

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

⟨EVIDENCE_TABLE⟩

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

Замечания преподавателя к 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)

⟨LEVEL4⟩

Трек 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 с. Запросы, попавшие на неё раньше, ждут клиентский таймаут: в серии было 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.