Files
mtusi2026lab3/REPORT.md
T

72 KiB
Raw Blame History

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

  • Автор, группа: Владимирцева, БВТ2301
  • Целевая оценка 5; выбранный трек 5: 1 «Цена масштабирования»
  • Ветка: solution/bvt2301-vladimirceva; локальные коммиты, PR не опубликован
  • Использованные источники, библиотеки и помощь ИИ: раздел 8 в конце отчёта

Состояние отчёта: уровень 3 и все проверки уровня 4, включая отказ каждой реплики и поочерёдную замену под нагрузкой, сняты (разделы 3–4, файлы evidence/). Основные серии трека 1 и эксперимент H4 завершены по bench/RUNBOOK.md. H4 опровергнута; требование одного подтверждённого улучшения пока не выполнено. Гипотезы и прогнозы раздела 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):

  1. make up, make instances — ≥ 2 разных X-Instance-Id у запросов одной сессии (пример).
  2. make test-failover ACTION_SCRIPT=scripts/stop-one.sh STOP_ONE_LOG=/tmp/stop-one.log — запись во время отказа, повтор с исходным ключом, без дублей.
  3. docker compose ps и строка /tmp/stop-one.log: остановлен именно контейнер с ID из TARGET_INSTANCE_ID. make replicas, затем то же для второй реплики. Обе реплики по очереди, stop и kill — make failover-each [STOP_MODE=kill] (вывод).
  4. 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. Отправка — одна транзакция:

  1. захват ключа одним INSERT … ON CONFLICT DO UPDATE … WHERE created_at < now − TTL RETURNING: новый или просроченный ключ — захвачен, иначе — занят, строка заблокирована до конца транзакции;
  2. захвачен — вставка сообщения с этим message_id, commit (ссылка проверяется при commit) → 201;
  3. занят — чтение сохранённого: тот же хэш → тот же Message (201), другой → 409 conflict.

Одновременные запросы с одним ключом через разные реплики ждут друг друга на уникальном индексе: второй после 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

Соединения PostgreSQL: 2 × (пул 10 + переполнение 5) + migrate = 31 ≤ max_connections 100; при замене на пике три реплики — 46. Кандидат H4 без переполнения возвращён к исходной настройке после отсутствия эффекта. Реплики, 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: одно подтверждённое улучшение Пока не выполнено: H4 опровергнута, изменение возвращено сравнение H4 с A/A
Запуск из копии без локальных файлов 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_max 1 × 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.
  • 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.
  • 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 по одному порогу нельзя.
  • H4. Улучшение: пул без переполнения (снимается, только если у 4x1-pg0.5 есть churn в ≥ 2 из 3 ячеек; иначе выбор улучшения — решение пользователя, bench/RUNBOOK.md, шаг 4). Изменение — одно значение по умолчанию: DB_POOL_OVERFLOW 5 → 0 (src/config.py). Механизм: QueuePool SQLAlchemy закрывает возвращённое соединение, если в пуле уже pool_size свободных, поэтому соединения сверх 10 живут, только пока заняты, и под нагрузкой открываются снова и снова; каждое новое — процесс PostgreSQL, аутентификация SCRAM-SHA-256 на стороне базы и PBKDF2 на стороне asyncpg. Без переполнения запрос ждёт свободное соединение (DB_POOL_TIMEOUT 5 с), но база не тратит 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.
    • Итог: опровергнута. В основном сценарии R* 788 → 788/с (0 %), разбросы пересекаются; новых сессий 23 → 3, но CPU PostgreSQL на запрос на R* остался 314.7 мкс. У контроля сдвиг +11.8 % также признан шумом из-за пересечения разбросов. Предсказание роста R* и снижения CPU не выполнено. pool_overflow возвращён с 0 на 5; измеренный кандидат сохранён в коммите d9868ca и метке after. Проверки после возврата: 84 теста приложения и 15 проверок отказов прошли; все результаты стендов 0.
  • H5. Улучшение: ограничение конкурентности обращений к БД. Записана 16 октября 2026 после завершения и опровержения H4, до новых замеров. Изменение: значения по умолчанию пула 10 + 5 → 2 + 0 (DB_POOL_SIZE, DB_POOL_OVERFLOW); остальные настройки неизменны. При четырёх API верхняя граница соединений приложения уменьшится с 60 до 8. Мотивировка: в серии db две реплики дали медиану R* 1164, четыре — 788, при низком CPU реплик; в H4 уменьшение новых сессий не изменило основной R*. Проверяется предположение, что ограничение конкурентной работы соединений уменьшит конкуренцию на ограниченной базе. Сам механизм по одному счётчику соединений не доказан.

    • Основной сценарий 4x1-pg0.5: R* после / до ≥ 1,118 и вывод сравнения с A/A — «эффект» (непересекающиеся разбросы, сдвиг больше шума A/A). Дополнительные показатели: CPU PostgreSQL на запрос, число соединений и новых сессий; они объясняют результат, но не заменяют критерий R*.
    • Контроль 4x1, PostgreSQL 2 CPU: снижение медианы R* не больше одной ступени поиска (5,7 %); рост допустим. На фиксированных 250/500 запросах/с SLO и критерий ошибок должны выполняться.
    • Подтвердит: основной критерий выполнен, контроль не ухудшился сверх допуска, проверки корректности и отказов проходят. Опровергнет: любой из этих критериев не выполнен. При шуме A/A ≥ 11,8 % вывод о росте откладывается: точности недостаточно.
    • Цена: более раннее ожидание соединения, возможные 503 после DB_POOL_TIMEOUT; новая настройка может ограничить более мощную БД.
    • Методика и профиль те же; новая последовательность меток scaling-h5-before, scaling-h5-aa, scaling-h5-after в одной сессии устройства. Before и A/A — исходный код 10 + 5; измерение after начинается только после проверок кандидата.
    • Итог: проверка кандидата по H5 отложена из-за шума контроля. Before: R* 788 (788–833), A/A: 984 (833–1164), сдвиг 24.9 %; контроль 4x1 — 1819 во всех шести повторах. Предварительное условие шума < 11,8 % не выполнено. На момент этого вывода код оставался 10 + 5, измерений кандидата не было. Сравнение контролей.
  • H6. Пул 2 + 0 даёт эффект, превышающий разброс обоих контролей. Записана 16 октября 2026 после контролей H5, до изменения кода и измерения кандидата. Это отдельный план анализа: H5 и её порог шума сохранены. Профиль нагрузки, поиск, пороги признаков и код стенда не меняются. Новых контролей до получения «удобного» шума не снимаем: используются обе полные метки H5 одной продолжающейся сессии. Изменение и предполагаемый механизм те же: пул 10 + 5 → 2 + 0, ограничение одновременной работы с БД; новая метка — scaling-h6-after.

    • Основной сценарий: медиана R* after / before ≥ 1,5; минимальный R* after строго больше максимального R* обоих контролей (до измерения after эта граница равна 1164/с).
    • Оба сравнения before → after с A/A и aa → after с before в качестве A/A должны дать «эффект» по неизменному compare.py. Таким образом, +50 % должно сопровождаться отделением всех трёх новых повторов от шести исходных; одного выброса недостаточно.
    • Контроль 4x1: снижение медианы R* не больше одной ступени (5,7 %) относительно 1819/с. Все фиксированные ступени 250/500 после изменения должны держать SLO; проверки приложения и отказов проходят.
    • Подтвердит: выполнены все перечисленные критерии. Иначе улучшение не подтверждено, настройка возвращается к исходной. Дополнительные метрики соединений и CPU помогают объяснению, но не заменяют R*.
    • Ограничения: критерий H6 выбран с учётом уже наблюдённого шума контролей, до результатов кандидата. Это последовательное исследование, а не первоначальный план H5. Цена малого пула — ожидание и возможные 503; механизм конкуренции ещё не доказан.
    • Итог: кандидат ещё не измерен.

