The CPU per request and the lock waiters of the placement control are taken at 4560 rps; the header now says so instead of leaving the reader to guess between the two offered rates. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
98 KiB
Отчёт — лабораторная 3
- Автор, группа: Костылев Артём, БПИ2303
- Целевая оценка: 5; трек «5» — трек 1 «Цена масштабирования»
- Commit/PR: ветка
solution/bpi2303-kostylev. Код приложения (src/,compose.yaml,Dockerfile,infra/, хуки) последний раз менялся вa59e3a3— перенос исправлений лабы 2 после её ревью (цикл2026-10-30-carry-over-lab2-review-fixes); до негоe924281— удалён комментарий# type: ignore,22f0e62— улучшение трека 1 (отправка сообщения одной командой SQL) и107fbbb— закрепление CPU для замеров (по умолчанию выключено). После22f0e62менялись такжеAGENTS.md,student-tests/, обвязка (Makefile, последний раз —b1c80ee,scripts/,tools/), openspec, отчёт иevidence/. Все доказательства уровней «3» и «4» (checks,smoke,stack,environment,schema,migrations,kdf,secrets,lb-check,hooks,failover-*,persistence,faults,limits*,detection/,failover-each/,rolling*/,student-tests) сняты на итоговом кодеb1c80ee, запуск из чистого clone — наf5fea5c(тот же код плюс эти доказательства), контрольные прогоны трека — на том же коде; послеb1c80eeменялись только openspec, отчёт иevidence/. Серии трека A и B сняты на коде до улучшения (его они и обосновывают), сравнение до/после — наedc091dпротив22f0e62. Дата и коммит — в первой строке каждого отчётаevidence/*.txt, для JSON, CSV и сырья прогонов — в индексеevidence/README.md. PR «ЛР 3 — БПИ2303 — Костылев — на 5» в репозиторий преподавателя заполняется по.github/pull_request_template.md; его ссылка появляется при публикации - Использованные источники, библиотеки и помощь ИИ: FastAPI, gunicorn + uvicorn-worker, dishka, pydantic,
structlog, asyncpg, argon2-cffi, redis-py, pytest, ruff, ty (версии —
evidence/environment.txtиuv.lock); HAProxy 3.2 Configuration Manual (health checks, resolvers,retry-on,http-error,init-state), Grafana k6 (constant-arrival-rate,handleSummary), uvicorn и gunicorn (порядок graceful shutdown), документация Docker Compose (deploy.replicas,depends_on, secrets), PostgreSQL (SELECT … FOR UPDATE,INSERT … ON CONFLICT, уровни изоляции,WITHс изменяющими данные операторами,pg_stat_activityиpg_stat_statements), IETF draft «The Idempotency-Key HTTP Header Field», N. Gunther — Universal Scalability Law. Решение перенесено из моей лабы 2 и выполнено с помощью Claude Code; код, стенд и отказы проверены прогонами, перечисленными ниже.
Запуск из чистого clone
Требуются Docker с Compose v2, make и curl; системный Python 3.9+ — только для публичных проверок и
scripts/probe.py. Образы сторонних сервисов закреплены версией и digest, API собирается из исходников.
git clone <repo> && cd mtusi2026lab3 && git checkout solution/bpi2303-kostylev
make secrets # secrets/*: пароли PostgreSQL и Valkey, DATABASE_URL, CACHE_URL, ключ курсора; .env из .env.example
docker compose --env-file .env config --quiet
make up # docker compose up -d --build --wait: postgres, valkey → migrate (миграции, один раз) → api ×2 → lb
until curl -fsS "http://$(docker compose port lb 8080)/health/ready"; do sleep 1; done # готовность через LB
scripts/lb-wait.sh 2 # обе реплики UP в статистике LB
make test # публичный smoke через балансировщик (BASE_URL — опубликованный порт lb, см. ниже)
make lb-check # ≥2 X-Instance-Id на одном токене и 20 × 8 параллельных POST с одним ключом → evidence/lb-check.json
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make restore # вернуть остановленную реплику и дождаться её в ротации LB
curl -s -o /dev/null "http://$(docker compose port lb 8080)/health/live" # сдвиг round robin: следующий прогон остановит другую реплику
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && make restore
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make migrate # повторный запуск миграций: «up to date», данные не меняются
make down # безопасная остановка: контейнеры и сети удаляются, volumes с данными остаются
make reset-data # НАМЕРЕННОЕ удаление учебных данных: docker compose down -v --remove-orphans
make secrets идемпотентен: существующие файлы не перезаписываются, значения нигде не печатаются; make up
вызывает его сам. make up ждёт healthy всех сервисов, включая балансировщик, а он здоров, только когда в
ротации есть реплика (/healthz на порту статистики). Миграции применяет одноразовый migrate под advisory lock
до старта реплик; реплики схему не трогают. Публикуются только порты lb на 127.0.0.1: LB_HTTP_PORT
(по умолчанию 8080) и LB_STATS_PORT (8404, статистика только для чтения). На машине, где выполнялась работа,
параллельно работали стенды других лаб, поэтому в локальном .env стояли LB_HTTP_PORT=18083,
LB_STATS_PORT=23083. Цели make берут BASE_URL по умолчанию из docker compose port lb 8080, то есть
работают и с изменённым LB_HTTP_PORT; без поднятого стенда — http://localhost:8080, явный BASE_URL=…
переопределяет. Цель failover-теста выбирает round robin (реплика, обслужившая первое сообщение); второй
прогон сразу после первого попадает в ту же реплику, поэтому перед ним нужен один запрос через LB (строка
curl …/health/live выше или make failover-evidence SHIFT=1).
Последний прогон из свежего clone (evidence/clean-clone.txt, коммит f5fea5c — код b1c80ee, каталог mtusi2026lab3-clean —
свой compose-проект и пустые volumes, LB_HTTP_PORT=18083, команды дословно из блока выше, без BASE_URL):
config — valid; make up — 10 с, migrate применил 0001_init и 0002_idempotency_keys и вышел с кодом 0;
smoke PASS; 40 GET одним токеном — 20 + 20 на две реплики, 160 × 201 в гонках ключа; failover обеих реплик
по очереди (второй — после одного GET через LB) — 134 и 132 записи, 0 ошибок, первая запись через 2.934 и 2.736 с,
остановлены api-1, затем api-2, каждая Exited (0); persistence PASS; повторный migrate — up to date;
make storage-evidence в клоне перечислил только volumes mtusi2026lab3-clean_*; после make down volumes
остались, после make reset-data их 0.
Собственные проверки и тулчейн:
make install # uv sync --group dev (Python 3.14 и зависимости из uv.lock)
make lint # ruff check + ruff format --check (src, student-tests, scripts/{probe,limits,scaling}.py, tools) + ty check
make student-test # собственные тесты; поднимают одноразовые PostgreSQL и Valkey того же образа в Docker
PYTEST_ADDOPTS=-vv make student-test # то же с именами тестов (так снят evidence/student-tests.txt)
make check # офлайн-проверка skeleton
make validate # полная валидация OpenAPI 3.1 и примеров (openapi-spec-validator из dev-группы .venv)
make test-faults # тесты стенда лабы 2 (Valkey, PostgreSQL, гонки) через балансировщик
make faults-evidence # то же с датой и коммитом → evidence/faults.txt (путь репозитория → <repo>)
make failover-evidence [SHIFT=1] # docker inspect реплик до/после, make test-failover, логи остановленной, restore
make persistence-evidence # persistence-тест + StartedAt всех контейнеров до и после
make stack-evidence # сервисы, порты, hostname ↔ X-Instance-Id, лимиты, сети, взгляд LB
make storage-evidence # \d+ схемы, повтор миграций, префикс KDF, правила ignore
Проверки уровня «4» — по одной команде на пункт рубрики; каждая пишет файл в evidence/ и завершается
ненулевым кодом при нарушении (make level4 — все подряд):
make limits # лимиты, порты, секреты, volumes, сети по политике → evidence/limits.txt
make lb-check # 40 GET одним токеном + 20 раундов × 8 параллельных POST с одним ключом
make detection # три прогона: SIGTERM, kill, pause, остановка PostgreSQL → evidence/detection/run{1,2,3}/
make failover-each # каждая реплика: остановка, 10 с без неё, возврат — под k6 100 rps
make rolling-update FROM_REV=8d28d45 # стенд на версии уровня «3», затем замена на текущую под нагрузкой
make rolling-update # замена текущей сборкой (эквивалентная поочерёдная замена)
Генератор нагрузки — сервис k6 под профилем bench (с make up не стартует); RATE задаёт интенсивность.
Трек 1 «Цена масштабирования» — одна команда на всё и одна на графики. База очищается (down -v) перед каждой
конфигурацией, после серий стенд возвращается к обычной конфигурации. Для отчёта серия A шла 2 ч 11 мин (с
ожиданием тишины на VM), серия B — 34 мин, сравнение — 30 мин (по полю started в summary.csv):
make track1 # снимок хоста, серия A (1x4/2x2/4x1), серия B (1x1/2x1/8x1), до/после на 8x1, контроль, графики
make track1-control # контроль: пул и maxconn на 8x1 при 5 400 rps; 8x0.5 против 4x1 на CPU 7–10
make plots # только графики и сводка потолков из готовых evidence/track1/*/summary.csv
Версии и стенд: Python 3.14.7 в образе python:3.14-slim-trixie@sha256:51dafde8…,
haproxy:3.2.26-alpine@sha256:58938405…, postgres:17.11-alpine@sha256:266d3c25…,
valkey/valkey:8.1.11-alpine@sha256:2602ace2…, grafana/k6:2.3.0@sha256:2dd4756e…, uv 0.9.7 по digest,
Docker 28.3.2, Compose 2.38.2. Машина — Apple M4 Max, 16 CPU, 48 ГБ RAM, macOS 15.1; VM Docker Desktop —
16 CPU, 7.65 ГиБ (evidence/environment.txt).
Архитектура и решения
┌── api (gunicorn, 2 × UvicornWorker) ──┐ asyncpg pool, 1–2 с
клиент ──HTTP──▶ lb (HAProxy 3.2) ───┤ X-Instance-Id = hostname ├──▶ postgres (источник истины, pgdata)
127.0.0.1:8080 round robin, └── api (gunicorn, 2 × UvicornWorker) ──┘──▶ valkey (кэш сессий, AOF, valkeydata)
httpchk /health/ready migrate (тот же образ, один раз до реплик) ──▶ postgres
сеть edge ─────── lb ─────── сеть backend (internal): lb, api, migrate, postgres, valkey
Перенесено из лабы 2 без изменения поведения: зоны identity и messaging, порты и адаптеры, UoW, шина
событий с журналом аудита, ASGI-конвейер, Basic → Bearer, Argon2id, сессии в PostgreSQL с read-through кэшем
в Valkey и отметками отзыва, подписанный курсор, порядок истории под блокировкой строки чата, миграции под
advisory lock, тесты стенда (make test-faults). Уже в лабе 2 реплика не держала в памяти ничего, от чего
зависит корректность: кэш и отметки отзыва общие (Valkey), курсор подписан общим секретом, отметка
created_at назначается под блокировкой строки чата, а не часами процесса. Изменено: один контейнер с
портом → сервис api с deploy.replicas за HAProxy; X-Instance-Id; обязательный Idempotency-Key;
миграция 0002; restart.sh перезапускает и LB; таймауты и воркеры под реплики; удалён api-shortttl
(публиковал порт API в обход LB, проверка истечения TTL осталась in-process тестом). Лаба 3 начата с коммита
8cddb09 лабы 2, а исправления лабы 2 после её ревью (8cddb09..102579e) перенесены отдельным циклом
2026-10-30-carry-over-lab2-review-fixes (a59e3a3): предел тела считает фактически принятые байты
(chunked сверх 1 MiB → 413), выход отзывает сессию через порт SessionRevocations и снимает отметку отзыва,
если PostgreSQL отверг удаление (503 значит «сессия ещё действует»), пустой cursor → 400, зоны связаны только
схемой БД, воркер сам прерывает зависший при остановке запрос (500) до SIGKILL мастера.
X-Instance-Id. PlatformSettings.instance_id по умолчанию — socket.gethostname(); Docker даёт
контейнеру hostname, равный короткому ID, поэтому значение одно на все воркеры реплики, стабильно на жизнь
контейнера и совпадает с docker ps (evidence/stack.txt). Конвейер ставит заголовок рядом с
X-Request-Id на каждый ответ, проходящий через него; ответ 500 формирует внешний ServerErrorMiddleware,
поэтому обработчик необработанных исключений ставит оба заголовка сам. INSTANCE_ID в compose не задаётся:
он был бы одинаков у всех реплик.
Идемпотентная отправка (зона messaging). Таблица idempotency_keys (chat_id, user_id, key, fingerprint, message_id, created_at), PK (chat_id, user_id, key) — область «пользователь + метод + путь чата + ключ»
(ключ бывает только у POST …/messages), FK (chat_id, user_id) → chat_members и message_id → messages,
CHECK формата ключа и длины отпечатка. После трека 1 отправка — одна команда SQL без явной транзакции
(PostgresMessageLog.post, порт MessageLog; до трека было пять обращений, три из них под блокировкой чата):
- CTE
chat: строка чатаFOR UPDATE, соединённая с членством отправителя; нет строки →404; created_at = GREATEST(часы реплики, last_message_at + 1 мкс)— история чата не идёт назад;INSERT idempotency_keys … ON CONFLICT DO UPDATE … WHEREключ истёк — живой ключ не трогается;INSERT messagesтолько если ключ записан,UPDATE chats.last_message_at; команда фиксируется сама;- ключ занят → вторая команда вне блокировки читает квитанцию, моложе
IDEMPOTENCY_TTL_SECONDS: тот же отпечаток → сохранённое сообщение (201, тот жеMessageOut,created_atс микросекундами); другой →409.
Порядок проверок отправки: сессия (401) → форма запроса: Idempotency-Key, malformed JSON, лишние поля и
типы (400, проверяет FastAPI до обработчика, чат не читается, поэтому ответ одинаков для существующего и
несуществующего чата) → доступ к чату (404) → текст (400). Текст проверяется до записи; если он невалиден,
отдельным чтением проверяется членство, чтобы посторонний получил 404, а не 400 (тесты
test_access_checked_before_body и test_request_shape_is_checked_before_access, сценарии
lab3-idempotent-messages «Порядок проверок отправки сообщения»). Сообщение и ключ фиксируются вместе или не фиксируются вовсе; маркера «в обработке»
нет, поэтому после гибели реплики посреди запроса повтор с тем же ключом создаёт сообщение один раз.
Одновременные повторы одного ключа всегда идут в один чат и ждут на блокировке его строки; дождавшийся
получает конфликт ключа, а следующая команда в READ COMMITTED видит зафиксированную квитанцию. Внешний ключ
квитанции на сообщение проверяется в конце команды, поэтому ключ можно вставить раньше сообщения. Отпечаток —
SHA-256 канонического JSON распарсенной модели, поэтому порядок полей и пробелы не важны. Ответы 4xx/5xx
ничего не пишут; lock_timeout теперь 503, а не 500. Отвергнуто: SET NX в Valkey (не атомарен с
COMMIT), отдельный маркер «processing» (залипает после отказа).
Балансировщик (infra/haproxy/haproxy.cfg):
| Параметр | Значение | Зачем |
|---|---|---|
| Обнаружение | server-template api 8 api:8080, resolvers docker (127.0.0.11), init-addr none |
остановленная реплика пропадает из DNS, новая появляется без перезапуска LB и без docker.sock |
| Алгоритм | balance roundrobin, без stick |
каждое новое соединение — следующая реплика; сессия общая, привязка не нужна |
| Проверка | GET /health/ready, inter 1s fastinter 500ms downinter 2s fall 2 rise 2, timeout check 1s, init-state fully-down |
реплика без БД или в остановке выходит из ротации; вернувшаяся получает трафик только после проверок |
| Повторы | retries 2, redispatch 1, retry-on conn-failure empty-response; disable-l7-retry всем, кроме GET и POST …/messages с ключом |
отказ соединения повторяется всегда (запрос не ушёл); после отправки — только безопасное к повтору; POST /users, /chats, вход не повторяются (contracts/README.md) |
| Соединения к API | option http-server-close |
нет простаивающих keep-alive, за которые гонится остановка реплики |
| Таймауты | connect 500ms, server 10s > REQUEST_TIMEOUT_SECONDS=8 > statement_timeout 2 с; queue 3s, maxconn 64 на сервер |
цепочка клиент > LB > приложение > БД |
| Ошибки LB | 502/503/504 — JSON {"error":{…,"request_id"}} с тем же X-Request-Id |
формат контракта даже без реплик (evidence/hooks.txt) |
X-Request-Id |
непустой входящий до 200 символов пробрасывается, иначе uuid4 | приложение эхо-возвращает его |
| Остановка | stop_signal: SIGUSR1, hard-stop-after 5s |
мягкий стоп внутри stop_grace_period 8 с |
Остановка и процессы (уровень «4»). По SIGTERM реплика сначала выходит из ротации и только потом
перестаёт принимать соединения. Каждый воркер запускает DrainingServer (наследник uvicorn.Server,
src/messenger/gunicorn_conf.py): после сигнала он поднимает флаг, /health/ready отвечает 503, /health/live
— 200, запросы обслуживаются как обычно, и так DRAIN_SECONDS=2 — дольше худшего обнаружения 503
балансировщиком (1,5 с). Затем uvicorn закрывает listener и дообрабатывает принятые запросы ещё
SHUTDOWN_TIMEOUT_SECONDS − DRAIN_SECONDS − 1 = 3 с (не меньше таймаутов БД 1 + 2 с), а запрос, не завершённый
к этому сроку, прерывает сам с 500 и выходит с кодом 0; весь срок — ≤5 с < gunicorn graceful_timeout 6 с <
docker stop -t 7 хука < stop_grace_period: 8s < 10 с, поэтому мастер gunicorn не доходит до SIGKILL воркера. Без окна (уровень «3») gunicorn закрывал listener сразу, и запрос, уже
стоявший в очереди accept, LB видел как обрыв после отправки: для GET и сообщений с ключом это повтор, для
POST /users, /chats и входа — 502. Разница видна в счётчиках LB: rolling update со старой версии —
wredis 55 (запросы, перенаправленные на соседа), с новой — все 0 (evidence/rolling*/result.json). Хук
stop-one.sh теперь идёт 2,63 с (evidence/hooks.txt). На реплику cpus: 1, 512m, 2 воркера, пул 8: 2 × 2 × 8 = 32 соединения <
max_connections=200. API работает read_only с tmpfs /tmp.
Проверки, период и максимум обнаружения. GET /health/ready раз в inter 1s; после первого провала —
fastinter 500ms; fall 2 провала — реплика исключена; rise 2 успеха — возвращена; timeout check 1s;
у DOWN-реплики — downinter 2s. Readiness пингует PostgreSQL за ≤0,8 с (0,4 с на соединение из пула и 0,4 с
на SELECT 1), то есть отвечает явным 503 раньше таймаута проверки. init-state fully-down: сервер, который
стартовал, появился через DNS или вернулся из MAINT (resolution), получает трафик только после rise 2
проверок (без этого HAProxy делал его UP/READY сразу по DNS-ответу, и запросы уходили в ещё не слушающий
gunicorn — первый прогон failover-each показал wredis 19 и 49 без ошибок; это записано в design.md
изменения 2026-10-28-add-lab3-failover-operations, сырьё того прогона заменено повторным с init-state).
| Отказ | Как замечает LB | Максимум обнаружения | Замер (make detection) |
|---|---|---|---|
SIGTERM (docker stop, stop-one.sh) |
readiness 503 в окне вывода |
inter + (fall−1)·fastinter = 1,5 с, и раньше закрытия порта (2 с) |
0,99–1,43 с; действие (docker stop -t 7) завершилось через 2,53–2,61 с |
процесс убит (docker kill) |
отказ соединения, DNS | 1,5 с | 0,47–0,54 с |
процесс завис (docker pause) |
таймаут проверки | inter + (fall−1)·fastinter + fall·timeout check = 3,5 с |
2,91–3,23 с |
| PostgreSQL остановлен | readiness всех реплик 503 |
1,5 с до 0 UP; LB сам отвечает 503 |
0,93–1,44 с; /health/live через LB → 503 unavailable без X-Instance-Id |
Замер — три прогона make detection подряд (evidence/detection/run{1,2,3}/), в таблице диапазон. Время
считается от запуска команды отказа, поэтому замер включает задержку docker CLI до сигнала и период опроса
статистики LB (50 мс) и может превысить формулу на эту величину: допуск замера — 0,25 с. На итоговом коде все 12
замеров уложились в формулу без допуска (в faults.txt остановка PostgreSQL — 0,93 с); раньше допуск
понадобился: на a02d442 у PostgreSQL в двух прогонах из трёх (1,553 и 1,551 с), при ревью — у SIGTERM (1,609 с),
на e00eb6c — у SIGTERM в failover-each (1,515 с). Возврат в ротацию после восстановления — 1,96–3,63 с.
Цепочка таймаутов (проверяется тестом student-tests/unit/test_timeouts.py по compose.yaml,
haproxy.cfg и scripts/stop-one.sh, а не только таблицей):
| Звено | Значение | Условие |
|---|---|---|
LB timeout server |
10 с | > REQUEST_TIMEOUT_SECONDS |
REQUEST_TIMEOUT_SECONDS |
8 с | > ожидание соединения + оператор БД |
DB_ACQUIRE_TIMEOUT_SECONDS + DB_COMMAND_TIMEOUT_SECONDS (statement_timeout = lock_timeout) |
1 + 2 с | ≤ дообработки после окна |
LB timeout check |
1 с | > readiness 0,8 с |
DRAIN_SECONDS |
2 с | > обнаружения 1,5 с |
дообработка после окна (uvicorn timeout_graceful_shutdown) |
SHUTDOWN − DRAIN − 1 = 3 с |
≥ таймаутов БД 1 + 2 с; затем зависший запрос → 500 |
SHUTDOWN_TIMEOUT_SECONDS (gunicorn graceful_timeout) |
6 с | > окна + дообработки; < STOP_TIMEOUT хука |
STOP_TIMEOUT хука stop-one.sh |
7 с | < stop_grace_period 8 с < 10 с |
LB timeout connect / queue |
0,5 с / 3 с | отказ соединения повторяется на соседа сразу |
LB hard-stop-after |
5 с | < stop_grace_period LB 8 с |
| клиенты: resilience / smoke / k6 | 2 / 10 / 10 с | — |
Хуки. scripts/stop-one.sh — контейнер api с .Config.Hostname == TARGET_INSTANCE_ID → docker stop -t 7,
реплика остаётся остановленной, неизвестный ID → код 3 без изменений. scripts/restart.sh — stop lb api,
restart postgres valkey, up -d --no-recreate --wait (те же контейнеры, повторный migrate), volumes не
трогаются. scripts/restore.sh — up --no-deps --no-recreate --wait api, затем scripts/lb-wait.sh ждёт, пока
статистика LB покажет все реплики UP.
Роли и сервисы (compose.yaml; сети edge и backend с internal: true):
| Роль | Сервис | Версия / digest | Health / readiness | Volume | Сеть / порт | Credentials |
|---|---|---|---|---|---|---|
| load_balancer | lb |
haproxy:3.2.26-alpine@sha256:58938405…, uid 99, read_only, cap_drop: ALL |
/healthz :8404 (nbsrv(api) ≥ 1); проверяет реплики GET /health/ready |
нет | edge + backend; 127.0.0.1:${LB_HTTP_PORT:-8080}, 127.0.0.1:${LB_STATS_PORT:-8404} |
нет |
api ×API_REPLICAS |
api |
сборка из Dockerfile, python по digest, uid 10001, read_only |
GET /health/ready (пингует PostgreSQL) |
нет | backend, порт не публикуется |
secrets database_url, cache_url, cursor_secret через *_FILE |
| postgres | postgres |
postgres:17.11-alpine@sha256:266d3c25…, uid 70, pg_stat_statements |
pg_isready |
pgdata:/var/lib/postgresql/data |
backend |
secret postgres_password через POSTGRES_PASSWORD_FILE |
| сессии (кэш) | valkey |
valkey/valkey:8.1.11-alpine@sha256:2602ace2…, uid 999 |
valkey-cli ping с паролем |
valkeydata:/data (AOF) |
backend |
secret valkey.conf (requirepass) |
| bootstrap | migrate |
образ api, restart: "no" |
код выхода 0 | нет | backend |
secret database_url |
генератор нагрузки (профиль bench) |
k6 |
grafana/k6:2.3.0@sha256:2dd4756e…, uid хоста |
нет | нет (скрипт infra/k6 только для чтения) |
только edge, порт не публикуется |
нет |
Готовность реплики зависит только от PostgreSQL: Valkey — кэш, при его отказе проверка идёт в БД. Общее
хранилище сессий — PostgreSQL (источник истины) плюс общий Valkey. Bootstrap: make secrets (идемпотентен,
не перезаписывает существующие файлы), make up (миграции — migrate под advisory lock); повтор безопасен
(make migrate → up to date). Лимиты: lb 1 CPU/128m, api 1 CPU/512m на реплику, migrate 0.5/256m,
postgres 2/1g, valkey 0.5/128m, k6 2/512m (make limits сверяет их и изоляцию с политикой).
Соответствие .env.example реальной конфигурации:
.env.example |
В решении | Комментарий |
|---|---|---|
APP_HOST, APP_PORT |
HOST, PORT |
заданы в образе (0.0.0.0:8080); снаружи — порт LB LB_HTTP_PORT |
APP_ENV |
не используется | режимов окружения нет |
SESSION_TTL_SECONDS |
SESSION_TTL_SECONDS |
по умолчанию 3600 |
DATABASE_URL_FILE |
DATABASE_URL_FILE |
любой параметр читается из <ИМЯ>_FILE |
SESSION_STORE=postgres |
фиксировано | PostgreSQL — источник истины сессий, Valkey — кэш поверх него |
CACHE_URL_FILE |
CACHE_URL_FILE |
без него кэш выключен |
API_REPLICAS |
deploy.replicas: ${API_REPLICAS:-2} |
число реплик сервиса api |
IDEMPOTENCY_TTL_SECONDS |
IDEMPOTENCY_TTL_SECONDS |
86 400; квитанция старше срока перезаписывается новым запросом |
| — | LB_HTTP_PORT, LB_STATS_PORT |
опубликованные порты LB на 127.0.0.1 |
| — | API_CPUS, API_MEMORY, WEB_CONCURRENCY, DB_POOL_MAX_SIZE, API_SERVER_MAXCONN |
размер реплики, воркеры, пул на воркер, очередь LB на сервер |
| — | PG_MAX_CONNECTIONS, PG_CPUS, PG_MEMORY, LB_CPUS |
лимиты PostgreSQL и LB |
| — | REQUEST_TIMEOUT_SECONDS, DRAIN_SECONDS, SHUTDOWN_TIMEOUT_SECONDS |
8 с, 2 с и 6 с (заданы в compose и образе) |
| — | DB_ACQUIRE_TIMEOUT_SECONDS, DB_COMMAND_TIMEOUT_SECONDS |
1 с и 2 с: ожидание соединения из пула и statement_timeout = lock_timeout |
| — | K6_CPUS, K6_MEMORY |
лимиты генератора нагрузки (профиль bench) |
| — | API_CPUSET, LB_CPUSET, PG_CPUSET, VALKEY_CPUSET, K6_CPUSET |
закрепление за CPU для трека 1; пусто — не закреплено |
| — | CURSOR_SECRET_FILE |
общий ключ подписи курсора для всех реплик |
Доказательства критериев
Все проверки через LB шли на порт 18083: цели make берут BASE_URL из docker compose port lb 8080 (см.
«Запуск»). Дата и коммит прогона — в первой строке отчёта *.txt, для JSON, CSV и сырья прогонов — в индексе
evidence/README.md.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
| Публичный smoke | make test |
PASS: lab3 public API scenario (включая replay == first, 409 на другой body, 400 без ключа, X-Instance-Id на каждом ответе); на итоговом коде — тоже PASS |
evidence/smoke.txt, evidence/clean-clone.txt, evidence/track1/after-checks.txt |
| Офлайн-контракт, OpenAPI и тулчейн | make check; make validate; make lint |
PASS: offline skeleton structure, local refs and Python syntax; PASS: full OpenAPI 3.1 and JSON Schema validation; ruff All checks passed!, 103 files already formatted, ty All checks passed! |
evidence/checks.txt |
| Запуск из чистого clone | git clone, make secrets, config --quiet, make up, ожидание /health/ready, тесты, make migrate, make down, make reset-data |
valid; make up 10 с, migrate применил 0001/0002 и Exited (0); smoke, failover обеих реплик, persistence PASS без явного BASE_URL при LB_HTTP_PORT=18083; повтор миграций up to date; после down 2 volume, после reset-data 0 |
evidence/clean-clone.txt |
3.1 Весь стенд в compose.yaml, ≥2 API, одна точка входа, общая БД и общее хранилище сессий |
make stack-evidence (config --quiet, ps, docker port реплик, docker inspect, статистика LB) |
2 контейнера api без портов (docker port пуст), порты только у lb на 127.0.0.1; container_name 0; LB видит api1 UP L7OK 200, api2 UP L7OK 200; один postgres, один valkey |
evidence/stack.txt |
3.2 Разные запросы одного пользователя — разные реплики без повторного входа, видно по X-Instance-Id |
make lb-check (40 × GET /users/me одним токеном, новые соединения) + docker inspect |
{"286766bf2b32": 20, "fa81adafcb69": 20} — ровно hostname двух контейнеров api; из чистого clone — тоже 20 + 20 |
evidence/lb-check.json, evidence/stack.txt, evidence/clean-clone.txt |
| 3.3 Остановка любой одной реплики: ≤10 с, данные доступны, ошибки измерены | make failover-evidence → make test-failover ACTION_SCRIPT=scripts/stop-one.sh, docker inspect до/после, restore; затем make failover-evidence SHIFT=1 — один GET /health/live через LB перед тестом сдвигает round robin на другую реплику |
реплика 286766bf2b32: первая запись после хука через 2.639 с от его старта, 139 записей, 0 ошибок; реплика fa81adafcb69 (прогон с SHIFT=1): 2.747 с, 138, 0; после теста exited именно target, вторая running; в логе остановленной — сигнал, окно вывода из ротации с readiness 503, закрытие и выход; PASS: failover … |
evidence/failover-286766bf2b32.txt, evidence/failover-fa81adafcb69.txt |
| 3.3 Хук останавливает только заданную реплику | scripts/stop-one.sh с hostname, с неизвестным ID и без него |
хук 2.63 с (окно вывода 2 с + остановка), код 0, target exited exit_code=0, вторая running; неизвестный ID → код 3, всё работает; без переменной → код 1 |
evidence/hooks.txt |
| 3.4 Повтор с тем же ключом не создаёт дубль; конкурентный повтор и смена реплики | make lb-check (20 раундов × 8 параллельных POST с одним ключом через LB); PYTEST_ADDOPTS=-vv make student-test; failover-тест (после ошибки — тот же ключ и текст) |
160 × 201 от обеих реплик (80 + 80); в каждом из 20 раундов тела равны, в истории 1 копия, другой body → 409; test_replay_returns_the_same_message, test_same_json_in_other_layout_is_a_replay, test_other_body_with_same_key_conflicts, test_concurrent_retries_through_two_replicas_store_one_message (8 повторов через два экземпляра приложения → одна строка ключа) — PASSED |
evidence/lb-check.json, evidence/student-tests.txt, evidence/failover-*.txt |
| 3.4 Неподтверждённую запись можно безопасно повторить | PYTEST_ADDOPTS=-vv make student-test; failover-тест сверяет историю байт-в-байт |
test_rejected_attempt_does_not_take_the_key (4xx не занимает ключ), test_expired_key_starts_over, test_replay_checks_session_and_access_again — PASSED; в истории после отказа нет дублей id/text |
evidence/student-tests.txt, evidence/failover-*.txt |
3.5 make test, persistence и failover проходят; ≥2 наблюдаемых реплики |
make test, make persistence-evidence, make test-failover … |
smoke PASS; persistence PASS, StartedAt у lb, обеих api, postgres, valkey, migrate после теста новее, ID контейнеров те же; failover observed_instances_before: 2; на итоговом коде — то же |
evidence/smoke.txt, evidence/persistence.txt, evidence/failover-*.txt, evidence/clean-clone.txt |
| Перенос lab2: схема PK/FK/UNIQUE и миграции с нуля, повтор без дублей | чистый clone (make up на пустом volume); make storage-evidence |
0001_init, 0002_idempotency_keys применены на пустом volume; \d+ всех таблиц; повтор up to date, счётчики строк до и после равны (сообщений столько же, сколько ключей: 160 и 160) |
evidence/clean-clone.txt, evidence/schema.txt, evidence/migrations.txt |
Перенос lab2: Basic только на /auth/sessions, Bearer, logout, X-User-Id игнорируется |
make test; PYTEST_ADDOPTS=-vv make student-test; make test-faults |
smoke PASS; тесты test_sessions.py, test_authentication.py, test_negative.py — PASSED; logout 204 → 401 → 401 через LB |
evidence/smoke.txt, evidence/student-tests.txt, evidence/faults.txt |
| Перенос lab2: password KDF | make storage-evidence |
$argon2id$v=19$m=19456,t=2,p=1$ у всех 28 пользователей; в sessions только 32-байтовые SHA-256 |
evidence/kdf.txt |
| Перенос lab2: секреты и volumes вне Git | git ls-files secrets .env; git check-ignore -v …; в чистом clone git status --ignored |
пусто; пути игнорируются; в clone secrets/ и .env — !! (ignored) |
evidence/secrets.txt, evidence/clean-clone.txt |
| Перенос lab2: отказы Valkey и PostgreSQL через LB | make test-faults (BASE_URL — порт lb) |
12 passed: гонка регистрации 201×1/409×49, чат с несуществующим участником 400, остановка Valkey (выход 503, затем 204) и PostgreSQL (503 за ≤0.014 с; live внутри реплики 200; LB исключил обе реплики ещё через 0.93 с и сам отвечает 503; готовность через 2.3 с), рестарт API (готовность 2.6 с), полный рестарт с выходом 204 → 401, срок сессии после рестарта не продлевается |
evidence/faults.txt |
X-Instance-Id на каждом ответе приложения |
PYTEST_ADDOPTS=-vv make student-test (test_instance.py) |
test_every_response_names_the_replica (200, 401, 404, скрытый 405 как 404, 400, 204), test_rejected_body_names_the_replica (413), test_unhandled_error_names_the_replica (500), test_replica_defaults_to_container_hostname — PASSED |
evidence/student-tests.txt, student-tests/api/test_instance.py |
| Непривилегированные процессы | make stack-evidence; снимок окружения |
api — uid 10001, lb — 99 (haproxy), postgres — 70, valkey — 999 |
evidence/stack.txt, evidence/environment.txt |
Уровень «4». Нагрузка — k6 open model из сети edge в lb:8080: 100 запросов/с постоянной
интенсивности (80 % POST сообщения с уникальным ключом, 20 % чтения первой страницы истории), 20
пользователей и 10 чатов, прогрев 10 с, замер 60–90 с; параллельно зонд шлёт сообщение каждые 0,1 с и после
ошибки повторяет тот же ключ, а опрос статистики LB 10 раз в секунду пишет число UP. Счётчики LB —
дельта за прогон по backend api: wretr (повторы), wredis (перенаправления), econ, eresp, hrsp_5xx.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
4.1 Health/readiness, таймауты и прекращение приёма при SIGTERM согласованы |
make student-test (test_timeouts.py, test_drain.py, вывод -s) |
цепочка: LB server 10 с > запрос 8 с > БД 3 с; readiness 0,8 с < check 1 с; окно 2 с > обнаружение 1,5 с; дообработка 3 с ≥ БД 3 с; остановка 6 с < хук 7 с < stop_grace_period 8 с; настоящий gunicorn по SIGTERM (в тесте окно 1 с, срок 3 с): ready/live (503, 200) в окне, порт закрыт через 1.18 с, запрос, принятый до сигнала и дописанный после закрытия порта, получил 201, запрос, тело которого так и не пришло, прерван с 500, выход через 2.62 с |
evidence/student-tests.txt, compose.yaml, infra/haproxy/haproxy.cfg, src/messenger/gunicorn_conf.py |
| 4.1 LB исключает недоступный backend; период проверок и максимум обнаружения | make detection (три прогона) |
период 1 с (0,5 с после провала), fall 2/rise 2; заявлено ≤1,5 с (503/отказ соединения) и ≤3,5 с (зависание), допуск замера 0,25 с; измерено (min–max трёх прогонов): SIGTERM 1.004–1.325 с — раньше конца остановки (2.446–2.634 с), kill 0.218–0.757 с, pause 3.013–3.045 с, PostgreSQL 1.269–1.553 с до 0 UP и 503 unavailable от LB; возврат 1.92–3.04 с; все 12 pass: true |
evidence/detection/run{1,2,3}/{sigterm,kill,pause,postgres}.json |
| 4.2 Последовательно остановить каждую реплику (с восстановлением предыдущей); RPS, ошибки, время восстановления | make failover-each (на реплику: stop-one.sh, docker compose ps -a реплик, 10 с без неё, restore.sh — всё внутри окна нагрузки) |
286766bf2b32: 100.0 rps, 6000 запросов k6, ошибок 0, p50/p95/p99 2.04/6.56/13.68 мс, обнаружение 0.926 с, возврат в ротацию через 14.932 с от начала действия (действие 15.23 с: хук + 10 с + restore), зонд 655 попыток / 0 ошибок, пока реплика исключена, её X-Instance-Id не встречался (128 ответов только от fa81adafcb69); fa81adafcb69: 100.02 rps, 6001, 0 ошибок, 2.10/6.46/14.16 мс, 1.065 с, 14.587 с, 655/0; в action.txt сразу после хука — Exited (0) у остановленной и Up (healthy) у второй; счётчики LB wretr/wredis/econ/eresp/hrsp_5xx — 0. Обнаружение ≤1,5 с без допуска (на e00eb6c было 1.515 с — в пределах допуска замера 0,25 с на docker CLI и опрос, см. make detection) |
evidence/failover-each/summary.json, evidence/failover-each/<hostname>/ |
| 4.2 Общая идемпотентность — параллельными запросами с одним ключом | make lb-check |
20 раундов × 8: 160 × 201 от двух реплик, 20/20 раундов с одинаковыми телами, одной копией и 409 на другой body; на итоговом коде — то же |
evidence/lb-check.json, evidence/clean-clone.txt, evidence/track1/after-checks.txt |
4.3 CPU/RAM-лимиты, API без портов в обход LB, секреты и хранилища только где нужно, нет container_name |
make limits (docker compose --profile bench config + docker inspect против политики в scripts/limits.py) на итоговом коде |
лимиты у всех 6 сервисов (api 1/512MiB, lb 1/128MiB, postgres 2/1024MiB, valkey 0.5/128MiB, migrate 0.5/256MiB, k6 2/512MiB) и применены у запущенных; порты только у lb на 127.0.0.1; секреты: api — 3, migrate — database_url, postgres — пароль, valkey — конфиг, lb и k6 — нет; volumes pgdata/valkeydata только у своих хранилищ; backend internal, k6 только в edge; api и lb read_only; PASS. Подмешанные нарушения (порт и лишний секрет у api, container_name, снятый лимит) → 5 нарушений, код 1 |
evidence/limits.txt, evidence/limits-violations.txt |
| 4.4 Rolling update под нагрузкой | make rolling-update FROM_REV=8d28d45 (стенд на образе уровня «3» с тегом mtusi-messenger:8d28d45, затем замена на текущую версию с запасом +1) |
lb_up_min 2 из 2, k6 100 rps, 8996 запросов, ошибок 0 (5 итераций k6 сброшены), зонд 934/0; после замены отвечают только новые контейнеры (e2d392075b96, bc58bf60e518 → c84bddf582a8, 225f56282b82; образ 84c47c47ad8a → cb0dac56ff0b); старые реплики без окна дали wredis 55 — запросы, перенаправленные LB на соседа |
evidence/rolling-from-8d28d45/result.json, action.txt |
| 4.4 То же на текущей версии | make rolling-update |
lb_up_min 2, 9001 запрос, ошибок 0, зонд 942/0, все реплики новые (c84bddf582a8, 225f56282b82 → 89953d9764bd, 1f35898d8b4e); все счётчики LB 0. Образ пересобран из той же ревизии, ID другой (cb0dac56ff0b → c23101d9a13d): BuildKit пишет при сборке новый манифест с аттестацией (exporting attestation manifest в clean-clone.txt) — это эквивалентная поочерёдная замена |
evidence/rolling/result.json, action.txt |
| 4.4 Миграции однократно и совместимы с работающей версией | scripts/rolling-update.sh; make storage-evidence |
migrate запускается один раз до замены первой реплики (migration.completed up to date), реплики схему не трогают, migrate под pg_advisory_lock; между уровнями «3» и «4» схема не менялась; 0002_idempotency_keys только добавляет таблицу, код лабы 2 её не замечает |
evidence/rolling*/action.txt, evidence/migrations.txt |
Трек 1 «Цена масштабирования». Подробности, таблицы и выводы — в разделе трека ниже; поля CSV —
evidence/track1/README.md.
| Критерий трека | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
| Гипотеза и повторяемая методика | openspec/changes/archive/2026-10-29-add-lab3-scaling-cost/proposal.md (коммит d8d551a); make track1 |
гипотезы H1–H3 записаны в предложении до первого прогона серий; серии, сравнение и графики — одной командой; снимок хоста и версий | evidence/track1/host.txt, evidence/track1/README.md |
| 1/2/4 реплики при фиксированном суммарном CPU/RAM | make track1-a (4 CPU / 2 GiB, воркеров = CPU, пул 32 и очередь LB 128 во всех вариантах, CPU 7–10 закреплены) |
пик успешных RPS: 1×4 — 5 375, 2×2 — 4 964, 4×1 — 4 724; потолок по SLO у всех 4 560 rps, но p95 там 9 / 69 / 150 мс | evidence/track1/series-a/summary.csv, plots/series-a-*.png, plots/capacity.md |
| Серия с ростом ресурсов | make track1-b (1→2→4→8 реплик по 1 CPU) |
пик 1 720 → 2 936 → 4 724 → 4 260: восемь реплик хуже четырёх; USL σ = 0,014, κ = 0,038, максимум около 5 реплик | evidence/track1/series-b/summary.csv, plots/scaling.png, plots/capacity.md |
| Saturation point БД/LB/пула и почему реплики перестают помогать | метрики каждого прогона: docker stats, HAProxy CSV, pg_stat_activity, pg_stat_statements |
на 8×1: API 473 из 800 %, LB 40 % ядра, PostgreSQL 178 из 200 %, 47,5 из 64 соединений ждут блокировку строки чата, 6,8 — idle in transaction, SELECT … FOR UPDATE чата — ≈14,1 мс в среднем (13,6–14,4) и 98,7 % времени топ-20 операторов. Контроль (make track1-control, 3 повтора): maxconn LB 16/32/64 — пик 4 526 / 4 677 / 4 525 rps, интервалы перекрываются (LB не ограничивает); пул 4/8/16 на воркер — 5 358 / 4 677 / 3 789 rps при 14,7 / 47 / 102 ждущих блокировку (пул не мал, а лишние соединения только добавляют конкурентов); 8×0,5 на CPU 4×1 — пик 5 525 против 5 928 (число процессов, а не другие ядра) |
evidence/track1/series-b/summary.csv, series-b/base-8x1_rate5400_rep*/pg_statements.csv, plots/utilisation.png, track1/control-{pool,cpus}/summary.csv, plots/capacity.md |
| Графики и сырые данные | make plots |
RPS и p95/p99 от нагрузки, CPU по компонентам, пик от CPU с USL, загрузка звеньев на пике, сводка потолков; сырьё каждого прогона — k6, docker stats, HAProxy CSV, pg_stat_activity, pg_stat_statements |
evidence/track1/plots/, evidence/track1/<серия>/<прогон>/ |
| Одно подтверждённое улучшение (до/после при тех же ресурсах) | make track1-compare (8×1, образ edc091d против текущего, чередование по повторам) |
запись сообщения одной командой: при 3 600 rps p95 64,5 → 3,7 мс, CPU на запрос API −14 %, PostgreSQL −26 %; пик 4 252 → 4 894 rps (+15 %), интервалы повторов не пересекаются | evidence/track1/compare/summary.csv, plots/compare-*.png |
| Улучшение не ломает уровни «3» и «4» | сразу после улучшения: make student-test, make test, 20 гонок ключа, make test-failover, make test-persistence; на итоговом коде b1c80ee — весь уровень «3», make test-faults и make level4 под k6 |
после улучшения: 240 passed, smoke PASS, 160 × 201, failover 131 запись / 0 ошибок, persistence PASS; на итоговом коде — 243 passed, 12 тестов стенда и все строки 3.x и 4.x выше (detection ×3, failover-each, оба rolling update — 0 ошибок под 100 rps), чистый clone |
evidence/track1/after-checks.txt, evidence/clean-clone.txt, файлы строк 3.x–4.x |
Эксперименты и отказы
Стенд: 2 реплики × (1 CPU, 512 MiB, 2 воркера), PostgreSQL 2 CPU / 1 GiB, HAProxy 1 CPU / 128 MiB, Valkey
0.5 CPU / 128 MiB, k6 2 CPU / 512 MiB; Docker Desktop на Apple M4 Max. Нагрузка в failover-тесте — один клиент,
POST каждые 0.1 с в течение 15 с, таймаут 2 с, повтор после ошибки с тем же ключом; в строках уровня «4» —
k6 100 rps плюс зонд (см. выше). Данные синтетические: каждый прогон создаёт своих пользователей и чаты.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|---|---|---|---|
stop api#1 (stop-one.sh, 286766bf2b32) |
запись продолжается ≤10 с, target больше не отвечает | 0 неудачных попыток, 139 записей; после теста 286766bf2b32 exited, fa81adafcb69 running (failover-286766bf2b32.txt) |
первая запись после хука через 2.639 с от его старта (хук ≈2,6 с из-за окна вывода; запись не прерывалась); потерь и дублей нет |
stop api#2 (после restore и одного запроса через LB — SHIFT=1, fa81adafcb69) |
то же для второй реплики | 0 неудачных попыток, 138 записей; fa81adafcb69 exited (failover-fa81adafcb69.txt) |
2.747 с; потерь и дублей нет |
Полный restart (restart.sh: lb, api ×2, postgres, valkey) |
прежний токен работает, история побайтно та же | persistence PASS; ID контейнеров прежние, StartedAt всех обновился: postgres, valkey, lb — 23:44:29, api — 23:44:30–31 при старте прогона в 23:44:25 (persistence.txt) |
потерь нет; в чистом clone — то же (clean-clone.txt) |
| Конкурентный одинаковый ключ (20 раундов × 8 POST через LB) | в каждом раунде одно сообщение, все ответы равны | 160 × 201, 80 + 80 по репликам, 20/20 раундов с 1 копией, другой body → 409 (lb-check.json) |
дублей нет |
| Все реплики остановлены | LB отвечает 503 в формате контракта |
503 {"error":{"code":"unavailable",…,"request_id":"no-replica-1"}} (hooks.txt) |
после make restore — 200 |
docker compose stop postgres |
реплики выходят из ротации, ответы 503, а не 500 |
503 за ≤0.014 с на ready, me, login, register; live внутри реплики 200; LB исключил обе реплики через 0.93 с (faults.txt) и 0.93–1.44 с (detection/run*/postgres.json) и отвечает 503 сам |
после start готовность через 2.3 с без рестарта API; в ротации через 2.48–2.65 с |
docker compose stop valkey |
проверка сессий через PostgreSQL, без анонимного доступа | действующий токен 200, неизвестный 401, выход 503 (faults.txt) |
после start выход 204 |
Повторный migrate |
схема и данные не меняются | up to date, счётчики равны (migrations.txt, clean-clone.txt) |
— |
SIGTERM реплике (docker stop -t 7) |
LB исключает её раньше, чем она закроет порт | исключена через 0.99–1.43 с, остановка завершилась через 2.53–2.61 с (detection/run*/sigterm.json); код выхода 0, в логе — окно 2 с и readiness 503 (hooks.txt, failover-*.txt) |
возврат после restore 1.96–3.63 с |
Процесс реплики убит (docker kill) |
исключение ≤1,5 с | 0.47–0.54 с (detection/run*/kill.json) |
restore 2.65–3.05 с |
Процесс реплики завис (docker pause) |
исключение ≤3,5 с по таймауту проверки | 2.91–3.23 с; через LB — 200 от соседа (detection/run*/pause.json) |
после unpause 2.37–2.86 с |
| Поочерёдная остановка каждой реплики под 100 rps | 0 ошибок, запись не прерывается, реплика возвращается | обе реплики: k6 0 ошибок из 6000 и 6001, зонд 0 из 655 и 655, p99 13.7 и 14.2 мс, повторов LB 0 (failover-each/summary.json) |
обнаружение 0.93–1.07 с; снова в ротации через 14.59–14.93 с от начала действия (хук + 10 с без реплики + restore) |
| Rolling update с уровня «3» под 100 rps | ёмкость не ниже 2, 0 ошибок, после — только новые реплики | lb_up_min 2, 0 ошибок из 8996, зонд 0 из 934; старые реплики без окна: wredis 55 |
замена двух реплик за 7.062 с |
| Rolling update текущей версии под 100 rps | то же, и без повторов LB | lb_up_min 2, 0 ошибок из 9001, зонд 0 из 942, все счётчики LB 0 |
12.010 с |
Трек 5 — трек 1 «Цена масштабирования»
Гипотезы (записаны в предложении до первого прогона). H1: при фиксированном бюджете API 4 CPU / 2 GiB
конфигурации 1×4, 2×2 и 4×1 дают одинаковый потолок в пределах ±15 %: упор — суммарный CPU интерпретатора, а
4×1 хуже по p99 из-за мелкой квоты CFS. H2: с 1 CPU на реплику пропускная способность растёт почти линейно до
4 реплик (≥3,2× от одной), от 4 к 8 — меньше чем в 1,5 раза, потому что насыщается общий PostgreSQL: блокировка
строки горячего чата (SELECT … FOR UPDATE держится три обращения к БД) и CPU у лимита; LB не узкое место.
H3: мера против найденного узкого места даёт ≥15 % потолка или вдвое меньший p95 при той же нагрузке и тех
же ресурсах.
Методика (make track1; scripts/scaling.py, сэмплеры scripts/{docker,lb,pg}-stats.sh, графики
tools/plot_track1.py, сценарий нагрузки infra/k6/messages.js):
- Стенд: Apple M4 Max, VM Docker Desktop 16 CPU / 7,65 ГиБ, Docker 28.3.2; образы — по digest (
host.txt). Каждый компонент закреплён за своими CPU (cpuset): PostgreSQL 0–1 (2 CPU, 1 GiB,max_connections=200), HAProxy 2 (1 CPU, 128 MiB), Valkey 3 (0,5 CPU), k6 4–6 (3 CPU, 1 GiB), реплики API — с 7-го ровно R×C CPU. - Конфигурация
R×C: R реплик по C CPU, воркеров gunicorn = C, пул asyncpg 8 на воркер,maxconnLB 32 на воркер. В серии A у всех вариантов одни и те же CPU 7–10, 2048/R MiB на реплику, 32 соединения с БД и 128 одновременных запросов к API — сравниваются реплики, а не очереди. В серии B — 1 CPU, 512 MiB, 1 воркер на реплику; точка 4×1 общая с серией A. - Нагрузка: k6
constant-arrival-rate(открытая модель, без coordinated omission) из сетиedgeвlb:8080, профиль уровня «4»: 80 %POSTсообщения с уникальнымIdempotency-Key, 20 % чтения первой страницы истории, на прогон 20 новых пользователей и 10 чатов. Прогрев 10 с, замер 30 с, метрики только по окну замера. Интенсивности — геометрическая сетка ×1,5 от 150 rps на CPU (A) и 450 rps на CPU (B), пока два шага подряд не насыщены во всех повторах или следующий шаг не превысит верхнюю границу сетки — 8 000 rps в серии A (--search 1.5:8000по умолчанию) и 9 000 rps в серии B. В серии A все три конфигурации насыщены только на 6 830 rps: следующий шаг 10 245 rps выше границы, и сетка остановилась на одном насыщенном шаге. Контрольные прогоны идут на заданных интенсивностях без сетки. 3 повтора на точку: в итоговых таблицах 123 прогона (63 + 42 + 18), 9,6 млн запросов, и 27 контрольных (15 + 12), 3,8 млн. - Набор данных: перед каждой конфигурацией
down -v, затем база растёт от прогона к прогону; размер в каждой строке (db_mb,messages— перед прогоном): 7,7 МБ в начале конфигурации, до 1 019 МБ и 2,1 млн сообщений перед последним прогоном серии A, 497 МБ и 1,0 млн — серии B, 1,77 ГБ и 3,7 млн — сравнения. - Насыщение шага: ошибок > 1 %, сброшенных итераций > 1 % или p95 > 500 мс; интенсивность насыщена, если насыщено большинство повторов. Потолок по SLO — наибольшая ненасыщенная интенсивность (грубо, шаг ×1,5), пик — наибольшая медиана успешных RPS (в открытой модели при перегрузке это и есть пропускная способность).
- Сырьё прогона: итог k6,
docker statsи счётчики/proc/statвсей VM, HAProxy CSV иpg_stat_activityраз в секунду, топ-20pg_stat_statements. Соседние стенды других лаб на той же VM мешали (сборки образов, тесты с контейнерами): прогон, где CPU VM вне контейнеров стенда больше одного ядра, сэмплы прерывались дольше 10 с или k6 шёл на 90 с дольше нагрузки, пишется вdisturbed.csvи повторяется после 15 с тишины, до трёх раз (серия A — 12 отбраковок, B — 0, сравнение — 13, контроль пула — 24, контроль размещения — 0). Семь шагов остались возмущёнными и после трёх повторов и вошли в таблицы с пометкойdisturbed: серия A 4×1 при 3 040 rps, повтор 2 (чужой CPU 138 %), сравнение «после» при 5 400 и 8 100 rps, повтор 1 (105 и 136 %), контроль пула — пул 8 и 16 в повторе 1,maxconn16 и 64 в повторе 2 (177–453 %), в контроле это нижние значения своих интервалов. Первая попытка серии A прервана: сборка образа соседней лабы остановила Docker API почти на 16 мин между прогонами, а CPU API на запрос вырос до 3,8 мс против 0,7–0,9 у соседних прогонов (2×2 при 1 350 rps — 410 % CPU;aborted/series-a-1-summary.csv).
Серия A — фиксированный бюджет 4 CPU / 2 GiB (медиана 3 повторов, в скобках min–max; «на пике» — при 6 830 rps):
| Конфигурация | p95 при 3 040 / 4 560 rps, мс | Потолок по SLO, rps | Пик успешных RPS | CPU API на запрос при 3 040 rps | Память API на пике | На пике: CPU API / PostgreSQL / LB, % ядра | На пике: ждут блокировку / idle in transaction из 32 |
|---|---|---|---|---|---|---|---|
| 1×4 | 2,9 / 9,3 | 4 560 | 5 375 (5 332–5 384) | 0,70 мс | 367 МиБ | 378 / 178 / 42 | 15,7 / 6,2 |
| 2×2 | 4,5 / 68,8 | 4 560 | 4 964 (4 894–5 104) | 0,80 мс | 2 × 214 МиБ | 379 / 173 / 41 | 16,0 / 6,9 |
| 4×1 | 35,0 / 150,3 | 4 560 | 4 724 (4 686–4 794) | 0,93 мс | 4 × 133 МиБ | 381 / 164 / 40 | 15,3 / 6,8 |
Серия B — рост ресурсов (1 CPU, 512 MiB, 1 воркер на реплику):
| Конфигурация | Потолок по SLO, rps | Пик успешных RPS | Ускорение к 1×1 | Эффективность на CPU | На пике: CPU API / лимит | CPU PostgreSQL / 200 | CPU LB | Ждут блокировку / idle in transaction / пул |
Очередь LB |
|---|---|---|---|---|---|---|---|---|---|
| 1×1 | 1 520 | 1 720 (1 674–1 722) | 1,00 | 100 % | 102 / 100 | 47 | 13 | 0,2 / 3,4 / 8 | 968 |
| 2×1 | 2 020 | 2 936 (2 868–2 998) | 1,71 | 85 % | 201 / 200 | 94 | 23 | 2,4 / 6,3 / 16 | 936 |
| 4×1 (из A) | 4 560 | 4 724 (4 686–4 794) | 2,75 | 69 % | 381 / 400 | 164 | 40 | 15,3 / 6,8 / 32 | 872 |
| 8×1 | ≥3 600 (первая точка сетки) | 4 260 (4 217–4 424) | 2,48 | 31 % | 473 / 800 | 178 | 40 | 47,5 / 6,8 / 64 | 744 |
Ошибок нет ни в одном прогоне таблиц (доля неуспешных ≤ 0,02 %): перегрузка проявляется как очередь в LB
(до 1 000 одновременных сессий — предел VU k6), рост задержки и сброшенные итерации, а не как 5xx, — таймауты
lock_timeout 2 с и timeout queue 3 с не достигались. Генератор нагрузки не был узким местом: k6 ≤ 84 % из
300 %, Valkey ≤ 12 % ядра. Память: API 116–374 МиБ на контейнер, PostgreSQL до 661 МиБ, k6 до 675 МиБ.
USL по пикам серии B (N = 1, 2, 4, 8 CPU): σ = 0,014 (последовательная доля), κ = 0,038 (стоимость
согласования), максимум при N* = √((1−σ)/κ) ≈ 5 реплик, дальше — спад (plots/scaling.png, plots/capacity.md).
Точка насыщения и почему реплики перестают помогать. До двух реплик упор — CPU API (100 % лимита),
PostgreSQL загружен наполовину. С четырёх реплик API, PostgreSQL и блокировки упираются почти одновременно, а
на восьми ресурсы простаивают: у API свободно 40 % CPU, у LB — 60 % ядра, у PostgreSQL — 11 %, и всё же пик
ниже, чем у четырёх реплик. Насыщена критическая секция записи в чат: в профиле 10 чатов, запись в чат
сериализуется блокировкой его строки, поэтому одновременно идут не больше 10 записей, а остальные транзакции
держат соединения пула и ждут (pg_stat_activity: 47,5 из 64 соединений в Lock: tuple/transactionid, пул
исчерпан — свободных 6). SELECT … FOR UPDATE чата длится в среднем ≈14,1 мс (13,6 / 14,2 / 14,4 по повторам) и занимает 98,7 % суммарного
времени топ-20 операторов (pg_statements.csv трёх повторов 8×1 при 5 400 rps), и около 7 соединений стоят
idle in transaction: держатель блокировки ждёт, пока event loop реплики отправит следующий оператор. Каждая новая реплика добавляет пул из 8 соединений и параллельных
писателей в те же 10 строк — больше ожидающих, больше пробуждений и переключений в PostgreSQL, длиннее очередь
event loop у держателей, а последовательная часть не уменьшается: это и есть рост κ по USL. LB (40 % ядра)
и пул — не причина, это проверено контрольными прогонами ниже. Серия A
добавляет вторую цену дробления: CPU API на запрос растёт с числом процессов-реплик (0,70 мс у 1×4, 0,93 у 4×1
при 3 040 rps; 1,1–1,2 у 8×1 против 0,6–0,8 у 1×1), память — тоже (367 МиБ одной репликой против 4 × 133 =
532 МиБ четырьмя).
Контрольные прогоны (make track1-control, итоговый код b1c80ee; меняется один ресурс при прочих равных,
варианты чередуются по повторам, 3 повтора, * — прогон остался disturbed после трёх повторов). Первая часть —
8×1 при 5 400 rps (за коленом) с пулом 4/8/16 соединений на воркер и очередью LB maxconn 16/32/64 на реплику:
| Вариант 8×1 | Успешные RPS, медиана (min–max) | p95, мс | Ждут блокировку / соединений с БД | Очередь LB, max | CPU API / PostgreSQL, % |
|---|---|---|---|---|---|
| пул 4 | 5 358 (5 316–5 394) | 179 | 14,7 / 32 | 739 | 517 / 163 |
пул 8, maxconn 32 (как в серии B) |
4 677 (3 749*–4 966) | 273 | 47,0 / 64 | 744 | 471 / 170 |
| пул 16 | 3 789 (2 291*–4 077) | 355 | 102,3 / 128 | 744 | 372 / 180 |
maxconn 16 |
4 526 (3 776*–4 917) | 258 | 47,3 / 64 | 872 | 424 / 177 |
maxconn 64 |
4 525 (4 005*–4 908) | 299 | 46,8 / 64 | 487 | 442 / 178 |
Очередь LB пик не меняет: при maxconn 16, 32 и 64 медианы 4 526 / 4 677 / 4 525 rps, интервалы перекрываются,
меняется только то, где ждут запросы (в очереди LB или в соединениях реплики). Пул меняет пик, но в обратную
сторону: чем он меньше, тем выше пропускная способность — 4 соединения на воркер дают 5 358 rps (интервал не
пересекается с пулом 8), 16 — 3 789. Число ждущих блокировку растёт вместе с пулом (14,7 → 47,0 → 102,3), а
запись в чат длится дольше (среднее время команды записи 1,7–3,2 → 12,2–15,6 → 35–47 мс, pg_statements.csv):
пул не ограничивает сверху, а, наоборот, впускает в PostgreSQL больше конкурентов за строку чата. Это прямое
подтверждение, что цена — согласование писателей одной строки (κ), а не нехватка соединений или LB; маленький пул
работает как admission control — второе возможное улучшение, в трек как основное не взято (выбрано до контроля).
Вторая часть отделяет число процессов от размещения: 4×1 и 8×0,5 на одних и тех же CPU 7–10 (столько же vCPU, что у 4×1, столько же процессов и соединений, что у 8×1):
| Конфигурация, CPU 7–10 | 4 560 rps: успешные RPS / p95 / p99, мс | 4 560 rps: CPU API на запрос | 4 560 rps: ждут блокировку / соединений | Пик при 6 830 rps, медиана (min–max) |
|---|---|---|---|---|
| 4×1 | 4 560 / 32 / 65 | 0,75 мс | 1,4 / 32 | 5 928 (5 894–5 950) |
| 8×0,5 | 4 560 / 61 / 109 | 0,86 мс | 4,2 / 64 | 5 525 (5 482–5 583) |
На тех же ядрах восемь процессов дают на 7 % меньший пик (интервалы не пересекаются), на 15 % дороже запрос по
CPU и вдвое больший p95 ниже колена. Значит, ретроградность 8×1 объясняется числом процессов и соединений, а не
тем, что CPU 11–14 медленнее: в прогонах того же часа 8×1 с пулом 4 (те же 32 соединения, что у 4×1) даёт
5 358 rps против 5 928 у 4×1 — цена процессов, а с пулом 8 (64 соединения) — 4 677 — плюс цена ожидающих.
Первая попытка этой части отброшена: в четырёх прогонах 4×1 команда записи замедлилась до 7–34 мс
(IO: WalSync, aborted/control-cpus-1-*.csv) при чужой нагрузке на CPU ниже порога отбраковки — она такое не ловит;
повтор сразу после дал 0,2–0,6 мс и вошёл в таблицу.
Улучшение: запись сообщения одной командой SQL (выбрано по узкому месту серии B; обоснование и отвергнутые
варианты — design.md изменения 2026-10-29-add-lab3-scaling-cost). Блокировка строки чата, проверка участия, отметка времени, ключ и сообщение —
одна команда с неявной транзакцией, без обращений к приложению под блокировкой (раздел «Идемпотентная отправка»
выше). Сравнение — make track1-compare: 8×1, те же ресурсы и профиль, образ «до» из edc091d, варианты
чередуются по повторам, по 3 повтора:
| Нагрузка | Вариант | Успешные RPS | p50 / p95 / p99, мс | CPU API / PostgreSQL, % | CPU на запрос API / PG, мс | Ждут блокировку / idle in transaction / ждут LWLock (WAL) |
|---|---|---|---|---|---|---|
| 3 600 | до | 3 596 (3 568–3 596) | 2,4 / 64,5 (35,7–142,5) / 122 | 457 / 137 | 1,27 / 0,38 | 12,8 / 4,5 / 1,5 |
| 3 600 | после | 3 600 (3 600–3 600) | 1,7 / 3,7 (2,8–5,4) / 12,6 | 391 / 102 | 1,09 / 0,28 | 0,15 / 0 / 1,9 |
| 5 400 | до | 4 252 (4 054–4 396) | 227 / 296 / 349 | 475 / 178 | — | 46,6 / 7,0 / 2,3 |
| 5 400 | после | 4 894 (4 494–5 104) | 198 / 246 / 278 | 479 / 179 | — | 46,4 / 0 / 8,5 |
| 8 100 | до | 4 104 (4 001–4 448) | 236 / 311 / 364 | 475 / 178 | — | 47,1 / 7,3 / 1,9 |
| 8 100 | после | 4 841 (4 618–5 046) | 202 / 254 / 287 | 462 / 174 | — | 46,3 / 0 / 9,2 |
Ниже колена (3 600 rps) p95 уменьшился в 17 раз, p99 — почти в 10, разброс повторов исчез; CPU API на запрос
−14 %, PostgreSQL −26 % (меньше операторов и обращений). За коленом пик вырос на 15 % (при 8 100 rps — на 18 %),
интервалы повторов «до» и «после» не пересекаются. При насыщении соединений idle in transaction больше нет,
но пул по-прежнему занят ждущими блокировку: теперь держатель ждёт не приложение, а сброс WAL при фиксации
(ожидания LWLock, почти все — WALWrite, 8,5–9,2 против 1,9–2,3 «до»; pg_activity.csv), а CPU PostgreSQL —
89 %. Нижние значения варианта «после» за коленом (4 494 и 4 618 rps) — как раз возмущённые прогоны (см.
методику): вывод они не усиливают, а ослабляют. Проверки уровней «3» и «4» на новом коде проходят
(after-checks.txt, clean-clone.txt), а на итоговом коде повторён весь уровень «4» под k6 (строки 4.x).
Выводы.
- H1 подтверждена частично. Потолки 1×4, 2×2 и 4×1 действительно в пределах ±15 % (4 724–5 375, −12 % у 4×1), но различие систематическое и больше разброса: чем мельче реплики, тем дороже запрос по CPU (+33 % у 4×1) и памяти, и тем раньше растёт хвост (p95 при 4 560 rps — 9, 69 и 150 мс). Упор на пике — не только CPU API (95 %): у всех трёх половина соединений ждёт блокировку чата. При фиксированном бюджете выгоднее меньше реплик покрупнее, а число реплик определяется отказоустойчивостью (≥2), а не скоростью.
- H2 опровергнута в части линейного роста и CPU БД, подтверждена в части 4→8. Гипотеза ждала ≥3,2× на 4
репликах и CPU PostgreSQL у лимита; измерено 2,75× (линейный рост — только до двух реплик, 1,71× на 2 CPU) и
CPU PostgreSQL 89 % (178 из 200). Рост 4→8 действительно меньше 1,5×, и даже отрицательный: 8 реплик дают
меньше, чем 4 (2,48×) — ретроградное масштабирование, κ > 0, максимум около 5 реплик. Насыщенное звено —
общая БД, но не её CPU и не
max_connections(64 из 200), а сериализованная по строке чата запись, растянутая обращениями к приложению; размер очереди LB и пула пик не ограничивает (контрольные прогоны). Отдельно проверено, что ретроградность — от числа процессов и соединений, а не от размещения на других vCPU. - H3 подтверждена. Укорочение критической секции до одной команды дало +15 % пика при тех же ресурсах и в
17 раз меньший p95 ниже колена. Следующий потолок — фиксация под блокировкой горячей строки (WAL) и CPU
PostgreSQL: его сдвигают только больше чатов в профиле,
synchronous_commit = off(ценой подтверждённых, но потерянных при сбое сообщений) или более быстрый диск и больше CPU для БД — новые реплики API не помогут.
Ограничения трека. Один host: k6, LB, API и PostgreSQL делят VM Docker Desktop, закрепление CPU разводит
их по vCPU, но не по физическим ядрам (у M4 Max ядра двух типов), поэтому абсолютные RPS — свойство этой машины,
сравнимы только конфигурации внутри одного прогона. Эффект числа процессов отделён от размещения контролем на
одних CPU 7–10; насколько сами CPU 11–14 медленнее 7–10, отдельно не измерялось. Соседние стенды других лаб работали всё время замеров;
отбраковка ловит нагрузку больше одного ядра, меньшая остаётся шумом (host-others.csv), а задержки дисковой
подсистемы VM не ловит вовсе (отброшенная первая попытка контроля размещения). CFS-квоты дают
троттлинг мелких реплик; гипотеза, что из-за него 4×1 дороже по CPU, не проверялась счётчиками cpu.stat.
docker stats даёт точку раз в 4–6 с, pg_stat_activity — раз в секунду, это выборка, а не трасса.
Профиль с 10 чатами нарочно горячий; с тысячами чатов узким местом стали бы CPU API и PostgreSQL, и кривая
серии B была бы ближе к линейной. Сетка ×1,5 делает потолок по SLO грубым, поэтому сравнение идёт по пику.
maxVUs k6 ограничен 1 000, поэтому при перегрузке растут сброшенные итерации, а очередь в LB упирается в
1 000. Порт-форвардинг Docker Desktop в замеры не входит — k6 бьёт в lb изнутри сети. База растёт внутри
конфигурации (до 1 ГБ в серии A), поэтому старшие интенсивности идут на большей базе, чем младшие. Сравнение
до/после сделано на одной конфигурации 8×1; третий повтор «после» снят отдельным запуском после сбоя
compose up (evidence/track1/README.md). compose up --wait на восьми репликах при смене варианта изредка
проходит только со второй попытки (оркестратор повторяет его через 30 с). Причина видна в полном выводе
(control-pool/compose-up-failed.log, оба раза при переходе на пул 16): смена переменных пересоздаёт все реплики
сразу, балансировщик на это время остаётся без готовых серверов, его healthcheck (nbsrv(api) ≥ 1, 3 провала по
2 с) помечает lb как unhealthy, и --wait завершается ошибкой; через 30 с реплики готовы и повтор проходит.
На обычный стенд это не влияет: make up и rolling update не пересоздают все реплики разом.
Ответы на вопросы защиты
Чем отказ процесса отличается от отказа узла? Отказ процесса — это одна реплика: контейнер остановлен,
убит или завис, а host, LB, PostgreSQL и соседняя реплика работают. Его ловит проверка готовности LB, и
трафик уходит на соседа: SIGTERM — 1,0–1,4 с, kill — 0,5 с, зависание (docker pause) — 2,9–3,2 с по таймауту
проверки (evidence/detection/), запись не прерывается (failover-each: 0 ошибок под 100 rps). Отказ узла
забирает всё, что на нём запущено, сразу: здесь узел один, поэтому вместе с репликами пропадают LB, PostgreSQL,
Valkey и volumes — отказ всего стенда, и никакая реплика его не переживёт. Кроме того, мёртвый узел не отвечает
RST и не закрывает соединения: обнаружение идёт только по таймаутам, как в сценарии pause, а не по отказу
соединения, как при kill. Защита от потери узла — несколько узлов и реплицированные LB и БД (трек 2) — в эту
работу не входит.
Почему depends_on/healthcheck сами по себе не являются балансировщиком? depends_on упорядочивает
только запуск: migrate ждёт healthy PostgreSQL, api — успешного завершения migrate и старта Valkey, один
раз, при up, и дальше ни на что не влияет. healthcheck лишь меняет статус контейнера в docker ps: у api он раз в 5 с с 3 повторами, то есть
unhealthy наступает через десяток секунд, и Compose ничего не делает с трафиком — встроенный DNS Docker
отдаёт адрес работающего контейнера независимо от его здоровья. Нет единой точки входа, распределения запросов,
повторов отказавшего соединения на соседа, мягкого вывода из ротации и ответа 503 в формате контракта, когда
готовых реплик нет. Всё это делает HAProxy: активная проверка /health/ready раз в 1 с с fall 2/rise 2,
round robin, retry-on conn-failure и redispatch. Пример — остановка PostgreSQL: контейнеры api продолжают
работать, а LB исключает обе реплики за 0,9–1,4 с и сам отвечает 503 unavailable (detection/run*/postgres.json).
Какие POST можно повторять после timeout и что защищает Idempotency-Key? Только POST /api/v1/chats/{chat_id}/messages с тем же Idempotency-Key и тем же телом. Сообщение и квитанция ключа
фиксируются одной командой, поэтому повтор после таймаута, обрыва или гибели реплики посреди запроса либо
находит квитанцию и получает тот же 201 с тем же Message, либо, если исходная запись не зафиксировалась,
создаёт сообщение один раз. Одновременные повторы через разные реплики сериализуются блокировкой строки чата:
160 × 201 и одна копия в каждом из 20 раундов (lb-check.json); failover-тест повторяет запись с тем же ключом
после ошибки, и в истории нет дублей (failover-*.txt). Ключ не защищает от другого тела с тем же ключом
(409), от повтора через 24 ч и больше (IDEMPOTENCY_TTL_SECONDS, ключ начинается заново) и не отменяет
проверку сессии и доступа при повторе (401/404). POST /users, POST /chats и POST /auth/sessions
ключа не имеют: повтор после таймаута может создать второй чат или вторую сессию, поэтому их не повторяют ни
клиент, ни LB — в HAProxy disable-l7-retry для всего, кроме GET и сообщений с ключом; отказ соединения
повторяется для всех, потому что запрос до реплики не дошёл.
Что сломается при увеличении числа API, если сессии находятся в локальной памяти? При round robin без
привязки токен, выданный репликой A, неизвестен остальным: при N репликах доля 401 на действующий токен —
около (N−1)/N, и проверка «разные реплики без повторного входа» не проходит. Выход на реплике A не отзывает
токен на B — отозванная сессия продолжает работать. Остановка или рестарт реплики теряют её сессии, и failover и
persistence с прежним токеном падают. Sticky-сессии лишь маскируют это: при отказе реплики клиенты всё равно
теряют вход, а нагрузка распределяется неравномерно. Здесь сессии хранятся в PostgreSQL (только SHA-256
токена) с общим кэшем и отметками отзыва в Valkey: 40 запросов одним токеном — 20 + 20 по репликам
(lb-check.json), выход 204 → 401 → 401 через LB (faults.txt), прежний токен живёт после рестарта всего
стенда (persistence.txt). То же относится к ключам идемпотентности: в памяти реплики повтор через соседа
создал бы дубль.
Ограничения и следующие шаги
- Один Docker-host: потеря host, LB или PostgreSQL — отказ всего стенда. LB и БД — единственные точки отказа; их резервирование вне рамок лабы.
- Цель failover-теста выбирает round robin (кто обслужил первое сообщение); второй прогон сразу после первого
и
make restoreпопадает в ту же реплику, поэтому перед ним нужен один запрос через LB:make failover-evidence SHIFT=1илиcurl -s -o /dev/null "http://$(docker compose port lb 8080)/health/live"передmake test-failover(так снятыfailover-fa81adafcb69.txtи второй failover вclean-clone.txt). X-Instance-Idраскрывает короткий ID контейнера — допустимо до лабы 7, где появится непрозрачный alias.- Таблица ключей растёт вместе с историей (строка на сообщение); истёкшие ключи только перезаписываются при повторном использовании, фоновой очистки нет.
- Запись в один горячий чат сериализуется блокировкой строки чата; повтор с ключом берёт ту же блокировку. После трека 1 блокировка держится одну команду SQL, но фиксация (сброс WAL) остаётся внутри неё — это следующий потолок для горячих чатов (раздел трека).
- Окно вывода из ротации удлиняет каждую остановку реплики на 2 с; оно рассчитано на проверки LB раз в
секунду: при большем
interокно нужно увеличить (это ловитtest_timeouts.py). - Время обнаружения измерено тремя прогонами на сценарий; верхняя граница — формула по параметрам проверки.
Замер считается от запуска команды отказа и включает задержку docker CLI и период опроса статистики LB, поэтому
может превысить формулу на эту величину; допуск замера — 0,25 с. На итоговом коде все замеры в пределах
формулы, раньше превышение в пределах допуска было у PostgreSQL (1,553 с),
SIGTERM(1,609 и 1,515 с). - Rolling update проверен со сменой кода без смены схемы. Миграция, несовместимая с работающей версией (удаление или переименование столбца), потребовала бы двух выпусков expand/contract; в лабе таких нет.
scripts/rolling-update.shиrestore.shиспользуют--no-recreate: после замены с другимAPI_IMAGEобычныйmake upпересоздаст реплики под текущий конфиг — это ожидаемо.- Секреты лежат файлами в
secrets/на хосте (каталог0700, файлы0644, чтобы их читали непривилегированные пользователи контейнеров); это учебное упрощение вместо менеджера секретов. - Трек 1: подтверждено одно улучшение (запись одной командой, +15 % пика, p95 в 17 раз ниже колена); гипотезы
о троттлинге CFS как причине дорогих мелких реплик и о росте с числом чатов не проверялись. Переход отправки
на одну команду убрал агрегат
Chatиз записи: правила участия и порядка теперь в SQL адаптера и держатся интеграционными тестами.