47 KiB
Отчёт — лабораторная 3
- Автор, группа: Лебедев Дмитрий, БВТ2302
- Целевая оценка; выбранный трек 5: 5, трек 1 «Цена масштабирования»
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ:
- библиотеки: Starlette 1.7.0, uvicorn 0.54.0, psycopg 3.2.10 + psycopg_pool 3.2.6, redis-py 5.2.1; HAProxy 3.0; генератор нагрузки — Go, только стандартная библиотека;
- документация: Docker Compose (services, deploy, networks), HAProxy 3.0 Configuration Manual (server-template, resolvers, http-check, retry-on, maxconn/queue, http-error), PostgreSQL (INSERT … ON CONFLICT, ожидание конкурентной вставки), Linux CFS bandwidth control (cpu.cfs_quota_us, nr_throttled);
- ИИ: реализация, тесты, эксперименты и этот отчёт подготовлены с помощью ИИ-ассистента Claude (Anthropic). Код других студентов не использовался.
Запуск из чистого clone
Выбранный вариант: Docker Compose + HAProxy. Prerequisites: Docker Engine 24+ с Compose v2, Python 3.9+ на хосте (тесты — только stdlib), make (Linux/macOS; для Windows — PowerShell-скрипты ниже). Свободны 127.0.0.1:8080 (API через LB), :8081 (api-ttl через LB), :8404 (статистика HAProxy).
Образы (закреплены тегами): haproxy:3.0.5-alpine, python:3.13.5-slim-bookworm (база API), postgres:16.10-alpine, redis:7.4.2-alpine, golang:1.24.7-alpine (только сборка генератора трека 1). API и генератор собираются из исходников репозитория.
./scripts/init-secrets.sh # secrets/* и .env (значения не печатаются)
docker compose --env-file .env config --quiet
docker compose --env-file .env --profile ttl up -d --build --wait # = make up
curl -si http://127.0.0.1:8080/health/ready | grep -i x-instance-id # запросы чередуются между репликами
make test BASE_URL=http://127.0.0.1:8080 # публичный smoke через LB
make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://127.0.0.1:8080
./scripts/start-replicas.sh # = make restore: вернуть остановленную реплику
make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://127.0.0.1:8080
make test-student # API/auth/ACL, идемпотентность, TTL, гонка кэша, отказы БД/Redis
make lb-experiments # уровень 4: отказ каждой реплики (SIGTERM/SIGKILL) и rolling update под нагрузкой
make track1 # трек 5.1, ≈ 1 ч; затем evidence/track1/summary.md и *.svg
./scripts/collect-evidence.sh # всё, кроме трека, с выводом в evidence/
make down # безопасно: контейнеры удаляются, volume pgdata сохраняется
make destroy-data # НАМЕРЕННОЕ удаление данных (down -v), с подтверждением
Windows (PowerShell 5.1, без make/WSL). Docker Desktop запущен, Python с python.org. Используйте 127.0.0.1, а не localhost (Windows сначала пробует ::1), команды — по одной строке (в PowerShell 5.1 нет &&):
powershell -NoProfile -ExecutionPolicy Bypass -File scripts\init-secrets.ps1
docker compose --env-file .env --profile ttl up -d --build --wait
$env:NO_PROXY = '127.0.0.1,localhost'
py -3 tests\smoke.py --base-url http://127.0.0.1:8080
py -3 tests\resilience.py --mode failover --action-script scripts\stop-one.cmd --base-url http://127.0.0.1:8080
powershell -NoProfile -ExecutionPolicy Bypass -File scripts\start-replicas.ps1
py -3 tests\resilience.py --mode persistence --action-script scripts\restart.cmd --base-url http://127.0.0.1:8080
powershell -NoProfile -ExecutionPolicy Bypass -File scripts\collect-evidence.ps1 # всё сразу; -WithTrack1 — с треком
*.cmd — обёртки над *.ps1: публичный тест запускает хук напрямую, а .ps1 Windows так не исполняет. Rolling update (scripts/rolling-update.sh) — POSIX sh: на Windows запускайте из Git Bash/WSL.
Действия оператора: только создание secrets. Миграции применяет one-shot сервис migrate до старта реплик; повторно — docker compose --env-file .env run --rm --no-deps migrate (no-op). Пароль БД записан в volume при первой инициализации — не удаляйте secrets/ при живом pgdata.
Где собраны доказательства. В среде разработки Docker daemon работал, но Docker Hub и PyPI были закрыты политикой сети. Поэтому
evidence/получены на том жеcompose.yamlс локально собранными образами-заменителями из бинарников хоста: HAProxy 3.0.0 из исходников, PostgreSQL 16.15, Redis 7.0.15, Python 3.13 с теми же библиотеками. Подмена — только полеimage/ сборка API через override-файл, не входящий в репозиторий; топология, сети, лимиты, healthcheck, хуки и конфиг HAProxy — те же. Перед защитой выполнитеmake up && ./scripts/collect-evidence.sh(Windows:scripts\collect-evidence.ps1), чтобыevidence/содержал вывод именно ваших официальных образов; тот же сценарий гоняет.github/workflows/app.yml.
Архитектура и решения
127.0.0.1:8080 / :8081 / :8404 (stats)
клиент ──HTTP──► lb: HAProxy 3.0 ──(сеть app, internal)──► api × API_REPLICAS (без ports)
│ DNS Docker: server-template api 8 api:8080 │ uvicorn, 1 процесс, пул ≤ 10
│ GET /health/ready каждые 1 с, fall 2, rise 2 │
│ maxconn 10 на реплику, очередь ≤ 2 с ▼ (сеть data, internal)
│ retry-on conn-failure + redispatch postgres:16 [pgdata] ← источник истины:
└ panic-mode: backup = те же реплики пользователи, чаты, сообщения, сессии,
ключи идемпотентности
migrate (one-shot, до реплик) ──────────────────────────────► redis:7 — кэш сессий (без persistence)
| Роль | Service | Образ | Health/readiness | Volume | Сеть/порт | Credentials |
|---|---|---|---|---|---|---|
| load_balancer | lb |
haproxy:3.0.5-alpine + infra/haproxy/haproxy.cfg |
wget /stats; бэкенды — HTTP-проверка /health/ready |
— | edge+app; 127.0.0.1:8080/8081/8404 |
— |
| api | api (deploy.replicas: ${API_REPLICAS:-2}) |
сборка Dockerfile |
python -m messenger healthcheck → /health/ready |
нет (stateless) | app+data, порты не публикуются | secrets database_url, cache_url |
| migrations | migrate (one-shot, restart: "no") |
тот же образ, command: migrate |
завершение с кодом 0 — условие старта api |
— | data | database_url |
| postgres | postgres |
postgres:16.10-alpine |
pg_isready |
pgdata |
data | POSTGRES_PASSWORD_FILE |
| redis | redis |
redis:7.4.2-alpine (user redis) |
redis-cli ping |
— (кэш) | data | requirepass из secret |
| api-ttl (тест TTL) | api-ttl, профиль ttl |
образ API, SESSION_TTL_SECONDS=2 |
как у api | — | app+data; только через LB :8081 |
как у api |
Лимиты: API — API_CPUS/API_MEMORY (по умолчанию 1 CPU / 512 MiB на реплику), LB 0.5 CPU / 128 MiB, PostgreSQL 1 CPU / 1 GiB, Redis 0.25 CPU / 128 MiB, migrate 0.5 / 256 MiB. Нет container_name — api масштабируется (--scale, deploy.replicas). Контейнер API: uid 10001, read_only, cap_drop: ALL, no-new-privileges. Сети app и data — internal: true: PostgreSQL, Redis и реплики API снаружи недоступны, единственная точка входа — LB.
Что перенесено из lab2. Весь API, PostgreSQL как источник истины, сессии (scrypt, opaque Bearer, TTL, logout), Redis-кэш сессий с outbox-инвалидацией, keyset-пагинация, тесты lab2. Что изменено в lab3:
- Stateless-реплики. Всё, от чего зависит корректность, — в PostgreSQL (сессии, ключи идемпотентности), Redis — общий кэш. Sticky sessions нет:
balance roundrobin. X-Instance-Id— случайный alias процесса (api-<8 hex>), без hostname/IP; реплика пишет его в/tmp/instance-id(tmpfs) — такstop-one.shнаходит контейнер.- Миграции отдельно и однократно: сервис
migrateвыполняется до реплик (depends_on: service_completed_successfully), подpg_advisory_lock. Реплики (MIGRATE_ON_START=false) только проверяют, что вschema_migrationsесть все известные им версии с теми же checksum, и до этого не становятся ready. Более новая схема допустима (expand-фаза следующей версии). - Общая идемпотентность
POST /chats/{id}/messages(миграция0003_idempotency_keys.sql). - Graceful shutdown под LB и panic mode HAProxy (ниже).
Идемпотентность — транзакционная граница. Одна транзакция: удалить просроченный ключ этой тройки → INSERT message … WHERE EXISTS(membership) → INSERT idempotency_keys (user, chat, key, sha256(канонический JSON), message_id) ON CONFLICT DO NOTHING. Если ключ уже есть — ROLLBACK своей вставки и чтение сохранённого результата: тот же hash → тот же 201 и то же Message (Idempotent-Replayed: true), другой → 409. Конкурентная вставка того же ключа с любой реплики ждёт на уникальном индексе COMMIT/ROLLBACK первой транзакции: после COMMIT получает конфликт, после ROLLBACK вставляет сама. Поэтому одновременные повторы через разные реплики дают ровно одно сообщение, а транзиентная ошибка (откат) ключ не занимает. Повтор заново проверяет сессию (Bearer) и членство в чате. Хеш — от канонического JSON (sort_keys, без пробелов): порядок ключей и форматирование не важны. Срок — IDEMPOTENCY_TTL_SECONDS (24 ч); очистка — фоновой задачей реплик пачками по 5000.
Health, readiness, timeouts, SIGTERM — согласованно.
| Параметр | Значение | Зачем |
|---|---|---|
| Проверка LB | GET /health/ready, inter 1s, после первой ошибки fastinter 500ms, fall 2, rise 2, timeout check 300ms |
Максимальное время обнаружения отказа ≈ 1 + 0.3 + 0.5 + 0.3 ≈ 2.1 с; возврат — 2 успешные проверки (≈ 1–2 с) |
timeout connect |
300 ms | к убитому контейнеру нет RST — ждём не дольше 300 мс, затем retry-on conn-failure + redispatch на другую реплику (повтор только если запрос ещё не отправлен — безопасно и для неидемпотентных POST) |
timeout server |
15 s | > REQUEST_TIMEOUT_SECONDS = 10 с приложения |
| SIGTERM в реплике | 3 с drain (SHUTDOWN_DRAIN_SECONDS): /health/ready = 503, ответы с Connection: close, запросы ещё обслуживаются; затем listener закрывается, запросы в полёте завершаются (≤ 10 с); 2-й сигнал — немедленный выход |
drain (3 с) > худшего времени обнаружения LB (≈ 2.1 с) — LB выводит реплику до закрытия listener |
stop_grace_period |
15 s | drain + завершение запросов в полёте |
| uvicorn keep-alive | 30 s (> idle-пула HAProxy) | соединение первым закрывает LB, а не реплика |
maxconn на реплику / timeout queue |
10 / 2 s | ограничение конкуренции: излишек ждёт в очереди LB, а не в event loop (обоснование — трек 5.1) |
| DNS | resolvers docker (127.0.0.11), hold obsolete 5s |
новые/удалённые реплики (--scale, rolling update) подхватываются без перезапуска LB |
depends_on/healthcheck Compose лишь упорядочивают старт и показывают состояние контейнера, но не распределяют трафик и не исключают больной backend из маршрута. Это делает HAProxy своими проверками.
Panic mode. Если readiness не проходит ни у одной реплики (например, упала БД), LB всё равно отправляет запросы в живые процессы (backup-слоты на те же адреса, option allbackups, resolve-opts allow-dup-ip). Клиент получает ответы приложения: анониму 401, бизнес-запросам 503 unavailable в формате API, /health/live = 200. Без этого LB отвечал бы безликим 503 на всё. Мёртвый процесс в backup-слоте даёт conn-failure и 503 LB.
Ответы, созданные LB (нет живых реплик, 502/504, /internal/* → 404), — в формате ошибок API с request_id = X-Request-Id (uuid). X-Instance-Id у них нет, контракт это допускает. Расширения API описаны в contracts/EXTENSIONS.md.
Соответствие переменных .env.example. APP_HOST/APP_PORT — адрес uvicorn (0.0.0.0:8080); SESSION_TTL_SECONDS — срок сессии; DATABASE_URL_FILE/CACHE_URL_FILE — /run/secrets/*; SESSION_STORE=postgres — источник истины сессий; API_REPLICAS → deploy.replicas; IDEMPOTENCY_TTL_SECONDS → срок ключа. Дополнительно: API_PORT, API_TTL_PORT, LB_STATS_PORT, API_CPUS, API_MEMORY, PG_CPUS, PG_MAX_CONNECTIONS, SESSION_CACHE, SESSION_CACHE_TTL_SECONDS, DB_POOL_MAX, KDF_CONCURRENCY, SHUTDOWN_DRAIN_SECONDS, LB_SERVER_MAXCONN, LB_QUEUE_TIMEOUT (см. комментарии в .env.example и compose.yaml).
Rolling update и миграции. scripts/rolling-update.sh: собрать образ новой версии (APP_VERSION → label и env); один раз применить миграции (run --rm migrate); для каждой старой реплики поднять одну новую (--scale N+1 --no-recreate), дождаться healthy, остановить старую SIGTERM-ом (drain) и удалить. Число готовых реплик не опускается ниже N. Ограничение: миграции обязаны быть expand-only (добавлять, не ломая работающую версию: новые таблицы/nullable-колонки/индексы). Удаление и переименование делаются отдельным релизом (contract) после того, как старых реплик не осталось. Скрипт это не проверяет: это дисциплина разработки, проверенная демонстрацией ниже.
Доказательства критериев
Все файлы — в evidence/. Стенд описан в примечании выше; версии и контейнеры — evidence/stack.txt (2 vCPU Intel Xeon 2.8 GHz, 8 GiB RAM, Docker 29.9.2, Compose 5.6.1). Прогон с пустого volume pgdata.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
|---|---|---|---|
| Публичный smoke через LB | tests/smoke.py --base-url http://127.0.0.1:8080 |
PASS: lab3 public API scenario |
smoke.txt |
| 3: стенд одной командой; ≥2 реплики, одна точка входа, общие БД и сессии | docker compose --profile ttl up -d --build --wait |
lb (единственный с портами), api-1, api-2, migrate (exit 0), postgres, redis, api-ttl — healthy |
stack.txt |
| 3: разные запросы одной сессии — разные реплики, без повторного входа | 6 запросов через LB; smoke/тесты с одним токеном | X-Instance-Id чередуется api-0ac6…/api-ea54…; 10 повторов POST с одним токеном обслужены 2 репликами |
instances.txt, test-idempotency.txt |
| 3: остановка любой реплики; чтение/запись ≤ 10 с; подтверждённые сообщения целы | tests/resilience.py --mode failover --action-script scripts/stop-one.sh ×2 + start-replicas.sh |
PASS дважды: ≥2 реплики до отказа, 0 неудачных попыток из 138–139 записей; first_recovery_seconds 4.7–4.8 (это время работы хука docker stop, записи не прерывались); остановленный контейнер (status=exited) в failover-hook.txt |
failover-1.txt, failover-2.txt, failover-hook.txt, restore-*.txt |
| 3: повтор POST с тем же ключом без дублей, в т. ч. конкурентно и через другую реплику | student-tests/test_idempotency.py |
30 одновременных POST одного ключа: 14 + 16 ответов от двух реплик, одно тело, 1 строка; 2 разных тела на один ключ: 1 сообщение, 10×201 + 10×409; повторы с другой реплики; 400 на неверный ключ; неуспешный запрос ключ не занимает; повтор после logout — 401; ключ старше 24 ч переиспользуется | test-idempotency.txt |
| 3: неподтверждённую запись можно повторить с тем же ключом | failover-тест (повтор неопределённого POST тем же ключом), серия отказов (повтор после 502/таймаута) | дублей текста 0, потерянных подтверждённых 0 во всех прогонах | failover-*.txt, lb/failover-series.json |
| 3: persistence | tests/resilience.py --mode persistence --action-script scripts/restart.sh |
PASS тем же токеном; новые StartedAt/PID у LB, обеих реплик, PostgreSQL, Redis; volume сохранён |
persistence.txt, restart-hook.txt |
| 3: миграции отдельно, однократно, повтор без дублей | пустой volume → сервис migrate; run --rm migrate |
applied: [0001, 0002, 0003] один раз; повтор — applied: []; реплики логируют schema compatible; replica ready |
migrations.txt, migrations-rerun.txt |
| Сохранены возможности lab2 | test_api.py (auth, ACL, валидация, пагинация, rollback, гонка регистрации), test_expiry.py (через LB :8081), test_cache_race, test_failures.py |
18/18, 3/3, all passed, 2/2 | test-api.txt, test-expiry.txt, test-cache-race.txt, test-failures.txt |
| 4: health/readiness/timeouts/SIGTERM согласованы; LB исключает недоступный backend | таблица выше; серия отказов SIGTERM | после SIGTERM реплика получает последний запрос через 0.95–1.53 с, ошибок 0 | lb/failover-series.json |
| 4: последовательно остановить каждую реплику; RPS, ошибки, время восстановления | research/lb_experiments.py failover-series --mode both |
таблица ниже: SIGTERM — 0 ошибок; SIGKILL — 5–8 ответов 502 за ≤ 0.1 с; восстановление — 5.6–6.0 с до healthy | lb/failover-series.json, lb-failover-series.txt |
| 4: идемпотентность параллельными запросами с одним ключом | см. уровень 3 | 30 параллельных → 1 сообщение | test-idempotency.txt |
4: CPU/RAM-лимиты; API без портов; нет container_name |
compose.yaml |
у всех сервисов deploy.resources.limits; у api нет ports, сети app/data internal |
compose.yaml, stack.txt |
| 4: rolling update под нагрузкой; миграции однократны и совместимы | research/lb_experiments.py rolling-update (3 обновления подряд), research/expand_migration_demo.sh |
0 ошибок за 27–28 с замены, образы сменились, потерь и дублей нет; новая версия без миграции не ready (missing 0004), миграция применена один раз, старые реплики остались ready |
lb/rolling-update-*.json, rolling-update.txt, lb/expand-migration.txt |
| 5, трек 1 | research/track1.py run … (15 конфигураций, ключевые ×3) + report |
см. раздел трека | track1/*.json, track1/summary.md, track1/*.svg |
| Нагрузка (профиль) | tests/load.py --duration 30 --concurrency 4 через LB |
236.8 успешных RPS, 0 ошибок, p50/p95/p99 = 15.3/30.8/47.0 мс | load.json |
Эксперименты и отказы
Последовательный отказ каждой реплики под нагрузкой (evidence/lb/failover-series.json). 8 потоков closed-loop через LB, у каждого свой пользователь: 1 POST (с ключом; при ошибке повтор тем же ключом и телом) на 3 GET истории; клиентский таймаут 2 с. Фазы: 5 с до отказа → действие → 10 с с одной репликой → docker start → 5 с. 2 реплики × 1 CPU / 512 MiB, maxconn 10.
| Воздействие | Реплика | Ошибки после действия | Последняя ошибка | Реплика ещё отвечала | Макс. пауза между записями | RPS до / во время / после | p99 до / во время, мс | До healthy после старта | Потери / дубли |
|---|---|---|---|---|---|---|---|---|---|
SIGTERM (docker stop) |
api-1 | 0 | — | 0.95 с | 0.12 с | 265 / 252 / 253 | 101 / 68 | 5.6 с | 0 / 0 |
| SIGTERM | api-2 | 0 | — | 1.53 с | 0.18 с | 279 / 220 / 242 | 83 / 89 | 6.0 с | 0 / 0 |
SIGKILL (docker kill) |
api-1 | 5 × 502 | 0.08 с | 0.04 с | 0.32 с | 296 / 187 / 237 | 93 / 310 | 5.7 с | 0 / 0 |
| SIGKILL | api-2 | 8 × 502 | 0.10 с | 0.05 с | 0.31 с | 280 / 212 / 218 | 79 / 308 | 5.7 с | 0 / 0 |
SIGTERM: реплика 3 с отвечает 503 на readiness и дообслуживает запросы, LB выводит её за ~1 с — ни одной ошибки. SIGKILL: ошибки — только запросы «в полёте» на убитом процессе (502), дальше retry-on conn-failure + redispatch и проверка (fall 2) выводят реплику. Неопределённые POST повторены тем же ключом — дублей нет. Падение RPS «во время» — работа на одной реплике (её CPU и пул). «До healthy» — старт контейнера, проверка схемы и healthcheck Docker; в маршрут LB реплика возвращается через 1.3–3.6 с после старта.
Настройка, подтверждённая измерением (до/после). Сначала стояли timeout connect 1s и проверка с таймаутом по inter (1 с). При SIGKILL к убитому контейнеру нет RST, поэтому каждая попытка соединения и каждая проверка висели по 1 с: максимальная пауза между записями — 0.99–1.06 с, p99 ≈ 1010 мс, RPS во время отказа — 142–165. После timeout connect 300ms + timeout check 300ms: пауза 0.26–0.32 с, p99 ≈ 310 мс, RPS 187–215 (сохранены evidence/lb/failover-series-connect1s.json и текущий ряд).
Rolling update под нагрузкой (evidence/lb/rolling-update-3.0.1.json, -3.0.2-expand.json, -3.0.3.json): три замены подряд — 0 ошибок из 5274–5710 запросов за 27–28 с, p99 135–173 мс, потерянных/дублированных сообщений 0; image id обеих реплик сменился (rolling-update.txt). Вторая замена несла новую expand-миграцию 0004 (lb/expand-migration.txt): контейнер новой версии до миграции остался NOT-READY с логом schema is behind … missing 0004; migrate применил её один раз; старые реплики 3.0.1 остались ready.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|---|---|---|---|
| SIGTERM одной реплики | 0 ошибок, LB выводит её до закрытия | 0 ошибок, последний запрос на неё через ≤ 1.5 с | новые запросы не прерывались; 0 потерь |
| SIGKILL одной реплики | ошибки только у запросов в полёте | 5–8 ответов 502 за ≤ 0.1 с | ≤ 0.32 с до следующей успешной записи; 0 потерь |
| Рестарт всего стенда (restart hook) | данные и токен живы | PASS | 0 потерь |
| Остановка Redis | работа через PostgreSQL | всё 2xx, /users/me за 5 мс |
outbox дообработан после старта; отозванный токен — 401 |
| Остановка PostgreSQL | ограниченный 503, аноним — 401 | 503 unavailable за 2.0 с, /health/live = 200 через panic mode LB |
ready через 2.3 с после старта БД |
| Rolling update ×3 | без ошибок | 0 ошибок | 0 потерь |
Трек 5.1. Цена масштабирования
Вопрос и гипотезы. Что даёт добавление API-реплик и где предел?
- H1. При фиксированном суммарном CPU/RAM больше реплик не дают больше пропускной способности: Python-API ограничен CPU, а у каждой реплики свои накладные расходы.
- H2. При росте ресурсов пропускная способность растёт до насыщения общего ресурса, после чего новые реплики не помогают.
- H3. При перегрузке без ограничения конкуренции полезная пропускная способность не держит плато, а проваливается (congestion collapse). Ограничение
maxconnна LB это устраняет.
Методика (повторяемая): make track1 = research/track1.py run all + report.
- Стенд. Тот же
compose.yaml+research/compose.track1.yaml. Реплики API привязаны к ядруAPI_CPUSET=0, их суммарный бюджет задаётся квотойAPI_CPUS; LB, PostgreSQL, Redis и генератор — на ядреAUX_CPUSET=1. Перед каждой конфигурацией реплики и LB пересоздаются (--force-recreate), запуск только после того, как LB видит все реплики UP. - Нагрузка. Генератор
research/loadgen— Go, только stdlib, внутри сети стенда (без docker-proxy).- Модель open-loop: запросы по расписанию, задержка — от запланированного момента, без coordinated omission.
- 48 синтетических пользователей по одному чату с историей; смесь 70% GET истории (limit 50), 20% POST сообщения (уникальный ключ), 10% GET
/users/me. - Ступени 40…800 req/s по 3 с прогрева + 10 с измерения; серия останавливается после двух ступеней с > 30% ошибок.
- Метрики.
- Ёмкость при SLO: максимальная полезная пропускная способность при p99 ≤ 250 мс и ошибках ≤ 1%.
- Максимум при ошибках ≤ 1%.
- Пик полезной пропускной способности.
- Одновременно: CPU%/RAM контейнеров (
docker stats), очередь HAProxy (stats CSV), соединения и события ожидания PostgreSQL (одна сессияpsql \watch 1), доля периодов CFS с троттлингом (cpu.stat), счётчики пула psycopg в репликах до/после.
- Повторы. Ключевые конфигурации (серия A,
maxconn 10) — 3 прогона, в выводах медиана. Остальные — по 1 прогону, это отмечено.
Исходные данные: evidence/track1/<config>[-rN].json (все ступени и ресурсы), summary.md/summary.json, графики *.svg.
Серия A — фиксированный бюджет API 1 CPU / 512 MiB (scrypt-параллелизм делится так же: 4/2/1), медиана 3 прогонов:
| Конфигурация | Ёмкость при SLO, rps | Макс. при ошибках ≤ 1 %, rps | Пик, rps | CPU API при 80 rps | CFS-троттлинг при 80 rps | p99 при 80 rps |
|---|---|---|---|---|---|---|
| 1 × 1.0 CPU | 240 (280/240/240) | 280 | 280 | 28 % | 0 % | 27 мс |
| 2 × 0.5 CPU | 200 (120/200/200) | 200 | 235 | 32 % | 6.7 % | 48 мс |
| 4 × 0.25 CPU | 160 (160/120/160) | 200 | 200 | 45 % | 4.7 % | 66 мс |
H1 подтверждена, и дробление даже вредит. Механизмы:
- Накладные расходы на реплику. На одной и той же нагрузке 80 rps суммарный CPU API растёт с 28 до 45%: у каждой реплики свои health-проверки LB (1/с), фоновые циклы (кэш, очистка), event loop и рантайм. Стоимость запроса на пике растёт с 3.2 до 4.4 мс CPU.
- Квота CFS. Реплика с квотой 0.25–0.5 ядра, выбравшая квоту за период 100 мс, замораживается до конца периода: 5–7% периодов с троттлингом уже при 80 rps и до 36% на пике. Отсюда хвост задержки при одинаковом суммарном CPU.
- RAM. У каждой реплики фиксированные ~30–45 MiB рантайма плюс по 32 MiB на одновременный scrypt. При 128 MiB на реплику и scrypt-параллелизме 4 первые прогоны получили cgroup OOM kill при регистрации пользователей (
dmesg: Memory cgroup out of memory). Дробить RAM без пересчёта параллелизма KDF нельзя.
Серия B — рост ресурсов (реплики по 0.25 ядра на изолированном ядре, 1 прогон; 4×0.25 — медиана серии A) и серия C — вся машина (2 vCPU без изоляции, общие с LB/БД/генератором, 1 прогон):
| Конфигурация | Суммарно CPU API | Пик, rps | Макс. при ошибках ≤ 1 %, rps |
|---|---|---|---|
| 1 × 0.25 | 0.25 | 84 | 80 |
| 2 × 0.25 | 0.5 | 160 | 160 |
| 3 × 0.25 | 0.75 | 178 | 160 |
| 4 × 0.25 | 1.0 | 200 | 200 |
| 1 × 1.0 (для сравнения) | 1.0 | 280 | 280 |
| 2 × 1.0, вся машина | ≤ 2 (2 vCPU хоста) | 320 | 320 |
| 4 × 1.0, вся машина | ≤ 2 | 312 | 280 |
Почему рост реплик перестаёт помогать (H2):
-
До 0.5 ядра рост почти линеен (84 → 160 rps), дальше выгода падает: 0.75 → 178, 1.0 → 200. Четыре реплики по 0.25 уступают одной реплике на целом ядре (280) по причинам серии A.
-
На всей машине 2 реплики дают +14% к одной (320 против 280), а 4 реплики — уже не лучше двух. На пике суммарная загрузка контейнеров — 159–171% из 200%, остальное съедают dockerd/containerd и сэмплер: хост насыщен.
-
CPU на запрос по компонентам (machine-2×1.0, на пике):
Компонент мс CPU/запрос API 3.5 PostgreSQL 0.6 генератор 0.5 LB 0.23 Redis 0.12 API в ~6 раз дороже PostgreSQL на запрос. Значит, на этой машине первым кончается CPU для API, а БД и LB далеки от насыщения: PostgreSQL ~20% CPU; события ожидания — почти только
CPU, изредкаIO:WALSync,pg_test_fsync0.25 мс. -
Каждая новая реплика добавляет процессы, которые конкурируют за те же 2 ядра, и пул из 10 соединений к БД: 10 → 20 → 41 соединение. Время удержания соединения на запрос (среднее по всей серии): 16 мс у 1×1.0 → 18 мс у 2×1.0 → 40 мс у 4×1.0.
-
Оценка следующего предела (экстраполяция, не измерено). При изобилии CPU для API первым насытится PostgreSQL на одном ядре — около 1 / 0.6 мс ≈ 1600 rps на этой смеси. Затем
max_connections=100при пуле 10 ограничивает число реплик ~9 (с учётом migrate и служебных соединений). Дальше нужен пул на стороне БД (PgBouncer) или меньший пул на реплику.
Насыщение пула. При 1×1.0 под перегрузкой запрос в среднем по серии ждёт свободное соединение 279–308 мс (3 прогона), а держит его 16 мс. При этом сам SQL выполняется ~1 мс: соединение «держит» корутина, которая ждёт своей очереди в перегруженном event loop. /users/me без БД (из кэша Redis) в тех же ступенях отвечает за ~25 мс, history/post — около 1 с. Ошибки — PoolTimeout/TooManyRequests пула, а не LB.
Серия P (1×1.0, по 1 прогону), пик / ёмкость при SLO:
| Пул | Пик, rps | Ёмкость при SLO, rps |
|---|---|---|
| 5 | 320 | 280 |
| 10 | 280 | 240 |
| 20 | 280 | 200 |
| 40 | 280 | 200 |
Больший пул не помогает: ограничитель — CPU event loop, а не число соединений. Меньший пул лишь ограничивает конкуренцию. Это подводит к улучшению.
Подтверждённое улучшение: ограничение конкуренции на LB (maxconn 10 на реплику, timeout queue 2s) — 1×1.0 CPU, пул 10, медиана 3 прогонов каждого варианта:
| Поданная нагрузка | Без лимита: полезная / ошибки / p50 | maxconn 10: полезная / ошибки / p50 |
|---|---|---|
| 280 req/s | 280 / 0 % / 72 мс | 280 / 0 % / 12 мс |
| 320 req/s | 276 / 13.8 % / 744 мс | 320 / 0 % / 162 мс |
| 360 req/s | 277 / 22.9 % / 794 мс | 360 / 0.1 % / 1323 мс |
| 400 req/s | 253 / 36.8 % / 931 мс | 354 / 11.4 % / 1670 мс |
| 460 req/s | 223 / 51.6 % / 1103 мс | 328 / 28.7 % / 2026 мс |
| Ёмкость при SLO | 240 (280/240/240) | 280 (320/280/240) |
| Макс. при ошибках ≤ 1 % | 280 (280/280/280) | 360 (360/360/320) — +28 %, каждый из 3 прогонов выше каждого базового |
H3 подтверждена. Без лимита LB отдаёт реплике всё сразу: сотни корутин в event loop борются за CPU и 10 соединений, время удержания соединения раздувается, запросы истекают по таймауту пула. CPU тратится на работу, которую потом выбрасывают, и полезная пропускная способность падает с 280 до 223 rps. С maxconn 10 в реплике не больше 10 запросов; остальные ждут в дешёвой очереди HAProxy и при переполнении получают быстрый 503. Полезная пропускная способность держит плато 330–360 rps вместо провала.
Проверенные варианты (по 1 прогону):
| Вариант | Макс. при ошибках ≤ 1 %, rps |
|---|---|
maxconn 10, timeout queue 2s |
360 (медиана) |
maxconn 20 |
320 |
maxconn 10, timeout queue 250ms |
239: очередь 250 мс слишком коротка и отбрасывает всплески, которые иначе уложились бы |
2×0.5 с maxconn 10 |
280 (без лимита 200) |
Значения maxconn 10 и timeout queue 2s приняты по умолчанию в compose.yaml; уровни 3–4 повторно проверены уже с ними.
Ограничения измерений:
- Одна машина на 2 vCPU. Генератор, LB, БД и рантайм Docker делят её с API. Изоляция ядер снимает конкуренцию только для API.
- Абсолютные числа зависят от CPU хоста. Переносимы соотношения и механизмы, не rps.
- Ключевые конфигурации повторены 3 раза; разброс ёмкости при SLO — одна ступень (±40 rps), из-за этого шага сетки ёмкость определена с точностью до ступени. Остальные конфигурации — 1 прогон.
- Тёплый кэш, данные — тысячи сообщений: стоимость БД здесь минимальна; большие истории — в треке 5.2 lab2.
- Числа получены на локальных образах-заменителях: HAProxy 3.0.0 вместо 3.0.5, PostgreSQL 16.15 вместо 16.10, Redis 7.0 вместо 7.4, psycopg без C-расширения (pure-Python + системная libpq) вместо
psycopg[binary]. Последнее завышает CPU API на запрос: в официальном образе ожидаемы более высокие абсолютные значения. Повторитеmake track1. - Сэмплер сам потребляет CPU хоста. Первая версия с
docker execраз в секунду заметно занижала результаты и заменена одной сессиейpsql.
Ответы на вопросы защиты
- Отказ процесса vs отказ узла. Отказ процесса (SIGKILL реплики) оставляет живыми хост, сеть, Docker и остальные контейнеры: LB видит отказ соединения, перенаправляет запросы, Docker перезапускает контейнер, volume на месте. При отказе узла пропадает всё, что на нём: все реплики, LB, PostgreSQL и его диск. На одном Docker-хосте этот стенд отказ узла не выдерживает — для этого нужны другие узлы, репликация БД и переносимый LB (трек 5.2, не выбран).
- Почему depends_on/healthcheck — не балансировщик.
depends_onзадаёт только порядок старта, healthcheck Docker лишь помечает контейнер unhealthy. Ни то, ни другое не распределяет запросы, не исключает больной backend из маршрута и не повторяет запрос на другой реплике. Это делает LB: активные проверки,fall/rise,redispatch. - Какие POST можно повторять после timeout и что защищает Idempotency-Key. Без ключа повторять безопасно только то, что не создаёт новый объект, — в обязательном API таких POST нет: повтор регистрации даст 409, повтор создания чата создаст ещё один чат.
POST /messagesс тем жеIdempotency-Keyи тем же телом можно повторять сколько угодно и через любую реплику: результат первой успешной транзакции сохранён атомарно с сообщением, повтор возвращает его же, другой body — 409. LB сам повторяет только то, что не было отправлено (retry-on conn-failure). - Что сломается с сессиями в локальной памяти. Токен, выданный репликой A, будет неизвестен реплике B: при roundrobin каждый второй запрос — 401. Logout на одной реплике не отзовёт токен на другой. Рестарт или отказ реплики разлогинит её пользователей. Sticky sessions лишь маскируют проблему и ломаются при отказе реплики. Здесь сессии в PostgreSQL, Redis — общий кэш.
Ограничения и следующие шаги
- Выдерживается: остановка/убийство любой одной API-реплики (без ошибок при SIGTERM, ≤ 8 ошибок 502 при SIGKILL), рестарт всего стенда с volumes, rolling update под нагрузкой, отказ Redis, отказ PostgreSQL (ограниченные 503).
- Не выдерживается: отказ хоста; отказ единственного LB или PostgreSQL — это SPOF стенда.
scripts/stop-one.shнаходит реплику по alias черезdocker exec(файл/tmp/instance-id) — это требует работающего процесса. Убитую реплику так не найти, но этот хук останавливает живую реплику.- Публичный failover-тест сам выбирает реплику, которая обслужила запрос. Поэтому поочерёдная остановка каждой реплики показана отдельно (
lb/failover-series.json: api-1 и api-2, SIGTERM и SIGKILL). - Окно устаревания кэша сессий при сетевом разделении реплики и Redis — как в lab2 (≤
SESSION_CACHE_TTL_SECONDS). - Rolling update на Windows — только из Git Bash/WSL (скрипт POSIX sh).
evidence/получены на образах-заменителях (см. примечание в начале). Повторите./scripts/collect-evidence.shна официальных образах.