Результаты исходных серий (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* при фиксированном бюджете и росте ресурсов

R* от числа реплик и линейный ориентир

Дополнительные показатели на индивидуальном 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.

Сравнение H4: полный вывод с A/A. Шум A/A — 10.6 %; порог эффекта — непересекающиеся разбросы, сдвиг больше шума и отношение R* ≥ 1,118.

Конфигурация R* до, медиана (min–max), /с R* после Δ Вывод Новых сессий до / после PostgreSQL мкс/запрос на R* до / после
4x1-pg0.5 788 (788–931) 788 (788–788) 0 % шум (разбросы пересекаются) 23 / 3 314.7 / 314.7
4x1 1627 (1455–1819) 1819 (1819–1923) 11.8 % шум (разбросы пересекаются) 53 / 3 572.2 / 574.5

Число новых сессий взято на первой нарушившей ступени; это разные интенсивности до и после. Переоткрытие уменьшилось, но причинную связь с ростом пропускной способности измерение не подтвердило. Пул after — 10 + 0, хеш a0d92ab73f82f300, коммит d9868ca; все шесть ячеек завершены без пометок, host_warnings пуст.

Сравнение R* до, A/A и после 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 должно выполняться подряд в одной сессии устройства.
  • На SVG p95 ось ограничена 1000 мс; большие задержки нужно смотреть в исходных CSV, где значения сохранены полностью.
  • Признак pool использует число соединений, включая простаивающие; достижение порога само по себе не доказывает ожидание свободного соединения. Для H4 постоянный пул может давать этот признак и без переполнения.
  • В основных сериях все конфигурации поместились в ВМ; в итоговых searches.csv нет generator_bound, cap и stand_down. Отдельная аномальная ступень A/A описана выше и сохранена в данных.
  • Возобновление прерванной серии требует доработки: статически найденные дефекты RESUME=1 описаны в KNOWN_ISSUES.md. Завершённые серии для отчёта этот режим не использовали.

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/, снятых командами, указанными в их шапках; решения проверены тестами и вручную.