47 KiB
Отчёт — лабораторная 3
Балансировка и отказ API-реплики
- Автор, группа: Максимова Мария, БВТ2303
- Целевая оценка: 4
- Commit/PR: (ветка
solution/maksimova_bvt2303) - Использованные средства: Python 3.12.7 (в Docker), FastAPI, uvicorn, SQLAlchemy 2 (async) + asyncpg, argon2-cffi, redis-py (клиент Valkey) — всё из lab2; PostgreSQL 16.4, Valkey 8.0.1, HAProxy 3.0.11, Docker Desktop 29.3.0 + Compose v5.1.0.
- Источники: документация HAProxy 3.0 (resolvers, server-template, http-check, retry-on, http-error), Docker Compose (deploy.replicas, resources, depends_on conditions, secrets), uvicorn (Server, graceful shutdown), PostgreSQL (INSERT … ON CONFLICT, advisory locks).
- Помощь ИИ: Claude Code использовался для переноса lab2 под lab3 (идемпотентность, drain при SIGTERM, X-Instance-Id), конфигурации HAProxy, операторских скриптов, собственных тестов и черновика отчёта. Все команды и измерения запущены на моём стенде 2026-10-13, сырые результаты — в
evidence/.
0. Коротко и простыми словами
Раньше (lab2) был один процесс API. Если он падал — мессенджер не работал. В lab3 процессов API два, а перед ними стоит балансировщик HAProxy. Клиент всегда ходит на один адрес localhost:8080, а HAProxy по очереди отправляет запросы то в одну реплику, то в другую. Если одна реплика умирает, HAProxy это замечает и отправляет всё в живую.
Чтобы такое работало, API не должен ничего важного хранить «у себя в памяти». Всё хранится в общих местах:
- PostgreSQL — все данные, сессии (токены входа) и ключи идемпотентности;
- Valkey — только быстрый кэш сессий (если его потерять, ничего не сломается — данные возьмутся из PostgreSQL).
Поэтому неважно, какая реплика обработала запрос: обе видят одни и те же данные и один и тот же токен.
Вторая проблема — повторы. Клиент отправил сообщение, реплика упала, ответа нет. Сообщение сохранилось или нет? Клиент не знает и повторяет запрос. Чтобы повтор не создал дубль, клиент передаёт заголовок Idempotency-Key — уникальную строку на одно сообщение. Сервер запоминает ключ в PostgreSQL вместе с сообщением. Если пришёл тот же ключ ещё раз, сервер не создаёт новое сообщение, а возвращает уже сохранённое.
Что проверено (подробности и цифры — в разделах 5–6):
| Что | Результат m |
|---|---|
Публичные тесты make check, make test |
PASS |
| Запросы одного пользователя обслуживают разные реплики | да, X-Instance-Id чередуется, повторный вход не нужен |
Остановка каждой реплики (make test-failover) |
PASS для обеих, 0 ошибок, запись снова работает через 4.4–4.5 s |
Перезапуск всего стенда (make test-persistence) |
PASS, данные и прежний токен сохранились |
| 16 одновременных POST с одним ключом, 10 раз | каждый раз ровно 1 сообщение, запросы шли через обе реплики |
| Остановка/убийство реплик под нагрузкой (4 прогона) | 1 ошибка на ~11 600 запросов (при SIGKILL), потерь и дублей 0 |
| Rolling update (замена обеих реплик новой версией) | 70 s под нагрузкой, 0 ошибок, 4 826 записей, потерь и дублей 0 |
1. Что сделано
Из lab2 перенесены app/, миграции 001–002, scripts/migrate.py, scripts/init-secrets.sh, requirements.txt. Новое в lab3:
- HAProxy (
infra/haproxy/haproxy.cfg) — единственная публичная точка входа:8080. Сервис Composeapiзапускается в 2 экземплярах (deploy.replicas: 2), у него нетportsи нетcontainer_name. - HAProxy сам находит реплики через встроенный DNS Docker: имя
apiвозвращает IP всех работающих контейнеров сервиса (server-template api 8 api:8080 … resolvers docker). Каждую секунду HAProxy проверяет у каждой реплики/health/ready. Балансировка — обычный round-robin, без sticky session. - В процессе API нет локального состояния: всё в PostgreSQL и общем Valkey.
- Каждый ответ API содержит заголовок
X-Instance-Id= hostname контейнера (короткий Docker ID). По нему видно, какая реплика ответила. POST /chats/{id}/messagesтребуетIdempotency-Key(миграция003_idempotency_keys.sql, код —app/repositories.py: create_message_idempotent).- Graceful shutdown (
app/server.py): получив SIGTERM, реплика 3 s продолжает работать, но отвечает503на/health/ready. За это время HAProxy выводит её из пула, и только потом она закрывает порт и дорабатывает начатые запросы. - Миграции выполняет отдельный одноразовый сервис
migrateдо старта API, а не каждая реплика сама.pg_advisory_lockзащищает от двух одновременных запусков. - Операторские скрипты:
stop-one.sh(остановить одну реплику),kill-one.sh(убить SIGKILL),start-api.sh(вернуть),restart.sh(перезапуск всего стенда),rolling-update.sh(поочерёдная замена реплик).
Исправления в коде lab2, найденные при переносе:
Dockerfile: былоCMD ["sh","-c","uvicorn …"], сталоCMD ["python","-m","app.server"]. Приsh -cпроцессом №1 в контейнере былsh: он не передавал SIGTERM в uvicorn, иdocker stopубивал процесс без graceful shutdown (проверено черезdocker top).CreateChat.title: максимум 255 → 100 символов, как в контракте.init-secrets.sh: файлы секретов 0644 внутри каталога 0700. На Linux пользователь контейнераappuserне мог прочитать файл 0600, смонтированный как secret.migrate.py: повтор подключения к БД иpg_advisory_lock.
2. Запуск из чистого clone
Нужно: Docker Engine/Desktop с Compose v2, sh, make, Python 3.9+ (для make test с хоста). Все образы закреплены версиями:
| Роль | Service | Образ | Health/readiness | Volume | Сеть / порт | Секреты |
|---|---|---|---|---|---|---|
| LB | lb |
haproxy:3.0.11-alpine |
wget /lb-health (:8404) |
— | edge; 8080 публично, 8404 только 127.0.0.1 |
нет |
| API ×2 | api |
messenger-lab3-api:<APP_VERSION> (сборка из Dockerfile, база python:3.12.7-slim) |
GET /health/ready (БД доступна и нет drain) |
— | edge + backend, порт не публикуется |
database_url, cache_url |
| Миграции | migrate |
тот же образ | завершается с кодом 0 | — | backend |
database_url |
| БД | db |
postgres:16.4-alpine |
pg_isready |
postgres_data |
backend (internal) |
postgres_password |
| Кэш сессий | valkey |
valkey/valkey:8.0.1-alpine |
valkey-cli ping |
нет (это кэш) | backend (internal) |
valkey_password |
| Проверки | tester (profile tools) |
сборка student-tests/Dockerfile.tester (python:3.12.11-alpine3.22 + docker CLI 28.5.1) |
— | — | edge |
docker.sock (только учебный стенд) |
Сеть backend — internal: true: у PostgreSQL и Valkey нет выхода наружу, и HAProxy к ней не подключён. Наружу опубликован только порт 8080 балансировщика.
# 1. Секреты (создаются один раз в infra/secrets/, в Git не попадают; значения не печатаются)
sh scripts/init-secrets.sh
cp .env.example .env # необязательные параметры, секретов не содержит
# 2. Сборка, миграции (сервис migrate) и запуск; --wait ждёт, пока все сервисы станут healthy
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
# 3. Проверки уровня 3
make check
make test # на Windows: PYTHONUTF8=1 make test PYTHON=python
docker compose --profile tools run --rm tester make test-failover ACTION_SCRIPT=scripts/stop-one.sh
docker compose --profile tools run --rm tester sh scripts/start-api.sh # вернуть остановленную реплику
docker compose --profile tools run --rm tester make test-persistence ACTION_SCRIPT=scripts/restart.sh
# 4. Проверки уровня 4
docker compose --profile tools run --rm tester python3 student-tests/idempotency_concurrency.py
docker compose --profile tools run --rm tester sh student-tests/run-failover-series.sh
# rolling update: терминал 1 — нагрузка 70 s, терминал 2 (на хосте, сразу после старта нагрузки) — замена реплик
docker compose --profile tools run --rm tester python3 student-tests/failover_load.py --duration 70 --label rolling-update --output evidence/rolling-update-load.json
APP_VERSION=v3 sh scripts/rolling-update.sh
# Состояние реплик в LB (UP/DOWN, счётчики): http://127.0.0.1:8404/stats
# Безопасная остановка (данные сохраняются в volume):
docker compose down
# Намеренное удаление учебных данных (удаляет volume с БД!):
docker compose down -v
Почему тесты отказа запускаются в контейнере tester. Публичный тест вызывает .sh-скрипт через subprocess.Popen, а Windows не умеет исполнять .sh. Поэтому failover/persistence запускаются в контейнере tester: там есть Python, make и docker CLI, а BASE_URL = http://lb:8080 (тот же балансировщик, только изнутри Docker-сети). Сами тесты не менялись. На Linux те же команды можно запускать прямо с хоста.
Про APP_VERSION. rolling-update.sh переводит реплики на образ messenger-lab3-api:$APP_VERSION. Последний прогон перевёл стенд на v3. Дальнейшие docker compose up нужно выполнять с тем же APP_VERSION=v3, иначе Compose пересоздаст реплики на образе dev.
Переменные .env.example → реальная конфигурация:
.env.example |
Где используется |
|---|---|
APP_HOST, APP_PORT |
заданы в compose.yaml (0.0.0.0:8080) |
SESSION_TTL_SECONDS |
api (по умолчанию 3600) |
DATABASE_URL_FILE |
/run/secrets/database_url у api и migrate |
SESSION_STORE |
valkey: сессии в PostgreSQL, cache-aside в Valkey (как в lab2) |
CACHE_URL_FILE |
/run/secrets/cache_url у api |
API_REPLICAS |
deploy.replicas сервиса api (по умолчанию 2) |
IDEMPOTENCY_TTL_SECONDS |
api (86400 = 24 ч) |
APP_ENV |
не используется приложением |
3. Архитектура и решения
client ──HTTP:8080──► HAProxy (lb) ──round-robin, проверка /health/ready раз в 1 s──► api-1 ─┐
│ DNS Docker 127.0.0.11: имя "api" → IP всех реплик api-2 ─┤
└─ X-Request-Id, повтор на другую реплику при отказе ... │
▼
сеть backend (internal): PostgreSQL (источник истины)
Valkey (кэш сессий)
Источник истины — PostgreSQL: пользователи, чаты, участники, сообщения, сессии (хеш токена), ключи идемпотентности. Valkey хранит только копию «хеш токена → пользователь» с TTL ≤ 60 s. Logout на одной реплике пишет в общий Valkey отметку revoked (tombstone), её сразу видят все реплики. Поэтому повторный вход при смене реплики не нужен: в failover-тесте 40 запросов /users/me одним токеном обслужили 2 разные реплики.
Как работает идемпотентность. Таблица idempotency_keys: первичный ключ (user_id, chat_id, method, key), request_hash = SHA-256 тела запроса, message_id. Всё делается в одной транзакции:
INSERT … ON CONFLICT DO UPDATE … WHERE created_at < now() - TTL RETURNING 1— «занять» ключ. Если тот же ключ в этот момент занимает незавершённая транзакция на другой реплике, PostgreSQL заставляет вторую транзакцию ждать на уникальном индексе. Так одновременные повторы выстраиваются в очередь в самой БД, без блокировок в памяти API.- Ключ занят нами →
INSERTсообщения,UPDATEключа ссылкой на сообщение,COMMIT. Если что-то упало до COMMIT, откатываются обе записи: ни сообщения, ни ключа нет, и повтор выполнится заново. - Ключ уже был сохранён раньше → если хеш тела совпадает, возвращается
201с тем же сообщением и заголовкомIdempotent-Replayed: true; если тело другое —409. Ключ старше 24 ч можно использовать заново.
До всего этого повтор проходит проверку токена и членства в чате (посторонний получит 404). Область действия ключа: пользователь + метод + чат + ключ — тот же ключ у другого пользователя или в другом чате создаёт новое сообщение (проверено тестом).
Миграции: Сервис migrate стартует после того, как БД стала healthy, а API — только после того, как migrate успешно завершился (depends_on: service_completed_successfully). Повторный запуск печатает SKIP. Миграция 003 только добавляет таблицу, поэтому её можно применить, пока работает старая версия API. Правило на будущее: удалять/переименовывать колонки — отдельным релизом, когда ни одна реплика их уже не использует (expand → deploy → contract). Автоматической проверки совместимости нет — это ограничение.
Транзакционные границы: создание чата с участниками — одна транзакция (из lab2); сообщение + ключ идемпотентности — одна транзакция; отзыв сессии — UPDATE в PostgreSQL, затем tombstone в Valkey.
4. Health, timeouts и обнаружение отказа (уровень 4)
| Параметр | Значение | Где |
|---|---|---|
/health/live |
200, только «процесс жив» | app/main.py |
/health/ready |
200, если SELECT 1 в PostgreSQL успешен и нет drain; иначе 503. Valkey не критичен: без него запросы идут в PostgreSQL |
app/main.py |
| Активная проверка LB | inter 1s, fall 2, rise 2, timeout check 1s (раз в секунду; 2 неудачи подряд → DOWN; 2 успеха → UP) |
infra/haproxy/haproxy.cfg |
| Пассивная проверка LB | observe layer4 error-limit 1 on-error mark-down: первая же ошибка соединения на реальном запросе сразу переводит сервер в DOWN |
там же |
| DNS-обновление списка реплик | hold valid 2s (резолвер Docker 127.0.0.11) |
там же |
| Таймауты LB | connect 1 s, server 10 s, http-request 10 s, keep-alive 10 s, client 30 s | там же |
| Повторы в LB | retries 2, option redispatch 1, retry-on conn-failure empty-response 503. Повтор уже отправленного запроса запрещён для POST (кроме POST сообщения с Idempotency-Key) и для DELETE |
там же |
| Приложение | statement_timeout 5 s, ожидание соединения из пула 3 s, connect 3 s; uvicorn keep-alive 30 s (больше, чем 10 s у LB — соединение первым закрывает LB) | compose.yaml, app/server.py |
| SIGTERM | drain 3 s (readiness 503, Connection: close), затем закрытие порта и ожидание текущих запросов ≤ 8 s; stop_grace_period: 15s > 3 + 8 |
app/server.py, compose.yaml |
| Docker healthcheck API | каждые 2 s, 2 неудачи | compose.yaml |
Как таймауты согласованы между собой: timeout server LB (10 s) больше, чем БД может держать запрос (5 s statement + 3 s ожидание пула), поэтому LB не обрывает запрос, который приложение ещё может успешно завершить. Drain (3 s) больше, чем время, за которое LB замечает 503 (≈ 2–3 s), поэтому к моменту закрытия порта новые запросы на реплику уже не идут.
Максимальное время обнаружения отказа (по конфигурации):
- процесс упал (connection refused/reset) — на первом же реальном запросе (
observe layer4), сам запрос тут же повторяется на другой реплике; если трафика нет — активная проверка, ≤inter × fall= 2 s; - процесс жив, но не готов (нет БД, идёт drain) — ≤
inter × fall + timeout check≈ 3 s; - процесс завис (не отвечает вовсе) — ≤ 2 × (1 s интервал + 1 s таймаут проверки) ≈ 4 s; запросы, уже отправленные на зависшую реплику, ждут до
timeout server= 10 s.
Что видно при docker stop реплики: в логе HAProxy Server api/apiN is DOWN, reason: Layer7 wrong status, code: 503, затем в логе API drain finished: closing listener, контейнер завершается с Exited (0). Сам docker stop занимает ≈ 4 s (окно действия 4.13 и 4.04 s в evidence/failover-stop-*.json). При SIGKILL (kill-one.sh) код выхода 137.
5. Доказательства критериев
Все прогоны — 2026-10-13, 14:49–14:58 UTC, на стенде из раздела 6.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл |
|---|---|---|---|
| Публичный smoke | make test (хост → localhost:8080) |
PASS: lab3 public API scenario |
evidence/public-tests.txt |
| Структура контракта | make check |
PASS | evidence/public-tests.txt |
| ≥2 реплики, одна точка входа, общая БД и сессии | docker compose ps; 4 запроса подряд через LB; 40× /users/me одним токеном в failover-тесте |
2 контейнера api; X-Instance-Id чередуется fcae2c6047af / 1ff54c0efa0c; observed_instances_before: 2, без повторного входа |
evidence/public-tests.txt |
| Остановка любой одной реплики, восстановление ≤10 s | make test-failover ACTION_SCRIPT=scripts/stop-one.sh дважды — по разу для каждой реплики (в tester) |
оба PASS; failed_attempts: 0; first_recovery_seconds 4.4 и 4.52; в docker ps -a Exited (0) сначала у 1ff54c0efa0c, потом у fcae2c6047af — остановлен реальный контейнер |
evidence/public-tests.txt |
| Повтор с тем же ключом без дублей, в т.ч. во время отказа | resilience.py повторяет неопределённый POST тем же ключом; smoke: повтор = то же сообщение, другое тело = 409 |
PASS, дублей нет | evidence/public-tests.txt |
| Persistence | make test-persistence ACTION_SCRIPT=scripts/restart.sh |
PASS, прежний токен действует; StartedAt у db, valkey, обеих api и lb — после запуска hook (14:50:49–14:51:02), volume messenger-lab3_postgres_data на месте |
evidence/persistence.txt |
| 4: health/readiness/timeouts/SIGTERM согласованы, LB исключает backend | конфигурация + docker stop реплики |
раздел 4; реплика перестаёт получать запросы через 0.87–0.99 s после начала docker stop; выход с кодом 0 |
раздел 4, evidence/failover-stop-*.json |
| 4: поочерёдная остановка каждой реплики под нагрузкой: RPS, ошибки, время восстановления | student-tests/run-failover-series.sh (stop и kill для каждой реплики, с восстановлением предыдущей) |
таблица в разделе 6; 1 ошибка на 4 прогона, потерь и дублей 0 | evidence/failover-*.json, evidence/failover-series.txt |
| 4: параллельные запросы с одним ключом | student-tests/idempotency_concurrency.py (10 раундов × 16 одновременных POST с одним ключом) |
в каждом раунде 1 сообщение и 15 ответов-повторов; все 10 раундов прошли через 2 реплики; другое тело → 409; ключ не мешает другому пользователю/чату | evidence/idempotency-concurrency.json |
4: CPU/RAM-лимиты, нет портов API наружу, нет container_name, секреты только где нужны |
compose.yaml |
лимиты у всех сервисов; у api нет ports; db/valkey в internal-сети; у LB нет секретов (таблица в разделе 2) |
compose.yaml |
| 4: rolling update под нагрузкой, однократные совместимые миграции | APP_VERSION=v3 sh scripts/rolling-update.sh + параллельно failover_load.py (70 s, 4 потока) |
обе реплики v2 заменены на v3 (новые a9d3dc77f288, ea0e32824716); 4 826 подтверждённых записей, 0 ошибок, максимальная пауза между записями 0.054 s; миграции один раз, все SKIP |
evidence/rolling-update.txt, evidence/rolling-update-load.json |
| Нагрузка (справочно) | tests/load.py --duration 30 --concurrency 4, 4 прогона |
142–154 успешных RPS (среднее ≈ 148), 0 ошибок, p50 ≈ 15 ms, p95 76–86 ms, p99 98–138 ms | evidence/load*.json, evidence/load-docker-stats.txt |
Почему X-Instance-Id — не единственное доказательство: заголовок пишет само приложение. Поэтому после каждого отказа сохранён вывод docker ps -a: видно, что Exited именно тот контейнер, чей ID был в TARGET_INSTANCE_ID, а остальные сервисы продолжают работать.
6. Эксперименты и отказы
Стенд. Docker Desktop 29.3.0 (WSL2), хост 14 CPU / 7.4 GiB RAM. Лимиты: каждая api — 0.5 CPU / 256 MiB, db — 1 CPU / 512 MiB, valkey — 0.25 CPU / 128 MiB, lb — 0.5 CPU / 128 MiB. Генератор нагрузки — в контейнере tester в той же Docker-сети. Данные: синтетические, каждый прогон создаёт своих пользователей и чат.
Профиль нагрузки (student-tests/failover_load.py): закрытый цикл, 4 потока, 30 s, без прогрева; 50 % — POST сообщения, 50 % — GET истории (limit 20); таймаут клиента 3 s. Клиент ведёт себя как настоящий: если результат неизвестен, повторяет POST с тем же ключом и текстом. Через 8 s запускается action-скрипт против выбранной реплики; после прогона она возвращается (start-api.sh), и следующий прогон бьёт по другой. В конце вся история чата читается заново и проверяется: каждое подтверждённое сообщение на месте, одинаковых текстов нет.
Гипотеза. При docker stop (SIGTERM) клиенты не увидят ошибок: реплика сначала уходит из пула, потом закрывается. При SIGKILL возможны единичные ошибки: запросы, которые были внутри убитого процесса, оборвутся; большую часть из них HAProxy повторит на другой реплике. После отказа пропускная способность упадёт, потому что API упирается в CPU-лимит реплики.
RPS ниже — все успешные запросы (чтение + запись) в секунду. «Во время» — окно, пока выполняется action-скрипт (≈ 4 s для stop, < 1 s для kill).
| Воздействие | Что ожидаем | Что наблюдали: успешные RPS до → во время → после; p95 до → после | Восстановление / потеря данных |
|---|---|---|---|
stop-one реплика 1 (SIGTERM) |
0 ошибок | 130.6 → 79.1 → 93.5; p95 86 → 99 ms; ошибок 0 | реплика перестала получать запросы через 0.99 s; макс. пауза между записями 0.40 s; 1 525 записей, потерь и дублей 0; Exited (0) |
stop-one реплика 2 (SIGTERM) |
0 ошибок | 149.2 → 108.0 → 87.9; p95 81 → 100 ms; ошибок 0 | 0.87 s; пауза 0.39 s; 1 606 записей, потерь 0; Exited (0) |
kill-one реплика 1 (SIGKILL) |
единичные ошибки | 106.1 → 44.3 → 89.4; p95 99 → 100 ms; ошибок 0 | 0.06 s; пауза 0.19 s; 1 398 записей, потерь 0; Exited (137) |
kill-one реплика 2 (SIGKILL) |
единичные ошибки | 118.8 → 23.8 → 74.2; p95 94 → 104 ms; 1 ошибка (через 0.13 s после kill) | 0.11 s; пауза 0.29 s; 1 273 записи, потерь и дублей 0; Exited (137) |
| Rolling update api ×2 → v3 | 0 ошибок | 137.8 RPS в среднем за 70 s, ошибок 0; по секундам не ниже 52 успешных запросов | макс. пауза между записями 0.054 s; 4 826 записей, потерь и дублей 0 |
| Restart всего стенда | данные и токен сохраняются | make test-persistence PASS |
на время перезапуска сервис недоступен (ожидаемо: останавливаются и LB, и БД); БД поднялась в 14:50:49, LB — в 14:51:02 (≈ 13 s) |
Реплики: 1 = fcae2c6047af, 2 = 1ff54c0efa0c.
Выводы.
- Graceful stop работает: 0 ошибок в обоих прогонах. Реплика ещё ≈ 1 s обслуживает запросы во время drain, потом HAProxy убирает её из пула.
- Гипотеза про SIGKILL подтвердилась: в одном прогоне 0 ошибок, в другом 1 ошибка из ~2 500 запросов. Почти все оборванные запросы HAProxy сам повторил на другой реплике (
retry-on conn-failure empty-response). Единственную ошибку клиент повторил с тем же ключом — сообщение не потерялось и не задвоилось. Повторять в LB можно только потому, что GET безопасен, а POST сообщения защищёнIdempotency-Key. Для остальных POST повтор в LB отключён. - С одной репликой пропускная способность падает на ~30–40 % (с ~106–149 до ~74–94 RPS).
docker statsпод нагрузкой: обе api ≈ 49 % CPU при лимите 0.5 CPU, то есть упираются в свой лимит; db ≈ 34 % от 1 CPU, lb ≈ 22 %. Узкое место — CPU API, а не БД. Падение меньше двукратного, потому что часть времени запроса уходит на сеть, БД и сам генератор нагрузки на том же хосте. - Rolling update прошёл без ошибок: новая реплика добавляется и проходит проверки до того, как останавливается старая, поэтому в пуле всегда минимум 2 рабочие реплики.
Ограничения измерений. Закрытый цикл (coordinated omission: пока клиент ждёт медленный ответ, он не шлёт новые, поэтому задержки занижены). Каждый сценарий отказа — один прогон по 30 s без повторов. Генератор нагрузки на том же хосте и делит с ним CPU. RPS «во время» посчитан по окну < 5 s и шумный. first_recovery_seconds публичного теста считается от начала hook до первой записи после его окончания, а сам docker stop с drain длится ≈ 4 s — реальный перерыв в записи намного меньше (макс. пауза 0.39–0.40 s).
7. Ограничения и следующие шаги
- Выдерживается отказ одной API-реплики (процесса/контейнера). Не выдерживаются: отказ PostgreSQL (один экземпляр без реплики), отказ HAProxy (единственная точка входа) и потеря Docker-хоста — всё работает на одном хосте. Отказ Valkey выдерживается: API переходит на PostgreSQL (проверялось в lab2).
- Кэш сессий очищается (
FLUSHDB) при старте каждого процесса API — решение из lab2 против потерянной инвалидации. С несколькими репликами каждый рестарт/rolling update сбрасывает общий кэш: на корректность не влияет, но ненадолго увеличивает нагрузку на PostgreSQL. - Время сообщения —
now()начала транзакции PostgreSQL (одни часы для всех реплик). Транзакции могут фиксироваться не в порядкеcreated_at, поэтому читатель, листающий историю во время конкурентной записи, может не увидеть сообщение, вставленное «позади» курсора. При чтении уже неизменной истории пропусков и повторов нет. - Старые ключи идемпотентности автоматически не удаляются: через 24 ч ключ переиспользуется, индекс по
created_atподготовлен для будущей периодической очистки. X-Instance-Idраскрывает hostname контейнера (короткий Docker ID) — по немуstop-one.shнаходит контейнер. В lab7 его стоит заменить случайным псевдонимом.rolling-update.shиспользуетdocker compose --scale, поэтому номера контейнеров растут (api-5, api-6…). Автоматического отката нет: при ошибке скрипт останавливается, старые реплики продолжают работать.- Контейнер
testerмонтируетdocker.sock— это полный доступ к Docker-хосту; допустимо только на учебном стенде. - Тесты lab2 (
level4.py,db_checks.py) не перенесены: они рассчитаны на топологию lab2 (API напрямую на :8080, отдельныйapi_short_ttlна :8081).
Вопросы из README
Чем отказ процесса отличается от отказа узла? Процесс — одна программа (у нас один контейнер API). Если он упал, остальные реплики на том же хосте работают, а HAProxy переключается на них — это и проверено в лабораторной. Узел — целая машина (хост Docker). Если она пропала, пропадает всё, что на ней запущено: обе реплики, HAProxy, PostgreSQL. У нас все компоненты на одном хосте, поэтому отказ узла стенд не выдерживает — для этого нужны несколько машин и реплицированная БД (трек 2 на «5»).
Почему depends_on/healthcheck сами по себе не являются балансировщиком?
depends_on влияет только на порядок запуска: «не запускай API, пока БД не healthy». Docker healthcheck только ставит метку healthy/unhealthy на контейнер и никуда не направляет трафик. Ни то, ни другое не принимает запросы клиента, не распределяет их между репликами, не убирает упавшую реплику из маршрута и не повторяет запрос. Это делает HAProxy: он принимает запрос, выбирает живую реплику, сам проверяет её /health/ready и при ошибке повторяет запрос на другой.
Какие POST можно повторять после timeout и что защищает Idempotency-Key?
После timeout клиент не знает, выполнился запрос или нет. Повторять безопасно только тот запрос, повтор которого не создаст второй результат. У нас это POST /chats/{id}/messages с Idempotency-Key: сервер хранит ключ в той же транзакции, что и сообщение, и на повтор отдаёт уже созданное сообщение (на другое тело — 409). Ключ защищает от дублей при повторе — в том числе когда повтор пришёл на другую реплику или одновременно с оригиналом. Остальные POST (/users, /chats, /auth/sessions) ключа не имеют, их повтор может создать второй объект, поэтому HAProxy их не повторяет, если запрос уже ушёл в приложение. (Ошибку установления соединения можно повторять всегда — запрос до приложения не дошёл.)
Что сломается при увеличении числа API, если сессии хранятся в локальной памяти?
Пользователь вошёл через реплику 1 — токен есть только в её памяти. Следующий запрос round-robin отправит на реплику 2, а она такого токена не знает → 401, пользователя «выкинет». Logout на одной реплике не отзовёт токен на другой. При падении/рестарте реплики все её сессии пропадут. Sticky session лишь маскирует это (и всё равно теряет сессии при отказе), поэтому у нас сессии в PostgreSQL + общий Valkey.