Профиль при 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>
45 KiB
Отчёт — лабораторная 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) и internaldata(api, migrate, postgres, valkey): LB не видит хранилища, у хранилищ нет выхода наружу. Secrets — каждому сервису только свои (проверяется тестом поdocker compose config). - Дефект, найденный на lab3-сценарии рецензента. Если одной реплике отключить сеть
data, по дедлайну задача psycopg отменялась, psycopg слал cancel-запрос, а libpqPQcancelStartсинхронно резолвит имя хоста в потоке 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.
Гипотезы
- Один процесс Python (uvicorn, 1 воркер) исполняет байткод на одном ядре (GIL). Поэтому при фиксированном суммарном CPU одна «толстая» реплика упрётся в одно ядро, а несколько «тонких» используют весь бюджет. Дробить сильнее, чем по ядру на процесс, бесполезно.
- Реплики API без состояния масштабируют пропускную способность линейно, пока не насытится общий ресурс — PostgreSQL (одна БД на все реплики). После этого добавление реплик не помогает, и потолок задаёт CPU БД. Если дать БД больше CPU, потолок сдвинется — это проверка причины, а не совпадения.
- LB (HAProxy) и пул соединений не являются узким местом на этих нагрузках: HAProxy тратит единицы процентов ядра на сотни запросов/с.
- Улучшение: основная цена запроса — накладные расходы на каждый 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-loopconstant-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 на всё. Это сброс нагрузки, но грубый. Следующий шаг — ограничение одновременных запросов на реплику ниже
maxconnLB и отдельный лёгкий канал для 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.