62 KiB
Отчёт — лабораторная 3
- Автор, группа: Владимирцева, БВТ2301
- Целевая оценка 5; выбранный трек 5: 1 «Цена масштабирования»
- Commit/PR: TODO после публикации (ветка
solution/bvt2301-vladimirceva) - Использованные источники, библиотеки и помощь ИИ: раздел 8 в конце отчёта
Состояние отчёта: уровень 3 и все проверки уровня 4, включая отказ
каждой реплики и поочерёдную замену под нагрузкой, сняты
(разделы 3–4, файлы evidence/). Серии трека 1 выполняются по
bench/RUNBOOK.md; их места помечены TODO (Codex).
Гипотезы и прогнозы раздела 4 записаны до этих замеров.
1. Запуск и демонстрация
Нужны Docker Compose (Docker Desktop), make и uv. API — Python 3.13.15;
PostgreSQL 18.6, Valkey 9.1.2, HAProxy 3.4.6. Образы закреплены тегом с
патч-версией и digest индекса в Dockerfile и
compose.yaml, зависимости — uv.lock и
requirements.txt с хешами.
В .env.example добавлены реальные переменные Compose и запуска с хоста:
имена базы и пользователя, пустые строки паролей, порты и таймаут остановки.
make env заполняет пароли случайными значениями и сохраняет уже существующий
.env. Исправленный bootstrap проверен 15 октября на Apple M4;
вывод. Локальный процесс по умолчанию слушает
127.0.0.1, контейнер — 0.0.0.0 внутри сети Compose.
make install # uv sync
make env # .env со случайными паролями (в git нет)
make up # postgres, valkey → migrate → api × 2 → haproxy
make test # публичный smoke через LB
make instances # одна сессия на разных репликах (X-Instance-Id)
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make replicas # вернуть остановленную реплику
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-isolated # всё выше на отдельном чистом стенде (~50 с)
make failure-checks # проверки отказов (~55 с)
make rolling-update # поочерёдная замена без простоя
make up ждёт готовности хранилищ, успешного завершения миграций
(сервис migrate), готовности реплик и HAProxy. Единственная точка
входа API — HAProxy на 127.0.0.1:${HOST_PORT} (8080). Число реплик —
API_REPLICAS (2), разово — make replicas API_REPLICAS=3.
Сценарий защиты (README.md):
make up,make instances— ≥ 2 разныхX-Instance-Idу запросов одной сессии (пример).make test-failover ACTION_SCRIPT=scripts/stop-one.sh STOP_ONE_LOG=/tmp/stop-one.log— запись во время отказа, повтор с исходным ключом, без дублей.docker compose psи строка/tmp/stop-one.log: остановлен именно контейнер с ID изTARGET_INSTANCE_ID.make replicas, затем то же для второй реплики. Обе реплики по очереди,stopиkill—make failover-each [STOP_MODE=kill](вывод).make test-persistence ACTION_SCRIPT=scripts/restart.sh: рестарт LB, реплик, PostgreSQL и Valkey с сохранением volume, тот же токен. Для уровней 4 и 5 — метки стендаbench/(раздел 4).
Остановка: make stop (контейнеры остаются), make down (контейнеры
удаляются, volume pgdata остаётся). Удаление учебных данных — make wipe, только после ввода yes.
2. Архитектура и решения
клиент → 127.0.0.1:HOST_PORT → HAProxy ─┬→ api-1 ─┬→ PostgreSQL (данные, сессии, ключи идемпотентности)
└→ api-2 ─┴→ Valkey (кэш карточек чатов)
migrate (один раз на up и на замену, до реплик) → PostgreSQL
Перенесено из лабы 2 без изменений поведения: REST API, слои HTTP → сервисы → хранилище (SQLAlchemy Core + asyncpg), PostgreSQL как источник истины, Basic → Bearer-сессии (Argon2id, SHA-256 токена, TTL), кэш карточек в Valkey с обходом при отказе, 503 при недоступной БД, ограниченные пул и сроки, собственные тесты и проверки отказов.
Изменено в лабе 3:
| Что | Как |
|---|---|
| Реплики | сервис api × API_REPLICAS без портов и container_name; в памяти процесса нет ничего, от чего зависит корректность |
| Точка входа | HAProxy 3.4: round-robin без sticky session, реплики через DNS Docker, активная проверка /health/ready, повтор только при отказе соединения |
X-Instance-Id |
в каждом ответе API (в том числе ошибки, health, 404, 405, 500); hostname контейнера — начало его ID |
Idempotency-Key |
обязателен при отправке сообщения; ключ и сообщение — одна транзакция PostgreSQL (ниже) |
| Миграции | однократно сервисом migrate, только расширение схемы: ревизия 0002 — таблица ключей |
| Остановка | ранний обработчик SIGTERM до импорта приложения, согласованная цепочка таймаутов (ниже) |
| Поочерёдная замена | scripts/rolling-update.sh: миграции один раз, затем по одной реплике через drain в LB |
| Лимиты | CPU/RAM у всех контейнеров; секреты — только сервисам, которым нужны |
Почему HAProxy, а не Nginx, Traefik или Swarm. Нужны активные
проверки готовности, видимость новых и пропавших реплик без
перезагрузки и управляемый вывод реплики из балансировки при замене.
HAProxy даёт всё это штатно: server-template + resolvers (DNS
Docker), option httpchk, runtime API (drain/maint/ready) и
статистику слотов. Бесплатный Nginx активных проверок не имеет, Traefik
решает это через метки Docker и сокет демона (лишний доступ), Swarm
меняет весь способ запуска стенда (stack.yaml, registry для образа).
Compose + HAProxy — один make up и один хост.
Идемпотентность отправки
Таблица idempotency_keys: первичный ключ (автор, чат, ключ) — область
из контракта (пользователь + метод + путь чата + ключ; ключ принимает
одна ручка); SHA-256 канонического JSON тела; message_id; время
захвата; внешний ключ (chat_id, автор) → chat_members; ссылка на
сообщение DEFERRABLE INITIALLY DEFERRED. Отправка — одна транзакция:
- захват ключа одним
INSERT … ON CONFLICT DO UPDATE … WHERE created_at < now − TTL RETURNING: новый или просроченный ключ — захвачен, иначе — занят, строка заблокирована до конца транзакции; - захвачен — вставка сообщения с этим
message_id, commit (ссылка проверяется при commit) → 201; - занят — чтение сохранённого: тот же хэш → тот же
Message(201), другой → 409conflict.
Одновременные запросы с одним ключом через разные реплики ждут друг
друга на уникальном индексе: второй после commit первого видит его
строку и отдаёт повтор. Сбой до commit (отказ БД, ошибка вставки
сообщения) откатывает и ключ, и сообщение: транзиентная ошибка
результатом не фиксируется, повтор с тем же ключом безопасен. Повтор
заново проходит проверку сессии и членства. Порядок кодов: 401 → 400
(ключ и тело) → 404 → 409. Хэш строится из разобранных полей: пробелы и
\u-экранирование не делают тело «другим». TTL ключа —
IDEMPOTENCY_TTL_SECONDS (86400 = 24 ч, контракт). Ключ в журнал и
текст ошибки не попадает.
Реплики, проверки и цепочка таймаутов
| Звено | Значение | Почему |
|---|---|---|
| Проверка LB | GET /health/ready раз в 1 с, после неудачи — 0,5 с; fall 2, rise 2; timeout check 2,5 с |
/health/live не годится: живой процесс без PostgreSQL запросы не обслуживает |
| Худшее обнаружение отказа | зависшая реплика 6,5 с; пропавший адрес (kill) 2,5 с; закрытый сокет (stop) 1,5 с |
≤ 10 с из рубрики; формула — inter + timeout check + (fall − 1) × (fastinter + timeout check) |
| Возврат реплики в LB | ≤ 1,5 с после готовности; новый слот начинает DOWN (init-state down) |
запросы не идут на процесс, который ещё не слушает порт |
timeout connect, retries, redispatch |
0,5 с, 2, на другую реплику; повтор только conn-failure |
0,5 × 3 = 1,5 с < 2 с таймаута клиента tests/resilience.py; запрос, дошедший до реплики, не повторяется (POST не идемпотентны) |
timeout server |
10 с | > срок операции хранилища 6 с + закрытие соединения 2 с |
| Готовность внутри реплики | SELECT 1 за 2 с |
< timeout check 2,5 с: медленная БД — 503 реплики, а не таймаут проверки |
| Keep-alive | LB 10 с (http-reuse never) < реплика 60 с |
простаивающее соединение закрывает LB, а не реплика: нет 502 на гонке закрытия |
| Остановка | SHUTDOWN_TIMEOUT 5 с < stop_grace_period 10 с; stop-one.sh — docker stop --timeout 9 |
graceful успевает до SIGKILL, hook возвращается раньше 10 с |
| Старт | ранний обработчик SIGTERM до импорта приложения | docker stop стартующей реплики — 0,10 с, код 0 (evidence) |
Лимиты, пулы и порты
| Сервис | CPU | Память | Порт на хосте | Секреты |
|---|---|---|---|---|
| api × 2 | 1 | 512 МиБ | нет | пароли PostgreSQL и Valkey |
| haproxy | 1 | 256 МиБ | 127.0.0.1:HOST_PORT |
нет |
| postgres | 2 | 1 ГиБ | 127.0.0.1:POSTGRES_HOST_PORT (для make run) |
свой |
| valkey | 0,5 | 128 МиБ | 127.0.0.1:VALKEY_HOST_PORT (для make run) |
свой |
| migrate | 0,5 | 256 МиБ | нет | пароль PostgreSQL |
Кандидат H4 в текущем коде: пул 10 без переполнения. Соединения
PostgreSQL: 2 × 10 + migrate = 21 ≤ max_connections 100; при замене
на пике три реплики — 31. В исходной версии экспериментов пул 10 + 5
давал соответственно 31 и 46 соединений. Реплики,
migrate и LB: read-only файловая система, cap_drop: ALL,
no-new-privileges. Проверено: стенд и лимиты.
Миграции и совместимость
Миграции выполняет одноразовый сервис migrate до старта реплик;
реплики их не запускают. Повторный запуск — no-op. При поочерёдной
замене миграции — один раз, на новом образе, до первой новой реплики;
пересоздаётся контейнер самого сервиса migrate (иначе restart.sh
позже запускал бы старый образ на новой схеме). Ревизии только
расширяют схему (0002 — новая таблица), поэтому реплики прежней версии
работают на новой схеме, пока их не заменят; удаление и переименование
— отдельной ревизией после замены (expand → contract). Ревизия,
блокирующая рабочую таблицу, начинает с SET LOCAL lock_timeout = '2s'.
Отката кода автоматически нет: прежний код на расширенной схеме
работает, откат — прежний код и снова make rolling-update.
Конфигурация: логические имена .env.example
| Имя skeleton | Реализация |
|---|---|
APP_HOST, APP_PORT |
APP_HOST/APP_PORT приложения; в образе 0.0.0.0:8080; на хосте — HOST_PORT у HAProxy |
APP_ENV |
не используется: режим один (контейнер или make run) |
SESSION_TTL_SECONDS |
то же имя, по умолчанию 3600 |
DATABASE_URL_FILE |
не используется: DB_HOST/DB_PORT/DB_NAME/DB_USER/DB_PASSWORD, пароль из .env (POSTGRES_PASSWORD) через environment compose |
SESSION_STORE |
postgres — сессии в PostgreSQL |
CACHE_URL_FILE |
не используется: CACHE_HOST/CACHE_PORT/CACHE_PASSWORD (VALKEY_PASSWORD) |
API_REPLICAS |
то же имя: deploy.replicas сервиса api |
IDEMPOTENCY_TTL_SECONDS |
то же имя, по умолчанию 86400 |
Новые настройки приложения: APP_INSTANCE_ID (по умолчанию hostname),
KEEP_ALIVE_TIMEOUT (60 с). Полная таблица — src/AGENTS.md.
Пагинация и часы
Порядок истории — (created_at, id), keyset по индексу (chat_id, created_at, id). created_at назначает приложение: строго монотонно
внутри процесса; у реплик одного хоста общие часы ВМ, при равенстве
порядок задаёт id. Транзакции фиксируются не в порядке времени, и
сообщение с меньшим created_at может стать видимым позже соседнего:
обход неизменной истории без повторов гарантирован, снимок между
запросами — нет (контракт этого не требует).
3. Доказательства критериев
| Критерий | Результат | Доказательство |
|---|---|---|
| Публичный smoke через LB | PASS: lab3 public API scenario |
test-isolated, после замены |
| Стенд одной командой; ≥ 2 реплики, одна точка входа, одна БД и общие сессии | make up; порт API — только HAProxy; реплики без портов |
стенд |
| Одна сессия на разных репликах | 12 запросов одного токена — 2 реплики по 6; тест: 20 запросов — 10/10 | instances, тесты через LB |
| Остановка любой одной реплики: запись восстанавливается ≤ 10 с, подтверждённые сообщения целы | test-failover PASS для каждой реплики, stop и kill: неудачных попыток 0, первая запись после hook — 0,24–1,73 с |
failover-each, test-isolated |
| Какой контейнер действительно остановлен | ID из TARGET_INSTANCE_ID = ID в exited (STOP_ONE_LOG, docker compose ps) |
failover-each |
| Повтор POST с тем же ключом без дубля, в том числе конкурентный и через другую реплику | 10 одновременных отправок — 10 × 201, один id, пара пересекающихся запросов на разных репликах; повтор через другую реплику — тот же Message, 409 от обеих |
тесты через LB |
| Неподтверждённую запись можно повторить с тем же ключом | 503 не фиксируется результатом; сбой вставки сообщения откатывает ключ; срок ключа | проверки отказов |
make test-persistence |
PASS; StartedAt всех контейнеров новые, volume тот же | persistence |
| Health/readiness, timeouts, SIGTERM согласованы; LB исключает недоступную реплику; период проверок и худшее обнаружение | раздел 2, таблица цепочки; SIGTERM на старте 0,10 с, после старта 0,41 с, код 0 | early-stop, haproxy.cfg |
| Каждая реплика по очереди под нагрузкой: RPS, ошибки, время восстановления | 6 фаз stop/kill/pause; восстановление до 6 с; в каждой 4500 ключей = 4500 строк |
failover baseline |
| Общая идемпотентность параллельными запросами | 10 потоков, один ключ, разные реплики — одно сообщение | тесты через LB |
CPU/RAM-лимиты, API без портов в обход LB, секреты только где нужно, нет container_name у api |
лимиты у всех; переменные окружения по сервисам | стенд |
| Rolling update проверен | make rolling-update: по одной реплике, drain → maint → stop (exit 0) → rm, smoke PASS |
rolling-update |
| Rolling update под нагрузкой; миграции однократно и совместимы | Ошибок 0, замена 10.1 с, ревизия 0002 → 9001; 11 500 сообщений без потерь и дублей |
rollout baseline |
| Миграции однократно, повтор — no-op, схема = описание | alembic check: No new upgrade operations |
migrations |
| Собственные тесты уровня 4 | 84 passed; проверки отказов 15 passed | test-isolated, failure-checks |
| Трек 1: фиксированный бюджет 1/2/4 реплики | Медианы R*: 745 / 1231 / 1819 запросов/с; по 3 повтора, бюджет API 4 CPU / 2 ГиБ | серия a |
| Трек 1: рост ресурсов, точка насыщения | При PG 2 CPU: R* 745 → 1819/с для 1 → 4 API; при PG 0.5 CPU максимум после 2 реплик, далее 1164 → 788/с | серия b, db, графики |
| Трек 1: одно подтверждённое улучшение | TODO (Codex) | TODO (Codex): evidence/compare/scaling-ab-before__scaling-ab-after.md |
| Запуск из копии без локальных файлов | TODO (Codex, шаг 6 RUNBOOK) | fresh-copy |
4. Эксперименты и отказы
4.1. Отказы без нагрузки (сняты)
| Воздействие | Что ожидали | Что наблюдали | Восстановление / потеря данных |
|---|---|---|---|
docker stop реплики во время записи (test-failover, обе реплики) |
LB перенаправляет отказ соединения на живую реплику, ошибок нет | 0 неудачных попыток; первая запись после hook 1,22–1,73 с (hook ждёт graceful stop) | потерь и дублей нет |
docker kill реплики во время записи |
возможны оборванные запросы; повтор с ключом | 0 неудачных попыток; первая запись после hook 0,24–0,75 с | потерь и дублей нет |
| Рестарт LB, реплик, PostgreSQL и Valkey | данные и прежний токен целы | PASS | volume тот же, сессия та же |
| PostgreSQL остановлен | 503 быстро, без деталей | POST сообщения — 503 за 0,007 с; ready — 503 за 0,013 с |
запись во время отказа не появилась; тот же ключ после возврата — 201 один раз |
| PostgreSQL заморожен, пул из 1 | 503 за срок операции + закрытие | 503 за 4,02 с; второй запрос — 1,02 с (ожидание пула) | — |
| Valkey остановлен / заморожен | ответы из PostgreSQL, ≤ 0,2 с лишних | 200 за 0,013 с; заморозка — +0,22 с у одного запроса | кэш возвращается без рестарта API |
| Сбой вставки сообщения после ключа | откат ключа и сообщения | 500; ключей 0; повтор с ключом — 201 | — |
| SIGTERM стартующей реплике | быстрый выход 0, а не 10 с и SIGKILL | 0,10 с, код 0, строка stopped before startup |
— |
Источники — failover-each, persistence, failure-checks, early-stop.
4.2. Отказ каждой реплики под нагрузкой (уровень 4)
Методика (make bench-failover, профиль failover): свой проект
compose vlad-bench с лимитами рабочего стенда (2 реплики по 1 CPU /
512 МиБ, PostgreSQL 2 / 1 ГиБ, Valkey 0,5 / 128 МиБ, HAProxy 1 / 256 МиБ,
без swap); открытая модель через HAProxy — 100 записей с новым
Idempotency-Key и 100 чтений страницы истории в секунду; каждая
реплика по очереди в режимах stop (docker stop --timeout 9), kill,
pause; фаза — 10 с до действия, 15 с отказа, возврат той же реплики,
10 с после. Отметки — часы ВМ Docker: события Docker, журнал HAProxy,
моменты запросов по расписанию. После фазы неуспешные записи
повторяются с тем же ключом, затем сверка: строк в чате = ключей, без
дублей. CPU и память компонентов — сэмплер cgroup.
Прогноз (записан до замера):
| Режим | Обнаружение (граница) | Ошибки клиента | Восстановление |
|---|---|---|---|
stop |
≤ 1,5 с (сокет закрыт) | 0: отказ соединения LB повторяет на живую; рост задержки отдельных запросов до timeout connect 0,5 с |
0 с |
kill |
≤ 2,5 с | единицы: запросы, уже ушедшие на реплику (≈ интенсивность × задержка), — 502/обрыв; LB их не повторяет | ≤ 1 с; после повтора с ключом — потерь и дублей нет |
pause |
≤ 6,5 с | до половины запросов окна обнаружения (≈ 100/с × 6,5 с) — 504 через timeout server 10 с |
≈ время обнаружения; после повтора — без потерь и дублей |
Результат (15 октября 2026, Apple M4): все шесть фаз завершены, в каждой 4500 ключей = 4500 сообщений и 4500 различных текстов. Полная сводка и CPU по окнам, исходные данные.
| Фаза | Режим | Реплика | Обнаружение, с (граница) | Возврат в LB, с | Ошибки до / отказ / после | Виды ошибок | Восстановление, с | Успешных/с до / отказ / после | p95, мс до / отказ / после | max в отказе, мс | Повтор: не прошло → прошло | Сверка |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| p1-stop-r1 | stop | r1 (cce5762ff431) | 1.79 (2.5) | 2.03 | 0 / 1 / 0 | IncompleteReadError:1 | 1 | 200.0 / 199.9 / 199.9 | 6.5 / 13.3 / 6.9 | 512.6 | 0 → 0 | ok: 4500 ключей = 4500 строк |
| p2-kill-r1 | kill | r1 (cce5762ff431) | 1.21 (2.5) | 1.8 | 1 / 0 / 0 | IncompleteReadError:1 | 0 | 199.8 / 200.0 / 199.9 | 6.4 / 9 / 6.7 | 536.1 | 1 → 1 | ok: 4500 ключей = 4500 строк |
| p3-pause-r1 | pause | r1 (cce5762ff431) | 5.89 (6.5) | 1.04 | 1 / 584 / 0 | 504:585 | 6 | 199.7 / 161.2 / 199.9 | 6.9 / 7.8 / 6.7 | 9998.4 | 12 → 12 | ok: 4500 ключей = 4500 строк |
| p4-stop-r2 | stop | r2 (dad5d68a3f49) | 1.27 (2.5) | 0.81 | 0 / 0 / 0 | — | 0 | 200.2 / 199.9 / 200.0 | 6.6 / 8.6 / 6.6 | 528 | 0 → 0 | ok: 4500 ключей = 4500 строк |
| p5-kill-r2 | kill | r2 (dad5d68a3f49) | 0.26 (2.5) | 1.92 | 0 / 0 / 0 | — | 0 | 199.8 / 200.1 / 199.9 | 6.5 / 7.5 / 6.6 | 507.9 | 0 → 0 | ok: 4500 ключей = 4500 строк |
| p6-pause-r2 | pause | r2 (dad5d68a3f49) | 6.06 (6.5) | 0.98 | 1 / 553 / 0 | 504:554 | 6 | 199.9 / 163.2 / 199.9 | 6.8 / 7.6 / 6.9 | 10000.6 | 548 → 548 | ok: 4500 ключей = 4500 строк |
Обнаружение stop/kill уложилось в 2,5 с, pause — в 6,5 с.
Восстановление по посекундному критерию генератора — до 6 с, то есть
меньше обязательных 10 с. После возврата в LB ошибок нет во всех фазах.
В фазах pause получены 585 и 554 ответа 504, неуспешные записи
повторены с исходными ключами; сверка подтвердила отсутствие потерь
и дублей. p95 в таблице относится к успешным ответам: оно не описывает
ожидание неуспешного запроса до timeout server около 10 с.
Окна распределяются по времени запроса по расписанию, поэтому ошибка
в столбце «до» может принадлежать запросу, начатому непосредственно
перед воздействием и завершившемуся уже после него.
Прогноз подтвердился частично: время обнаружения, восстановления и
сохранность соответствуют ожиданиям; при первом stop зарегистрирован
один IncompleteReadError, хотя прогнозировался ноль ошибок. Это
согласуется с описанной гонкой keep-alive при внеплановой остановке без
drain. У первого kill также один оборванный ответ, у второго ошибок
нет. В фазе p3 CPU API до / отказ / после — 0.509 / 0.326 / 0.522 ядра,
PostgreSQL — 0.099 / 0.065 / 0.104: оставшаяся реплика выдерживала этот
профиль; измерение не утверждает, что любая нагрузка переживёт отказ.
4.3. Поочерёдная замена под нагрузкой (уровень 4)
Методика (make bench-rollout, профиль rollout): тот же стенд и
нагрузка; посреди неё scripts/rolling-update.sh (тот же, что make rolling-update) меняет обе реплики на образ с expand-ревизией
9001_rollout_probe (ALTER TABLE messages ADD COLUMN rollout_probe text NULL; ревизия существует только в образе стенда): миграция один раз,
затем по одной реплике. Окна: до скрипта, во время, после; ответы
старых и новых реплик по X-Instance-Id; проверки: две новые реплики,
ни одной старой, один новый образ, ревизия 0002 → 9001, сверка
записей.
Прогноз: ошибок клиента 0 (новая реплика получает запросы только
после UP, старая выводится drain до SIGTERM); p95 во время замены — не
больше двух p95 до неё: ADD COLUMN берёт ACCESS EXCLUSIVE на
messages на миллисекунды и ждёт идущие вставки; после замены — только
новые реплики.
Результат (15 октября 2026, Apple M4): скрипт завершился с кодом 0
за 10.1 с; все шесть проверок успешны. Применена ревизия 0002 → 9001,
колонка существует, после замены отвечают только две новые реплики.
Сверено 11 500 ключей, строк и различных текстов; повторов не потребовалось.
Полная сводка,
исходные журналы.
| Окно | с | Запросов | Успешных/с | Ошибок | Виды | p95, мс | max, мс | Ответов старых | Ответов новых |
|---|---|---|---|---|---|---|---|---|---|
| before | 7.97 | 1594 | 200.0 | 0 | — | 6.5 | 16.1 | 1594 | 0 |
| during | 10.12 | 2022 | 199.9 | 0 | — | 7.1 | 48.1 | 1167 | 855 |
| after | 94.91 | 18982 | 200.0 | 0 | — | 7 | 38.4 | 0 | 18982 |
Контейнеры (секунды от начала скрипта)
- +0.63 с create migrate 4529a10cb5fa
- +0.70 с start migrate 4529a10cb5fa
- +1.64 с die migrate 4529a10cb5fa
- +1.81 с create new 23ce58591a63
- +1.87 с start new 23ce58591a63
- +3.73 с kill old 8426dc470e58
- +4.00 с stop old 8426dc470e58
- +4.00 с die old 8426dc470e58
- +4.05 с destroy old 8426dc470e58
- +6.21 с create new b3a69b4e5e88
- +6.28 с start new b3a69b4e5e88
- +8.93 с kill old 8fe1b57c6f9d
- +9.25 с stop old 8fe1b57c6f9d
- +9.25 с die old 8fe1b57c6f9d
- +9.30 с destroy old 8fe1b57c6f9d
CPU и память по окнам
| Окно | API, ядер (макс. реплика) | PostgreSQL | HAProxy | ВМ занята | API, мкс/запрос |
|---|---|---|---|---|---|
| before | 0.465 (0.24) | 0.088 | 0.016 | 0.0842 | 2325 |
| during | 0.897 (0.237) | 0.093 | 0.024 | 0.1091 | 4487.2 |
| after | 0.499 (0.259) | 0.094 | 0.016 | 0.0746 | 2495 |
Прогноз подтвердился: ошибок нет во всех окнах; p95 во время замены
7.1 мс при 6.5 мс до неё, то есть меньше заранее заданной границы
двух исходных p95. Контейнер migrate стартовал на +0.70 с и завершился
на +1.64 с, первая новая реплика стартовала на +1.87 с: миграция
выполнилась один раз до замены, старые реплики продолжали работать на
расширенной схеме. В окне «после» ответов старых реплик 0.
В семи исходных журналах Docker events этих двух экспериментов
служебные абсолютные пути проекта в Compose labels заменены на
<репозиторий> с явного разрешения пользователя. Времена событий,
действия и ID контейнеров сохранены; агрегаты результатов не изменялись.
4.4. Цена масштабирования (трек 1)
Методика (make bench-scaling SERIES=…, профили SERIES в
bench/run.py, правила — bench/AGENTS.md):
- конфигурация — реплик × CPU реплики (память 512 МиБ на CPU),
PostgreSQL 2 CPU / 1 ГиБ (серия
db— 0,5 CPU), HAProxy 1 / 256 МиБ, Valkey 0,5 / 128 МиБ, генератор 2 / 1 ГиБ, сэмплер 0,25 / 256 МиБ, без swap; сумма лимитов ≤ CPU ВМ Docker (иначе отказ до стенда); - ячейка — конфигурация × повтор (3), каждая на свежем стенде: 20
пользователей, читаемый чат из 10 000 сообщений, 10 чатов записи,
VACUUM (ANALYZE),CHECKPOINT; порядок ячеек — круги с перемешиванием; - нагрузка — открытая модель через HAProxy (генератор на stdlib,
несколько процессов): 70 % страниц истории (
limit=50, курсор из пула), 20 % отправок с новым ключом, 10 %GET /users/me; задержка — от момента по расписанию (без coordinated omission); - ступень — прогрев 10 с с нуля или 5 с подъёма, окно 15 с; сначала 250 и
500 запросов/с, затем поиск R*: лестница
100 × 1,25^iот 300 × реплик, подъём до первой нарушившей, два деления по среднему геометрическому (разрешение ≈ 5,7 %); - SLO ступени: p95 успешных ≤ 200 мс и (ошибки + неполные страницы + недосланные) ≤ 1 %; R* — наибольший прошедший уровень поиска;
- сэмплер раз в секунду: CPU, троттлинг и память каждого контейнера
(cgroup), занятость ВМ, статистика HAProxy, соединения и счётчики
PostgreSQL; признаки узкого места с порогами, заданными до замеров
(
THRESHOLDSв bench/analysis.py):app,db_cpu,db_lock,pool,churn,lb,host,generator.
Серии: a — бюджет 4 CPU / 2 ГиБ: 1 × 4, 2 × 2, 4 × 1; b — 1, 2, 3, 4
реплики по 1 CPU; db — те же реплики 1, 2, 4 при PostgreSQL 0,5 CPU
(управляемое насыщение общей зависимости); ab — «до/после» улучшения
и A/A.
Калибровка до записи гипотез (самопроверка make bench-scaling-quick на
машине разработки Apple M3 Pro, 1 000 сообщений и окна по 6 с; метки
самопроверок в git не идут и результатом не являются): R*(1 × 1) ≈ 530/с,
R*(2 × 1) ≈ 830/с; на первой нарушившей ступени — app и pool, у 2 × 1
ещё churn; CPU PostgreSQL ≈ 0,4 мс на запрос на 200/с.
Гипотезы (записаны до замеров; итог — отдельным абзацем под каждой, формулировки не меняются):
- H1. Фиксированный бюджет (серия
a). Один процесс uvicorn с одним event loop занимает не больше одного ядра (GIL; Argon2id в потоках — только при входе, вне ступеней). Поэтому R*(1 × 4) ≈ R*(1 × 1) (из серииb), а 2 × 2 и 4 × 1 растут почти пропорционально числу процессов, пока не упрутся в общий ресурс.- Подтвердит: R*(1 × 4) / R*(1 × 1) ∈ [0,85; 1,25]; CPU реплики 1 × 4
на ступени R* (
api_cpu_max) ≤ 1,3 ядра; R*(2 × 2) ≥ 1,6 × R*(1 × 1); R*(4 × 1) ≥ 2,8 × R*(1 × 1) или на первой нарушившей у 4 × 1 есть признак общего ресурса (db_cpu,pool,churn,lb,host). - Опровергнет: R*(1 × 4) ≥ 1,25 × R*(1 × 1) или
api_cpu_max1 × 4 ≥ 1,5 ядра; R*(2 × 2) < 1,6 × R*(1 × 1) без признака общего ресурса. - Итог: подтверждена по заранее заданным критериям. Медианы R*
дают 745 / 745 = 1.000 для 1 × 4 против 1 × 1 и 1231 / 745 = 1.652
для 2 × 2. У 1 × 4 CPU на R* — 0.905 / 0.914 / 0.917 ядра в трёх
повторах. Рост 4 × 1 составляет 1819 / 745 = 2.442, меньше 2.8,
однако условие альтернативы из прогноза выполнено: на первой
нарушившей ступени
poolиchurnприсутствуют во всех трёх повторах. Это наблюдение не доказывает насыщение CPU PostgreSQL на 2 ядрах; для отделения ограничения базы предназначена серияdb.
- Подтвердит: R*(1 × 4) / R*(1 × 1) ∈ [0,85; 1,25]; CPU реплики 1 × 4
на ступени R* (
- H2. Рост ресурсов (серия
b, PostgreSQL 2 CPU). R* растёт с числом реплик, ограничение каждой ступени — CPU своей реплики (app); до 4 реплик общий ресурс не насыщается: по калибровке PostgreSQL тратит ≈ 0,4 мс CPU на запрос, и 2 ядра хватает до ≈ 4 000–5 000/с.- Подтвердит: эффективность R*(4) / (4 × R*(1)) ≥ 0,7; на первой
нарушившей ступени при k ≤ 4 есть
appи нетdb_cpuв ≥ 2 из 3 повторов; CPU PostgreSQL на R*(4) < 1,7 ядра. - Опровергнет: R*(4) < 1,25 × R*(3) (насыщение уже в серии
b) илиdb_cpu/lb/hostна первой нарушившей при k ≤ 4 — тогда точка насыщения найдена в серииb, и её признак называет узкое место. - Итог: частично подтверждена. R* растёт от 745 до 1819 запросов/с,
признак
appприсутствует на первой нарушившей ступени во всех трёх повторах каждой конфигурации,db_cpuне обнаружен. На R*(4 × 1) медиана CPU PostgreSQL — 1.091 ядра, меньше прогнозной границы 1.7. Однако эффективность четырёх реплик — 0.610, ниже ожидаемых 0.7. Отношение R*(4) / R*(3) — 1819 / 1455 ≈ 1.25017, поэтому условие опровержения «меньше 1.25» не выполнено. Рост есть, но он слабее прогноза; снижение эффективности само по себе не доказывает насыщение единственной базы. Исходные данные — серия b.
- Подтвердит: эффективность R*(4) / (4 × R*(1)) ≥ 0,7; на первой
нарушившей ступени при k ≤ 4 есть
- H3. Насыщение PostgreSQL (серия
db, 0,5 CPU). С общим PostgreSQL на 0,5 CPU рост реплик перестаёт помогать после двух: запросы ждут базу, а не CPU реплик. Под очередью к базе пул реплики выходит за 10 соединений, и соединения переполнения переоткрываются (churn), отнимая у насыщенной базы ещё CPU на новые сессии.- Подтвердит: R*(4 × 1) < 1,2 × R*(2 × 1); на первой нарушившей при
k ≥ 2 —
db_cpu(CPU PostgreSQL ≥ 0,425 ядра) в ≥ 2 из 3 повторов; CPU реплик на этой ступени < 0,85 ядра (api_cpu_max); у 4 × 1 —churn(≥ 20 новых сессий PostgreSQL за окно) в ≥ 2 из 3. - Опровергнет: R*(4 × 1) ≥ 1,2 × R*(2 × 1) или
db_cpuнет — база не узкое место даже на 0,5 CPU. - Итог: частично подтверждена. После двух реплик R* падает:
788 / 1164 = 0.677. У четырёх реплик CPU самой загруженной API на
первой нарушившей ступени — 0.401 / 0.393 / 0.380 ядра, ниже 0.85;
churnесть в 2 из 3 повторов. Но пороговый признакdb_cpuзарегистрирован только в 1 из 3 повторов как для двух, так и для четырёх реплик, вместо ожидаемых 2 из 3. У двух реплик CPU API на этой ступени — 0.865 / 0.984 / 0.916, поэтому тезис «ждут только базу, а не CPU реплик» для них не подтвердился. В первом прогоне четырёх реплик PostgreSQL занял весь лимит 0.5 CPU, доля времени троттлинга — 1.0; в двух других она составила 0.3 и 0.1688. Число соединений на первой нарушившей ступени — 60 во всех трёх повторах. Доказан спад пропускной способности при росте API на ограниченной базе; приписывать все случаи исключительно среднему CPU PostgreSQL по одному порогу нельзя.
- Подтвердит: R*(4 × 1) < 1,2 × R*(2 × 1); на первой нарушившей при
k ≥ 2 —
- H4. Улучшение: пул без переполнения (снимается, только если у
4x1-pg0.5естьchurnв ≥ 2 из 3 ячеек; иначе выбор улучшения — решение пользователя,bench/RUNBOOK.md, шаг 4). Изменение — одно значение по умолчанию:DB_POOL_OVERFLOW5 → 0 (src/config.py). Механизм:QueuePoolSQLAlchemy закрывает возвращённое соединение, если в пуле ужеpool_sizeсвободных, поэтому соединения сверх 10 живут, только пока заняты, и под нагрузкой открываются снова и снова; каждое новое — процесс PostgreSQL, аутентификация SCRAM-SHA-256 на стороне базы и PBKDF2 на стороне asyncpg. Без переполнения запрос ждёт свободное соединение (DB_POOL_TIMEOUT5 с), но база не тратит CPU на новые сессии.- Предсказание для
4x1-pg0.5: R* после / до ≥ 1,118 (две ступени сетки), выводcompare.pyс A/A — «эффект»; новых сессий за окно на первой нарушившей «после» ≤ 5 («до» ≥ 20); CPU PostgreSQL на запрос на R* «после» меньше, чем «до». - Контроль
4x1(PostgreSQL 2 CPU, узкое место — реплики): |Δ R*| меньше двух ступеней. - Подтвердит: всё для
4x1-pg0.5и контроль в пределах; шум A/A меньше двух ступеней. Опровергнет: разбросы пересекаются, Δ не больше шума A/A или меньше двух ступеней; переоткрытие не исчезло. - Цена: под перегрузкой запросы ждут пул, а не открывают соединения; после 5 с ожидания — 503. Соединений на реплику — не больше 10.
- Итог: TODO (Codex).
- Предсказание для
Результаты исходных серий (Apple M4): по три повтора каждой конфигурации. Полная сводка и точка насыщения; исходные ступени, ресурсы и паспорта — в каталогах серии a, b и db.
| Метка | Конфигурация | Реплик | CPU реплики | PostgreSQL CPU | R* медиана | min–max | Эффективность к 1 × 1 метки | Признаки на первой нарушившей |
|---|---|---|---|---|---|---|---|---|
| scaling-a | 2x2 | 2 | 2 | 2 | 1231 | 1164–1231 | — | churn ×3, pool ×3 |
| scaling-a | 4x1 | 4 | 1 | 2 | 1819 | 1819–1819 | — | app ×3, churn ×3, pool ×3 |
| scaling-a | 1x4 | 1 | 4 | 2 | 745 | 745–745 | — | pool ×3 |
| scaling-b | 3x1 | 3 | 1 | 2 | 1455 | 1376–1455 | 0.65 | app ×3, churn ×2, pool ×3 |
| scaling-b | 4x1 | 4 | 1 | 2 | 1819 | 1720–1819 | 0.61 | app ×3, churn ×3, pool ×3 |
| scaling-b | 1x1 | 1 | 1 | 2 | 745 | 745–745 | — | app ×3, pool ×3 |
| scaling-b | 2x1 | 2 | 1 | 2 | 1164 | 1164–1164 | 0.78 | app ×3, churn ×2, pool ×3 |
| scaling-db | 2x1-pg0.5 | 2 | 1 | 0.5 | 1164 | 1164–1231 | — | app ×3, churn ×3, db_cpu ×1, pool ×3 |
| scaling-db | 4x1-pg0.5 | 4 | 1 | 0.5 | 788 | 788–833 | — | churn ×2, db_cpu ×1, pool ×3 |
| scaling-db | 1x1-pg0.5 | 1 | 1 | 0.5 | 745 | 745–745 | — | app ×3, pool ×3 |
По заранее заданному критерию «следующая конфигурация даёт меньше +10 % R*» точка насыщения при PostgreSQL 0.5 CPU — после двух реплик: дальнейший рост до четырёх снижает R* с 1164 до 788/с. При PostgreSQL 2 CPU в пределах 1–4 реплик такого плато нет, хотя эффективность падает. Это граница исследованного диапазона, а не утверждение о неограниченном масштабировании.
Дополнительные показатели на индивидуальном R* каждой ячейки серии b. В таблице — медианы трёх результатов, включая медианы p50/p95/p99 отдельных повторов, а не перцентили объединённой выборки. CPU API — самая загруженная реплика, PostgreSQL — общий процессный cgroup.
| Конфигурация | Успешных/с | p50, мс | p95, мс | p99, мс | API, ядер | PostgreSQL, ядер |
|---|---|---|---|---|---|---|
| 1x1 | 745 | 3.89 | 67.3 | 119.35 | 0.918 | 0.177 |
| 2x1 | 1164 | 3.23 | 69.66 | 150.75 | 0.849 | 0.353 |
| 3x1 | 1455 | 4.69 | 73.47 | 151.41 | 0.901 | 0.665 |
| 4x1 | 1819 | 7.74 | 141.71 | 229.19 | 0.964 | 1.091 |
Графики p95 по ступеням и CPU компонентов: a: p95, a: CPU, b: p95, b: CPU, db: p95, db: CPU.
Решение перед сравнением H4: у 4x1-pg0.5 на первой нарушившей
ступени churn есть в 2 из 3 повторов; условие выбора улучшения
выполнено. Проверяется заранее записанное изменение overflow 5 → 0.
Сначала снимаются before и A/A на неизменном коде, затем проверяются
корректность и результаты after.
Сравнение улучшения: TODO (Codex): таблица
evidence/compare/scaling-ab-before__scaling-ab-after.md и итог H4.
Контроль до изменения: хеш приложения у before и A/A одинаковый —
0349e9a270178467, пул 10 + 5. В основном случае медиана R* обеих
меток 788/с; у контроля — 1627 → 1455/с (−10.6 %).
Сравнение одинакового кода.
Поле git_dirty метки A/A отражает новые файлы результатов в рабочем
дереве; исходники приложения и стенда не менялись.
В A/A, ячейка 4, фиксированная ступень 500/с завершилась с p95 3146.33 мс и 2463 неотправленными запросами из 7500 запланированных после досрочной остановки генератора. p95 обслуживания отправленного запроса — 3126.85 мс, p99 отставания отправки — 55.05 мс, CPU генератора 0.128 из 2 ядер; соединений с PostgreSQL — 60. Эта ступень и её признаки сохранены в runs.csv A/A. R* здесь описывает результат заданного поиска; прохождение найденной ступени не гарантирует прохождение каждого меньшего уровня в другом запуске. Фиксированные ступени и разбросы учитываются отдельно.
Семантика закрытия возвращаемых соединений переполнения и одинаковые параметры асинхронного пула подтверждаются документацией SQLAlchemy 2.1. Числа эффекта определяются сравнением измеренных меток с A/A.
5. Ограничения
- Один Docker-хост, один HAProxy, одна PostgreSQL, один Valkey. Выдерживается отказ процесса API (любой одной реплики при ≥ 2 живых); не выдерживается отказ хоста, LB и PostgreSQL. Отказ Valkey — деградация до PostgreSQL, не отказ.
- Отказ при
killиpause: запрос, который уже ушёл на реплику, LB не повторяет (POST не идемпотентны). Клиент получает 502/504 и обязан повторить отправку с тем же ключом — так делаетtests/resilience.pyи генератор стенда. - Остановка без вывода из LB (
stop-one.sh,docker stop) имитирует отказ: на гонке закрытия keep-alive возможен одиночный 502. Плановая замена (rolling-update.sh) сначала выводит реплику (drain). - Окно запуска интерпретатора до раннего обработчика SIGTERM — десятки
миллисекунд: сигнал в нём теряется (PID 1). Скрипт замены убирает
такую реплику
docker rm -f. - Просроченные ключи идемпотентности не удаляются сами: занятый заново
ключ заменяется, остальные копятся. Уборка —
DELETE FROM idempotency_keys WHERE created_at < now() - interval '24 hours'по индексуcreated_at(учебному стенду не нужна). - Порядок истории между репликами — по часам ВМ одного хоста; на разных хостах понадобился бы источник порядка в базе.
- Замеры — на одном ноутбуке, все компоненты делят его CPU; лимиты cgroup не привязаны к производительным ядрам. Числа разных машин рядом не ставятся.
- Сессия 15 октября 2026 начата на Apple M4 при питании от батареи
с явного разрешения пользователя. Фактическое питание и предупреждение
host on battery powerсохраняются в паспортах; влияние режима питания отдельно не измерялось. Результаты этих серий не сравниваются с прежней калибровкой на M3 Pro. - Между завершением серии
bи запускомdbбыла пауза около трёх часов из-за лимита сессии Codex. Код приложения и конфигурация ресурсов не менялись; температура хоста отдельно не измерялась. Это ограничение сопоставления серий. Сравнение улучшения с A/A должно выполняться подряд в одной сессии устройства. - TODO (Codex): ограничения, обнаруженные при замерах (хост,
generator_bound, конфигурации, не поместившиеся в ВМ).
6. Ответы на вопросы защиты
Чем отказ процесса отличается от отказа узла? Отказ процесса (реплика остановлена или убита) оставляет хост, сеть, LB и хранилища живыми: HAProxy перестаёт получать ответы проверок от одной реплики и за 1,5–6,5 с выводит её, остальные обслуживают запросы. Отказ узла уносит всё, что на нём: здесь на одном хосте и LB, и PostgreSQL, и все реплики — стенд его не переживает (раздел 5).
Почему depends_on/healthcheck сами по себе не являются
балансировщиком? depends_on упорядочивает только старт контейнеров,
healthcheck меняет лишь статус контейнера в Docker: запросы клиента они
не распределяют и не перенаправляют. Распределение, исключение
неготовой реплики и повтор при отказе соединения делает HAProxy со
своими проверками /health/ready.
Какие POST можно повторять после timeout и что защищает
Idempotency-Key? Только отправку сообщения — с тем же ключом и тем же
телом: сервер вернёт то же сообщение, если первая попытка
зафиксировалась, или создаст его один раз, если нет (ключ и сообщение в
одной транзакции). POST /users и POST /chats ключ не защищает: повтор
может создать второй объект, поэтому ни LB, ни API их прозрачно не
повторяют. Ключ защищает от дублей при неопределённом результате
(таймаут, обрыв, 5xx, переключение реплики), но не от другого тела с тем
же ключом — это 409.
Что сломается при увеличении числа API, если сессии находятся в локальной памяти? Токен, выданный одной репликой, другие не знают: round-robin отправит следующий запрос на другую реплику — 401, хотя вход был; logout отзовёт сессию только в одной реплике; рестарт реплики выкинет её пользователей. Лечить это sticky session — значит привязать пользователя к процессу и потерять его сессию при отказе этого процесса. Поэтому сессии — в PostgreSQL.
7. Что ещё проверить на защите
make lb-stats— слоты HAProxy, состоянияUP/DOWN, повторы.docker compose logs haproxy— строкиServer api/api-N is DOWNиis UPво времяmake test-failover.- Таблица ключей:
docker compose exec postgres psql -U … -c "\d idempotency_keys"(вывод).
8. Источники и помощь ИИ
- Документация: HAProxy 3.4 Configuration Manual (server-template, resolvers, http-check, retry-on, http-reuse, runtime API), Compose file reference, PostgreSQL INSERT … ON CONFLICT, SQLAlchemy pooling, uvicorn settings, RFC 9110 (семантика повторов), draft IETF «The Idempotency-Key HTTP Header Field».
- Библиотеки: FastAPI, Starlette, uvicorn, pydantic, SQLAlchemy, asyncpg, alembic, argon2-cffi, redis-py; тесты — pytest, httpx; генератор нагрузки, сэмплер, оркестратор стенда и графики — только стандартная библиотека Python.
- Помощь ИИ: Claude (Anthropic) — перенос кода из лабы 2, реализация
X-Instance-Id, идемпотентности, раннего обработчика SIGTERM, стенда compose с HAProxy, скриптов отказа и замены, тестов, нагрузочного стенда и черновиков документации; Codex (OpenAI) — замеры поbench/RUNBOOK.mdи их разбор. Все числа в отчёте — из файловevidence/, снятых командами, указанными в их шапках; решения проверены тестами и вручную.