68 KiB
Отчёт — лабораторная 3
- Автор, группа: Бакулин, БПИ2301
- Целевая оценка; выбранный трек 5, если нужен: 5, трек 1 «Цена масштабирования». Уровни 3 и 4 выполнены полностью.
- Commit/PR: ветка
solution/bpi2301-bakulin; ссылка на PR — после публикации. - Использованные источники, библиотеки и помощь ИИ: HAProxy 3.4 Configuration Manual (
server-template,resolvers,http-check,retry-on,maxconn,timeout queue,http-error), спецификация Docker Compose (deploy.replicas,resources,healthcheck.start_interval,depends_on: service_completed_successfully), docker rollout v0.14 (MIT), документация PostgreSQL 18 (INSERT … ON CONFLICT,FOR UPDATE SKIP LOCKED,pg_stat_database,pg_stat_activity), документация Go (net/httpServer.Shutdown, учёт CPU-лимита контейнера вGOMAXPROCS), документация Kubernetes о завершении пода иpreStopи AWS ELB о deregistration delay (обоснование drain-задержки), Site Reliability Engineering, гл. 21–22 (Handling Overload, Addressing Cascading Failures), Bronson et al. «Metastable Failures in Distributed Systems» (HotOS 2021), G. Tene о coordinated omission (open-loop генератор). Библиотеки:github.com/gin-gonic/ginv1.12.0,github.com/google/uuidv1.6.0,github.com/jackc/pgx/v5v5.11.0 (драйвер и пул),github.com/pressly/goose/v3v3.27.0 (миграции),github.com/redis/go-redis/v9v9.23.0 (клиент Valkey),golang.org/x/crypto/argon2, в тестахgithub.com/testcontainers/testcontainers-gov0.39.0, для графиков matplotlib 3.10.3. ИИ-ассистент использовался как парный программист: генерация кода, тестов и черновиков документации по моим архитектурным решениям с последующим ревью каждого модуля и переработкой по замечаниям; выбор стека, структура проекта, модель данных, обработка ошибок, логирование и границы модулей определены мной; все проверки воспроизведены мной вручную.
Запуск из чистого clone
Версии, на которых выполнялись проверки: Go 1.27.1 (go.mod), Docker Desktop 28.5.1 с Compose v2 (нужен 2.24+ из-за env_file … required: false), Python 3.13 для публичных проверок (нужен 3.9+), GNU Make. Образы закреплены digest'ами: haproxy:3.4.7-alpine3.24, postgres:18.6-alpine3.24, valkey/valkey:9.1.2-alpine3.24 в compose.yaml, golang:1.27.1-alpine3.23 и alpine:3.23 в Dockerfile.
make secrets # ./secrets: пароли PostgreSQL и Valkey и URL для API; существующие файлы не перезаписываются
make up # docker compose up -d --build --wait: postgres, valkey → migrate (один раз) → 2 реплики api; lb готов, когда через него отвечает реплика
make check PYTHON=python
make test PYTHON=python
make test-failover ACTION_SCRIPT=scripts/stop-one.sh PYTHON=python # на Windows: scripts/stop-one.cmd
docker compose start api # вернуть остановленную реплику
make test-persistence ACTION_SCRIPT=scripts/restart.sh PYTHON=python # на Windows: scripts/restart.cmd
make instances # какой контейнер отвечает под каким X-Instance-Id
make rollout # rolling update без простоя (docker rollout, скачивается с проверкой SHA-256)
make concurrency # гонки отправки и общий Idempotency-Key через разные реплики
make unit # собственные тесты; нужен Docker: тесты поднимают свои PostgreSQL и Valkey
Число реплик: API_REPLICAS=3 make up. Если порт 8080 занят — PUBLISH=127.0.0.1:28080 make up и BASE_URL=http://localhost:28080 для проверок; страница статистики HAProxy — http://127.0.0.1:8404/ (STATS_PUBLISH).
Эксперименты (настройки и генератор нагрузки — в compose.bench.yaml, скрипты подключают его сами):
make failover-load KIND=stop REPLICA=1 # отказ реплики под нагрузкой: stop (SIGTERM) или kill (SIGKILL)
make rollout-load # rolling update под нагрузкой
make bench SERIES="scripts/bench/series/A.conf …" RATES=400,800,… # трек 1; каждый прогон удаляет данные стенда
make plot PYTHON=<python с matplotlib из requirements-bench.txt>
Остановка и удаление данных. docker compose stop — graceful остановка всего стенда; make down — удалить контейнеры с сохранением volumes; make destroy (docker compose down -v) — намеренное удаление всех учебных данных. make bench тоже начинает каждый прогон с пустых volumes.
Архитектура и решения
edge data (internal: без выхода наружу)
клиент ──> lb (HAProxy 3.4) ──roundrobin──> api × N (Go) ──pgxpool ≤10──> postgres [pgdata] источник истины
127.0.0.1:8080 │ проверки /health/ready │ └──go-redis──────> valkey [valkeydata] сессии
127.0.0.1:8404 │ DNS Docker: server-template │
(статистика) └─ свои 502/503/504 в формате migrate (одноразовый, goose) ──> postgres
контракта loadgen (только эксперименты, compose.bench.yaml)
Реплики взаимозаменяемы: сессии лежат в Valkey, всё остальное — в PostgreSQL; ни одна реплика не хранит состояния, от которого зависит корректность (README:18). Порты публикует только lb, и только на loopback; у api нет ports и container_name, число реплик — deploy.replicas: ${API_REPLICAS:-2} (README:37). Сеть data объявлена internal: хранилища недоступны ни снаружи, ни из lb.
Балансировщик: Compose + HAProxy
Выбор и альтернативы:
- Nginx OSS проверяет backend'ы только пассивно (
max_fails/fail_timeout): упавшую реплику он замечает по неудачному клиентскому запросу, периода проверки нет, а README:35 требует назвать период и время обнаружения. Главное — он не видит readiness: реплика, которая по SIGTERM уже отвечает/health/ready503, продолжает получать запросы до закрытия порта. Активныйhealth_checkесть только в NGINX Plus. - Traefik с docker-провайдером требует смонтированный
docker.sock, то есть фактически root на хосте — против README:37 («общие только там, где нужно»). - Docker Swarm даёт rolling update и самовосстановление из коробки, но
stack deployне собирает образ, не читает.envи игнорируетdepends_on(порядок migrate → api пришлось бы писать в коде), а встроенная балансировка (IPVS) делит TCP-соединения, не HTTP-запросы, без повторов и без HTTP-проверок. Для одного хоста Compose продолжает lab2 и запускается одной командой.
HAProxy (infra/haproxy/haproxy.cfg):
- Обнаружение реплик —
server-template api 10 api:8080+resolvers docker(DNS Docker, опрос раз в 1 с,hold obsolete 0s): новые, перезапущенные и заменённые реплики появляются без перезагрузки LB, исчезнувший адрес уходит сразу.init-addr none— LB стартует раньше реплик. Десять слотов — до пяти реплик, удвоенных на время rolling update. - Активная проверка
GET /health/ready:inter 1s, после первой неудачиfastinter 500ms,fall 2/rise 2,timeout check 2s. Расчётное время обнаружения не готовой реплики — до 1,5 с (+ до 2 с, если проверка зависла до таймаута). - Балансировка
roundrobin, без sticky-сессий (README:19). Запросы разные по весу (вход с Argon2id тяжелее GET); при перекосеbalance leastconnменяется одним словом — в экспериментах перекоса между репликами не видно (раскладка по alias вseconds.csv). - Повторы только при ошибке соединения:
retry-on conn-failure,retries 2,option redispatch 1— повтор уходит на другую реплику. Это безопасно для любогоPOST: запрос не дошёл до API. Таймаут или пустой ответ не повторяются — запись могла уже произойти (contracts/README:43). - Ограничение на реплику (улучшение C трека 1):
maxconn 20на сервер иtimeout queue 300ms. Сверх 20 одновременных запросов на реплику запросы ждут в очереди LB не дольше 300 мс, затем получают 503. 20 = 10 соединений пула реплики + запас на запросы без БД; эта связь настроек LB и пула — осознанная. - Свои ошибки LB (502/503/504) — JSON в формате контракта с
request_id;X-Instance-Idу них нет, так как ни одна реплика не отвечала (contracts/README:39). - X-Request-Id: LB генерирует id (32 hex) и ставит его в запрос (
http-request set-header, перезаписывая значение клиента); API сохраняет входящий id, если он соответствует^[A-Za-z0-9-]{1,64}$, иначе генерирует свой. Один id проходит через лог LB, лог реплики, заголовок и тело ошибки; повтор на другую реплику идёт под тем же id. Клиент подставить свой id не может: API доступен только через LB. - Лог HAProxy пишет реплику, alias и request id каждого запроса — по ним находится строка в логе реплики. Страница статистики на
127.0.0.1:8404показывает состояние и последнюю проверку каждой реплики.
X-Instance-Id
Случайный alias процесса — 8 байт crypto/rand в hex, задаётся при старте и не меняется до выхода (contracts/README:39, задел на lab7: hostname/IP не раскрываются). Ставится первым middleware, поэтому есть на каждом ответе API, включая ошибки и health. Связь alias ↔ контейнер показывает make instances (scripts/api-instances.sh спрашивает каждый работающий контейнер через docker exec … wget /health/live). Перезапуск процесса даёт новый alias.
SIGTERM, readiness и таймауты
| Параметр | Значение | Где |
|---|---|---|
| Проверка LB | GET /health/ready каждую 1 с (0,5 с после неудачи), DOWN после 2 неудач, UP после 2 удач, таймаут 2 с | haproxy.cfg |
| /health/ready | 503 при shutdown или если PostgreSQL/Valkey не отвечают за общий бюджет 1 с | internal/health |
| По SIGTERM | readiness → 503, процесс продолжает обслуживать 2 с (APP_DRAIN_DELAY), затем http.Server.Shutdown с таймаутом 8 с |
internal/server |
| Docker | stop_grace_period: 15s > 2 + 8 с |
compose.yaml |
| Дедлайн запроса API | 5 с; WriteTimeout 10 с, чтобы 503 успел записаться |
internal/app, internal/server |
| LB → API | timeout connect 1s, timeout server 7s (> 5 с: медленный запрос заканчивается 503 самого API с причиной в логе; 504 LB — только для зависшей реплики) |
haproxy.cfg |
| PostgreSQL | пул 10 на реплику, statement_timeout 5 с, idle_in_transaction_session_timeout 10 с, connect и DNS 1 с |
internal/platform/postgres |
Drain-задержка (2 с) больше расчётного времени обнаружения LB (1,5 с), поэтому LB выводит реплику из ротации раньше, чем она закрывает порт. Измерено (evidence/failover/stop-*): от SIGTERM до DOWN в HAProxy — 1,43 и 0,96 с. При SIGKILL реплика исчезает из DNS Docker и LB переводит слот в MAINT по резолверу — 0,77 и 0,91 с после выхода процесса; запросы, попавшие на мёртвый адрес в этом окне, LB повторяет на другой реплике (ошибка соединения).
Так же устроено в продакшене: в Kubernetes под при удалении сначала исключается из Endpoints, а preStop-задержка держит процесс живым, пока это доходит до балансировщиков; AWS ELB/ALB использует deregistration delay. Общий принцип — задержка дренажа больше времени, за которое балансировщик узнаёт об остановке.
Миграции
Схема применяется одноразовым сервисом migrate (cmd/migrate, тот же образ со своим entrypoint): он ждёт здоровый PostgreSQL, применяет миграции goose под session advisory lock и завершается; api стартует только после service_completed_successfully (README:18 — отдельно, не гонкой реплик). API схему больше не меняет. Правило совместимости для rolling update (README:38): новые миграции выполняются, пока старые реплики ещё работают, поэтому миграция релиза только добавляет; удаление и переименование переносятся в следующий релиз. Миграция lab3 — новая таблица, старый код её не видит.
Общая идемпотентность отправки
Таблица message_idempotency_keys (migrations/00002_message_idempotency_keys.sql): PK (user_id, chat_id, key), FK (chat_id, message_id) → messages, индекс по created_at. Область ключа по контракту — пользователь + метод + путь чата + ключ (contracts/README:40); ключ принимает только POST /chats/{chat_id}/messages, поэтому метод и путь однозначно заданы чатом. Ключи вынесены в отдельную таблицу: они не атрибут сообщения, а инфраструктура вокруг него.
Порядок проверок POST /chats/{chat_id}/messages: сессия (middleware, 401) → chat_id (400) → заголовок Idempotency-Key: ровно одно значение [A-Za-z0-9._:-]{1,128} (400) → JSON (400) → членство (404, как у несуществующего чата) → текст (400) → запись. Повтор проходит те же проверки заново: отозванная сессия или потерянный доступ не получают сохранённый результат (contracts/README:42).
Запись — один SQL-оператор (CTE): вставка ключа ON CONFLICT … DO UPDATE … WHERE created_at < now() - TTL и вставка сообщения из RETURNING. Ключ и сообщение пишутся атомарно (contracts/README:42), блокировка ключа не переживает сетевого обмена с репликой. Конкурентный второй запрос с тем же ключом ждёт коммита первого на уникальном индексе и получает пустой claimed. Тогда вторым оператором читается сохранённое сообщение (снимок первого оператора не видит только что закоммиченный ключ). Тот же текст — 201 и то же сообщение; другой текст — 409 (contracts/README:41); сравнение содержания — Message.SameContent. Ключ старше 24 ч (IDEMPOTENCY_TTL_SECONDS) перехватывается новым сообщением.
Чистка: каждая реплика раз в 10 мин удаляет ключи старше TTL + 1 мин пачками по 1000 (DELETE … WHERE (…) IN (SELECT … FOR UPDATE SKIP LOCKED LIMIT 1000)): чистильщики разных реплик и запросы, держащие ключ, не ждут друг друга. Запас в минуту гарантирует, что ключ, который запрос только что увидел действующим, не исчезнет до чтения сохранённого сообщения (оба now() — часы одного PostgreSQL, между операторами доли секунды при дедлайне 5 с).
Проверено: 20 параллельных запросов с одним ключом — одно сообщение (TestConcurrentAppendOnceSameKeyStoresOneMessage); два приложения над общими хранилищами — одно сообщение (TestConcurrentReplaysAcrossTwoAppsCreateOneMessage); через LB 20 раундов × 8 параллельных попыток на соединениях — 20 сообщений, ответы двух разных реплик (evidence/concurrency.json).
Rolling update
make rollout (scripts/rollout.sh) использует готовый docker rollout v0.14 (MIT; скачивается по тегу и проверяется SHA-256): рядом со старыми репликами поднимается столько же новых, после того как все новые healthy (и ещё 4 с, чтобы LB их увидел), старые останавливаются через тот же SIGTERM-drain; если новая реплика не стала healthy, удаляются новые, старые продолжают работать — смеси версий не остаётся. Миграция, применённая до отката, остаётся: старые реплики работают на новой схеме, поэтому миграция релиза обязана быть совместимой со старым кодом (раздел «Миграции»); откат схемы — отдельное ручное решение, goose down может потерять данные, уже записанные в новую схему. Перед этим скрипт пересоздаёт migrate из нового образа без запуска: compose up внутри docker rollout применяет новые миграции один раз до старта новых реплик. Если какая-то реплика остановлена (например, после stop-one), скрипт отказывается работать: docker rollout заменил бы только её и оставил две версии.
Лимиты и конфигурация
compose.yaml — стенд с фиксированными лимитами у каждого сервиса: lb 0,5 CPU / 128M, api 1,0 CPU / 256M на реплику (GOMEMLIMIT=230MiB: Go не читает лимит cgroup), migrate 0,5 / 128M, postgres 1,0 / 512M (max_connections=150 = 10 слотов LB × пул 10 + migrate и psql), valkey 0,5 / 320M. Всё, что меняют эксперименты (лимиты API и PostgreSQL, пул, maxconn, лог LB, генератор нагрузки), — в compose.bench.yaml, который подключают только scripts/bench/*; без переменных он не меняет стенд.
Соответствие .env.example:
| Переменная | .env.example |
Реализация | По умолчанию |
|---|---|---|---|
| APP_HOST, APP_PORT, APP_ENV | да | как в lab2 | 0.0.0.0, 8080, lab |
| SESSION_TTL_SECONDS | да | срок сессии | 3600 |
| DATABASE_URL_FILE | да | файл с DSN, обязателен | /run/secrets/database_url |
| SESSION_STORE, CACHE_URL_FILE | да | не используются: сессии всегда в Valkey, кэша нет | — |
| API_REPLICAS | да | deploy.replicas сервиса api |
2 |
| IDEMPOTENCY_TTL_SECONDS | да | срок ключа сообщения | 86400 |
| SESSION_STORE_URL_FILE | нет | файл с URL Valkey, обязателен | /run/secrets/session_store_url |
| APP_DRAIN_DELAY | нет | обслуживание после SIGTERM с readiness 503 | 2s |
| DB_MAX_CONNS | нет | пул PostgreSQL на реплику (переменная трека 1) | 10 |
| APP_DEBUG_ADDR | нет | внутренний expvar-listener для экспериментов, наружу не публикуется | выключен |
| APP_LOG_LEVEL, APP_SHUTDOWN_TIMEOUT, APP_MAX_BODY_BYTES | нет | как в lab2 | info, 8s, 65536 |
Роли стенда:
| Роль | Сервис | Версия | Health/readiness | Volume | Сеть/порт | Credentials |
|---|---|---|---|---|---|---|
| load_balancer | lb | haproxy 3.4.7-alpine3.24 @digest | wget /health/ready через себя |
— | edge; 127.0.0.1:8080, статистика 127.0.0.1:8404 |
— |
| api | api × N | сборка из исходников | /health/ready (PG + Valkey) |
— | edge + data, без портов | secrets database_url, session_store_url |
| migrations | migrate | тот же образ | одноразовый | — | data | secret database_url |
| postgres | postgres | 18.6-alpine3.24 @digest | pg_isready -h 127.0.0.1 |
pgdata |
data | secret postgres_password |
| redis_or_valkey | valkey | 9.1.2-alpine3.24 @digest | valkey-cli ping с паролем |
valkeydata (AOF) |
data | secret valkey_auth |
Что перенесено из lab2 и что изменено
Перенесено без изменений: модель данных и keyset-пагинация, Bearer-сессии в Valkey, Argon2id, формат ошибок, таймауты зависимостей. Изменено в lab3:
X-Instance-Idна каждом ответе;X-Request-Idпринимается от LB;- обязательный
Idempotency-Keyи таблица ключей,Send(ctx, actor, MessagePayload); - graceful shutdown с drain-задержкой;
- миграции вынесены из API в
cmd/migrate; DB_MAX_CONNS, внутренний expvar-listener (APP_DEBUG_ADDR) для экспериментов;tools/concurrency— вторая фаза: общий ключ через разные реплики;- новые
tools/loadgenиscripts/bench/*.
Исправления базы lab2: оба TestSessionExpiresAfterTTL (internal/app, internal/auth) ждут истечения с допуском — Valkey в VM Docker, его часы отстают от Windows на доли секунды; TestMigrateIsRepeatable считает файлы миграций, а не ждёт ровно одну.
CI (.github/workflows/app.yml): unit с race detector, затем стенд, smoke, persistence, failover со stop-one.sh, обе фазы concurrency, логи и down -v.
Доказательства критериев
Файлы уровней 3 и 4 сняты на одном стенде, поднятом с пустых volumes; в заголовке каждого файла — дата, commit и параметры хоста (Windows 11, Docker Desktop 28.5.1, WSL2-VM 8 vCPU / 12 GB, i5-1240P). Запуски под нагрузкой (evidence/failover, evidence/rollout) записывают то же в meta.json; все их времена — по часам VM Docker (docker inspect, compose logs --timestamps, генератор), часы Windows расходятся с ними на 0,3–0,6 с. После снятия код системы изменился в одном месте (99216ef): run закрывает listener API, если не открылся debug-порт; на работу стенда, отказы и нагрузку это не влияет.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
| Публичный smoke | make check, make test |
оба PASS (профиль lab3, включая идемпотентность) | evidence/smoke.txt |
| Стенд в compose.yaml, одна команда запуска; ≥2 API, одна точка входа, общие БД и сессии (README:25) | docker compose config --quiet, docker compose up -d --build --wait с пустых volumes |
migrate применил 2 миграции и завершился, 2 реплики api healthy; порты только у lb; \dt: 6 таблиц, включая message_idempotency_keys |
evidence/bootstrap.txt |
| Разные запросы одного пользователя — разные реплики без повторного входа (README:26) | 10 GET с одним токеном через LB; make instances |
alias чередуются c6f9…/0d2f… (round-robin), оба alias принадлежат разным работающим контейнерам |
evidence/bootstrap.txt |
| Остановка любой одной реплики: чтение и запись не позже 10 с, подтверждённое доступно (README:27) | make test-failover ACTION_SCRIPT=scripts/stop-one.cmd дважды |
PASS оба раза: 127 и 126 успешных записей, 0 неудачных попыток, первое восстановление через 4,6 и 5,2 с (метрика теста); первый раз остановлен lab3-api-2, второй — lab3-api-1 (instances до и после) |
evidence/failover.txt |
| Повтор POST с тем же ключом не создаёт дубль, в том числе конкурентный и через другую реплику (README:28) | make concurrency (фаза 2); TestConcurrentAppendOnceSameKeyStoresOneMessage, TestConcurrentReplaysAcrossTwoAppsCreateOneMessage, TestReplayWithDifferentBodyIs409, TestReplayRechecksSession |
20 раундов × 8 параллельных попыток с одним ключом — 20 сообщений, ответы двух реплик, другой текст — 409 | evidence/concurrency.json, evidence/concurrency.txt, evidence/tests.txt |
| make test, persistence и failover проходят (README:29) | make test-persistence ACTION_SCRIPT=scripts/restart.cmd |
PASS тем же токеном; StartedAt всех пяти контейнеров изменился |
evidence/persistence.txt |
| Гонки отправки | make concurrency (фаза 1) |
10 × 10 — 100 уникальных сообщений в порядке id | evidence/concurrency.json |
| Health/readiness, timeouts, SIGTERM согласованы; LB исключает backend; период и время обнаружения (README:35) | конфигурация (раздел выше), TestDrainKeepsServingWhileNotReady; make failover-load KIND=stop для каждой реплики |
период 1 с (0,5 с после неудачи), DOWN после 2 неудач; от SIGTERM до DOWN 1,43 и 0,96 с, порт закрыт через 2,0 с после SIGTERM; 0 ошибок | evidence/failover/stop-1, stop-2, evidence/tests.txt |
| Каждая реплика по очереди: RPS, ошибки, время восстановления (README:36) | `scripts/bench/failover.sh stop | kill 1 | 2` (50 записей/с, 60 с, отказ на 15-й с, возврат на 35-й) |
| Лимиты CPU/RAM, API без портов в обход LB, нет container_name (README:37) | compose.yaml, docker compose ps |
лимиты у каждого сервиса, ports только у lb |
compose.yaml, evidence/bootstrap.txt |
| Rolling update под нагрузкой, миграции один раз (README:38) | make rollout-load (50 записей/с, обновление на 15-й с) |
обе реплики заменены (exit 0), 3000/3000 подтверждено, 0 ошибок, ответы 4 разных процессов; migrations applied — один раз |
evidence/rollout |
| Выбранный трек 1 «Цена масштабирования» | серии A, A′, B, парный контроль и C (make bench, make plot), 3 повтора вперемешку |
1/2/4 реплики при одном бюджете — одна ёмкость, +33 % CPU API на запрос; точка насыщения — CPU PostgreSQL ~1400 запросов/с; удвоение CPU базы — 1200 → 2000; maxconn 20 — за насыщением 1013–1594 успешных/с вместо 93–484 |
evidence/track1 |
Эксперименты и отказы
Уровень 4: отказ реплики и rolling update под нагрузкой
Постоянная запись 50 сообщений/с одним пользователем в течение 60 с (tools/loadgen timeline); каждый неподтверждённый POST генератор повторяет с тем же ключом; в конце вся история читается обратно — каждое подтверждённое сообщение должно быть ровно один раз. Стенд — compose.yaml (2 реплики по 1 CPU), генератор работает в сети Docker и обращается к lb:8080.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|---|---|---|---|
docker stop реплики 1 (SIGTERM) на 15-й с |
readiness 503, LB выводит реплику до закрытия порта, ошибок нет | DOWN через 1,43 с после SIGTERM, порт закрыт через 2,0 с; 3000/3000 подтверждено, 0 ошибок, 0 повторов | после start UP через 0,57 с; 0 дублей, 0 потерь |
docker stop реплики 2 |
то же | DOWN через 0,96 с; 3000/3000, 0 ошибок | UP через 1,03 с; 0 дублей, 0 потерь |
docker kill реплики 1 (SIGKILL) |
обрыв соединений; не дошедшее до API LB повторяет на другой реплике; неподтверждённое генератор повторяет с ключом | адрес исчез из DNS, слот в MAINT через 0,77 с после выхода процесса; 3000/3000, 0 ошибок, 0 повторов генератора | UP через 0,47 с после старта; 0 дублей, 0 потерь |
docker kill реплики 2 |
то же | MAINT через 0,91 с; 3000/3000, 0 ошибок | UP через 0,68 с; 0 дублей, 0 потерь |
make rollout под нагрузкой на 15-й с |
замена обеих реплик без ошибок, миграции один раз | exit 0 за ~16 с, 3000/3000, 0 ошибок, ответы 4 процессов (2 старых, 2 новых); migrations applied один раз |
0 дублей, 0 потерь |
При 50 записях/с и ответах за единицы миллисекунд в момент SIGKILL в полёте почти никогда нет запроса, поэтому неподтверждённых POST не было. Такой запрос получил бы 502 от LB (повторять его LB не вправе), и генератор повторил бы его с тем же ключом; этот путь проверяют make test-failover и фаза 2 make concurrency. После перезапуска контейнера HAProxy возвращает слот в UP при повторном разрешении DNS, не дожидаясь rise 2; если процесс ещё не открыл порт, запрос получает отказ соединения и повторяется на другой реплике (retry-on conn-failure).
Трек 1. Цена масштабирования
Гипотезы (сформулированы до измерений)
- H1. Фиксированный бюджет. При одном и том же суммарном CPU/RAM API (2 CPU, 1 GiB) переход 1 → 2 → 4 реплики не увеличивает ёмкость (в пределах ±10 %), а хвост задержек ухудшает: у каждой реплики свои накладные расходы (GC, пул, рантайм), а дробный лимит 0,5 CPU троттлится квотой CFS внутри периода 100 мс. Реплики дают отказоустойчивость, а не производительность.
- H2. Рост ресурсов. Реплики фиксированного размера (1 CPU) увеличивают ёмкость почти линейно, пока она не упрётся в общий ресурс; ожидаемо — PostgreSQL с 1 CPU: его CPU у лимита, а ёмкость стоит, сколько реплик ни добавляй.
- H3. Скрытая переменная — пул. Пул задан на реплику (10), поэтому 4 реплики держат 40 соединений к БД против 10 у одной. Если пул одной реплики был узким местом, часть «выигрыша от реплик» — выигрыш от большего пула. Проверяется серией с фиксированным суммарным пулом.
- Контроль. Если узкое место — CPU PostgreSQL, удвоение его CPU поднимает ёмкость. Это проверка вмешательством, а не по корреляции «CPU у лимита».
- H4 (улучшение C). Без ограничения числа запросов на реплику перегрузка обрушивает успешную пропускную способность каскадом; с ограничением на LB (
maxconn) успешная пропускная способность за точкой насыщения держится около ёмкости, а лишняя нагрузка быстро получает 503.
Гипотеза H4 появилась из предварительных прогонов 2026-11-03 (вне evidence): за точкой насыщения успешных ответов становилось 7–300 в секунду вместо ~1300. Механизм виден в метриках: без ограничения HAProxy отдаёт в реплику тысячи одновременных запросов, они ждут пул внутри приложения; /health/ready ждёт в той же очереди и не укладывается в 2 с, LB выводит живую реплику, её нагрузка уходит на остальные, и они выпадают следом; запросы, брошенные клиентом по таймауту, база всё равно выполняет, а отменённые запросы рвут соединения пула (total_conns 10 → 1, +30–40 сессий PostgreSQL в секунду).
Методика
Всё, что ниже, выполняют скрипты из repo: tools/loadgen (генератор), scripts/bench/run-series.sh (серии), scripts/bench/plot.py (таблицы и графики), конфигурации — scripts/bench/series/*.conf, настройки — compose.bench.yaml.
- Стенд. Windows 11, i5-1240P (4 P- + 8 E-ядер, 16 потоков), ноутбук от сети, схема «Высокая производительность»; WSL2-VM 8 vCPU / 12 GB; Docker Desktop 28.5.1. Во время прогонов тяжёлой посторонней нагрузки нет (допускался браузер).
- Постоянные компоненты во всех сериях: HAProxy 1 CPU / 128M (
nbthread 1), PostgreSQL 1 CPU / 1 GiB (кроме контрольного прогона), Valkey 0,5 CPU / 320M, генератор 2 CPU / 1 GiB (GOMEMLIMIT=900MiB). Меняются только API (число реплик, CPU/RAM,GOMEMLIMIT, пул),maxconnи CPU PostgreSQL — каждая строка серии задаёт их явно. - Профиль. 80 % —
GET /chats/{id}/messages?limit=50(первая страница — 50 самых старых сообщений чата, размер ответа постоянен), 20 % —POSTсообщения со свежим ключом; пользователь и чат случайны (seed фиксирован). Повторов нет: каждая ошибка — ошибка. - Данные. Каждый прогон — свежий стенд с пустых volumes. Перед измерением через API: 200 пользователей, 100 чатов по 2–5 участников, по 50 сообщений в чате (5000 сообщений); вход каждого пользователя один раз — Argon2id в измерения не попадает. Прирост за прогон —
messages_written_during_stepsвsteps.json. - Генератор open-loop. Запрос i отправляется в момент start + i/rate, не дожидаясь ответов: медленная система не снижает себе нагрузку (нет coordinated omission). Таймаут клиента 2 с — класс
client_timeout, это граница генератора, а не таймаут системы. Ошибки LB (нетX-Instance-Id) считаются отдельно от ошибок API. Генератор работает в сети Docker и обращается кlb:8080: проброс порта Windows → WSL2 в путь не попадает. - Ступени. Прогрев 30 с на первой частоте, затем ступени по 30 с: 400, 800, 1000, 1200, 1400, 1600, 1800, 2000, 2400, 2800 запросов/с (C: 400–2400 через 400). В сериях A–B лестница останавливается после первой ступени, где система вышла из целевых границ (ошибок ≥ 1 % или p99 > 500 мс); контроль и C идут до конца (
STOP_ON_FAIL=0). - Ёмкость — наибольшая ступень, где ошибок < 1 %, p99 успешных ≤ 500 мс и ступень действительна: генератор отправлял по расписанию (p99 отставания ≤ 10 мс). Недействительная ступень означает, что ограничивал генератор, а не система; она в ёмкость не идёт и считается в
capacity.csvотдельно. - Повторы. 3 повтора каждой конфигурации, чередуются: сначала повтор 1 всех конфигураций, потом 2, потом 3, — медленный период хоста не ложится на одну конфигурацию. Итог — медиана повторов, на графике ёмкости — разброс.
- Контроль шума. Перед каждым прогоном — замер скорости хоста (фиксированный цикл в контейнере с 1 CPU,
host_probe_sвmeta.json) и CPU генератора на 1000 запросов на первой ступени; прогон с отклонением > 25 % от медианы помечается вcontrol.csv. - Что снимается (
evidence/track1/raw/<серия>/<конфигурация>/rep<k>/):steps.json(по ступеням: частоты, ошибки по классам, p50/p95/p99, отставание, alias),seconds.csv(посекундно),metrics.jsonl.gz(раз в секунду: HAProxy по репликам — сессии, очередь, состояние; expvar каждой реплики — пул pgx: ожидания, отменённые и новые соединения, GOMAXPROCS, память и GC),docker-stats.jsonl.gz(CPU/RAM контейнеров),postgres.jsonl.gz(коммиты, сессии, ожидания активных backend'ов),compose.log(переходы состояния LB, старт и остановка реплик),meta.json(commit, хост, параметры).
Повторить:
make bench SERIES="scripts/bench/series/A.conf scripts/bench/series/Aprime.conf scripts/bench/series/B.conf" RATES=400,800,1000,1200,1400,1600,1800,2000,2400,2800
STOP_ON_FAIL=0 make bench SERIES=scripts/bench/series/control.conf RATES=400,800,1000,1200,1400,1600,1800,2000,2400,2800
STOP_ON_FAIL=0 make bench SERIES=scripts/bench/series/C.conf RATES=400,800,1200,1600,2000,2400
make plot PYTHON=<python с matplotlib из requirements-bench.txt>
Серии
| Серия | Конфигурации | Вопрос |
|---|---|---|
| A (H1) | A1 1×2,0 CPU / 1 GiB, A2 2×1,0 / 512M, A4 4×0,5 / 256M; пул 10 на реплику | меняется ли ёмкость, если тот же бюджет резать на реплики |
| A′ (H3) | A′1 1×2,0 с пулом 20, A′4 4×0,5 с пулом 5; A′2 = A2 | сколько разницы внутри A даёт пул |
| B (H2) | B1, B3, B4 — реплики по 1 CPU / 512M, пул 10; B2 = A2 | где ёмкость перестаёт расти и что у лимита |
| Контроль | A2 и A2 с PostgreSQL 2 CPU поочерёдно | поднимает ли CPU базы потолок |
| C (H4) | 1 и 4 реплики по 1 CPU: maxconn 0 (без ограничения) и 20; на 1 реплике ещё 10 и 40; лестница 400–2400 без остановки |
что даёт ограничение за точкой насыщения и насколько важно значение 20 |
Лимиты в B4 и C на 4 репликах: API 4 + LB 1 + PostgreSQL 1 + Valkey 0,5 + генератор 2 = 8,5 CPU лимитов на 8 vCPU; лимиты — потолки, фактически контейнеры занимают меньше (см. CPU в summary.csv), но на таких ступенях конкуренция за vCPU возможна и видна по отставанию генератора.
Результаты
Сырые данные — evidence/track1/raw/, сводки и графики — evidence/track1/ (summary.csv по ступеням, capacity.csv, control.csv, cost.csv, PNG). Данные: 5000 сообщений перед измерением; за прогон пишется ещё от 3800 до 79 000 в зависимости от длины лестницы (messages_written_during_steps).
Шум стенда. Замер скорости хоста (один и тот же цикл) менялся от 2,55 до 4,86 с при медиане 2,93 с; 9 из 24 прогонов серий A–B отклонялись от медианы больше чем на 25 % по замеру или по CPU генератора (control.csv). Шум проявляется как короткие остановки всей VM: p99 на одной ступени подскакивает выше 500 мс при CPU компонентов далеко от лимита, затем снова падает. Поэтому ёмкость отдельного прогона по строгому правилу сильно шумит, и выводы строятся на трёх опорах: медиана ёмкости по повторам, CPU компонентов на запрос при одинаковой нагрузке (устойчиво к остановкам, считается только по непомеченным прогонам) и CPU компонентов на ступени 1400 запросов/с.
Ёмкость (наибольшая прошедшая ступень; по повторам и медиана):
| Конфигурация | API | Повторы | Медиана |
|---|---|---|---|
| A1 | 1 × 2 CPU, пул 10 | 1000, 1400, 1000 | 1000 |
| A2 = B2 = A′2 | 2 × 1 CPU, пул 10 | 1400, 1200, 1000 | 1200 |
| A4 | 4 × 0,5 CPU, пул 10 | 800, 1400, 1000 | 1000 |
| A′1 | 1 × 2 CPU, пул 20 | 1200, 1000, 400* | 1000 |
| A′4 | 4 × 0,5 CPU, пул 5 | 1400, 1000, 400* | 1000 |
| B1 | 1 × 1 CPU | 1000, 400**, 1200 | 1000 |
| B3 | 3 × 1 CPU | 1200, 400*, 1400 | 1200 |
| B4 | 4 × 1 CPU | 1400, 800*, 1400 | 1400 |
* прогон помечен контролем шума: ступень провалена при отставании генератора 11–23 мс. ** не шум, а метастабильный отказ (ниже).
CPU на запрос при 800–1000 запросах/с (мс CPU, медиана непомеченных прогонов; cost.csv):
| Конфигурация | API | PostgreSQL | HAProxy | Оценка потолка 1 CPU PostgreSQL |
|---|---|---|---|---|
| A1 (1 × 2) | 1,15 | 0,74 | 0,33 | ~1340 запросов/с |
| A2 (2 × 1) | 1,40 | 0,74 | 0,34 | ~1350 |
| A4 (4 × 0,5) | 1,53 | 0,75 | 0,34 | ~1330 |
| A′1 (1 × 2, пул 20) | 0,98 | 0,58 | 0,27 | ~1710 |
| A′4 (4 × 0,5, пул 5) | 1,52 | 0,72 | 0,32 | ~1390 |
| B1 (1 × 1) | 1,01 | 0,60 | 0,30 | ~1670 |
| B3 (3 × 1) | 1,60 | 0,76 | 0,36 | ~1320 |
| B4 (4 × 1) | 1,55 | 0,71 | 0,34 | ~1410 |
Оценка потолка — 1 CPU, делённый на цену запроса; при большей нагрузке цена немного падает, поэтому реальное насыщение — на 1400–1600. На ступени 1400 запросов/с CPU PostgreSQL — 90–102 % его лимита во всех конфигурациях, где ступень действительна (A1 91, A2 92, A4 97, A′1 90, A′4 97, B1 91, B3 102, B4 98–99 %), а ожидания соединения пула растут до 800–2000 в секунду.
H1 — подтверждена. При одном бюджете 2 CPU ёмкость 1, 2 и 4 реплик одинакова в пределах шума (медианы 1000–1200, отдельные прогоны 800–1400). Цена разбиения видна по CPU: одна реплика тратит 1,15 мс CPU на запрос, две — 1,40, четыре — 1,53 (+33 %): у каждой реплики свой рантайм, GC и пул, а при лимите 0,5 CPU GOMAXPROCS=2 и квота CFS троттлят процесс. В ёмкости это пока не видно, потому что раньше упирается база; но на 1400 запросах/с API A4 занят на 195 % из 200 %, а A1 — на 130 % из 200 %: при четырёх репликах API подходит к пределу одновременно с базой, и при ещё более мелких репликах ограничителем стал бы уже он. Реплики дают отказоустойчивость, а не производительность.
H2 — подтверждена, точка насыщения — CPU PostgreSQL около 1400 запросов/с. B1 упирается в собственный CPU (API ~100 % из 100 % уже на 1200–1400), B2 и дальше — уже в базу: на 1400 запросах/с PostgreSQL занят на 98–102 %, а API B3 — на 190 % из 300 %, B4 — на 205–212 % из 400 %. Медианы ёмкости 1000 → 1200 → 1200 → 1400 для 1–4 реплик, и рост останавливается: третья и четвёртая реплики добавляют CPU, который некуда потратить. HAProxy тратит ~0,33 мс на запрос — потолок около 3000 запросов/с на 1 CPU, он не ограничивает.
H3 — опровергнута: пул не скрытая переменная. Суммарный пул 20 вместо 10/20/40 не меняет ёмкость (A′1 и A′4 — медианы 1000, как A1 и A4) и не меняет цену запроса в базе: CPU PostgreSQL на запрос 0,58–0,76 мс при любом числе соединений. Ожидания пула на насыщении — следствие насыщения базы, а не причина: пока база не у лимита, их почти нет (A2 на 800 — 7 в секунду).
Метастабильный отказ базовой конфигурации. В B1, повтор 2, на 800 запросах/с (ниже ёмкости) короткая остановка подняла задержки; /health/ready стоит в той же очереди к пулу и не уложился в 1 с; HAProxy вывел единственную реплику на 2,5 с (503 от LB), а вернувшаяся реплика разбирала очередь запросов, брошенных клиентом: до конца ступени 69 % ошибок, из них 14 511 таймаутов клиента. Система без ограничения на входе не возвращается сама после кратковременной перегрузки — это и чинит улучшение C.
Контроль — подтверждён вмешательством. A2 и A2 с PostgreSQL на 2 CPU прогонялись поочерёдно в одном заходе, лестница без остановки (scripts/bench/series/control.conf):
| Ёмкость по повторам | Медиана | На 1400 запросов/с: p99 / CPU PostgreSQL / CPU API | На 2000 запросов/с | |
|---|---|---|---|---|
| A2, PostgreSQL 1 CPU | 1000, 1200, 1400 | 1200 | 286–1345 мс / 100–102 % из 100 % / 165–168 % из 200 % | 240–520 успешных/с, коллапс |
| A2, PostgreSQL 2 CPU | 2000, 2000, 2000 | 2000 | 30–121 мс / 105–112 % из 200 % / 179–186 % из 200 % | 2000/с, p99 288–415 мс |
Удвоение CPU одной только базы подняло ёмкость с 1200 до 2000 (+67 %), диапазоны повторов не пересекаются. На 2000 запросов/с база занята на ~75 %, а API — 205–214 % из 200 %: следующий ограничитель — CPU реплик, и дальше снова помогает горизонтальное масштабирование API.
Улучшение C — ограничение запросов на реплику (H4 подтверждена). Конфигурации 1 и 4 реплик по 1 CPU, maxconn 0 (без ограничения) против 20, плюс 10 и 40 на одной реплике; лестница 400–2400 без остановки, повторы вперемешку:
| Конфигурация | Ёмкость по повторам | Успешных/с на 2000 | Успешных/с на 2400 | p99 успешных за насыщением | Таймауты клиента на 2400 |
|---|---|---|---|---|---|
| 1 реплика, без ограничения | 400, 400, 400 | 153–484 | 93–345 | ~1950–2000 мс | ~38 000 |
1 реплика, maxconn 20 |
800, 1600, 1200 | 1161–1540 | 1013–1594 | 360–390 мс | 0 |
| 4 реплики, без ограничения | 400, 1600, 800 | 43–726 | 177–321 | ~1990 мс | ~54 500 |
4 реплики, maxconn 20 |
400, 1600, 800 | 1304–1817 | 1393–1499 | 410–505 мс | 0 |
1 реплика, maxconn 10 |
800, 1200, 800 | 1097–1447 | 949–1395 | ~350 мс | 0 |
1 реплика, maxconn 40 |
800, 1200, 800 | 1272–1610 | 1435–1606 | ~375 мс | 0 |
- За точкой насыщения без ограничения успешная пропускная способность падает в 3,5–10 раз (медианы на 2000 и 2400), ошибки — в основном таймауты клиента (запросы, которые сервер всё равно выполнит), пул переподключается (до 30 новых соединений в секунду против 0), а HAProxy выводит перегруженные реплики из ротации (34 и 89 переходов в DOWN за три повтора на 1 и 4 репликах). С
maxconn 20она держится у потолка базы (1300–1800 успешных/с), лишнее получает быстрый 503 от LB, таймаутов клиента нет, ни одна реплика ни разу не выпала из ротации, а p99 успешных остаётся в пределах ~350–500 мс благодаряtimeout queue 300ms. На ступенях 2000 и 2400 диапазоны повторов «до» и «после» не пересекаются. - Ёмкость одной реплики по строгому критерию выросла с 400 (во всех трёх повторах) до 800–1600 (медиана 1200): ограничение улучшает хвост задержек и ниже насыщения — на 800 запросах/с p99 617–1159 мс без него и 52–196 мс с ним. Очередь перед репликой короткая (20), остальное ждёт в очереди LB, а не тысячами горутин внутри процесса с лимитом 1 CPU.
- На 4 репликах ёмкость по строгому критерию не изменилась (400, 1600, 800 в обоих вариантах): здесь её определяют ступени, где отставал генератор (8,5 CPU лимитов на 8 vCPU, см. ограничения), — эти ступени не засчитываются ни «до», ни «после».
- Значение 20 не магическое: 10, 20 и 40 ведут себя одинаково в пределах шума, 10 чуть раньше начинает отбрасывать (меньше запас на запросы без БД). Важно наличие границы порядка размера пула, а не точное число.
- Цена: ограничение превращает кратковременную перегрузку в быстрые 503 вместо медленных успешных ответов — клиент должен уметь повторять (для отправки сообщения это безопасно благодаря Idempotency-Key), а связь
maxconnс пулом реплики приходится держать согласованной. Ограничение не поднимает потолок базы; оно делает так, что база работает на запросы, которых кто-то ещё ждёт.
Графики (evidence/track1/): A-throughput.png, Aprime-throughput.png, B-throughput.png, control-throughput.png, C-throughput.png — успешные ответы от предложенной нагрузки (медиана повторов; полые точки — генератор отставал); *-p99.png — p99 успешных; capacity.png — ёмкость с разбросом повторов; cost-per-request.png — CPU на запрос по компонентам; cpu-at-capacity.png — CPU компонентов в точке ёмкости; pool-waits.png — ожидания соединения пула.
Ограничения измерения
- Один хост: генератор, LB, API и хранилища делят один ноутбук. Гибрид P/E-ядер и планирование Windows дают остановки всей VM: скорость хоста между прогонами менялась от 2,55 до 4,86 с на одном и том же цикле, 17 из 48 прогонов помечены контролем шума. Сравнения внутри одной таблицы сделаны в одном заходе с чередованием повторов; сравнивать абсолютные числа между заходами (например, B1 из серии B и «1 реплика без ограничения» из C) нельзя — у одной и той же конфигурации в разных заходах ёмкость отличалась вдвое.
- 4 реплики по 1 CPU + LB 1 + PostgreSQL 1 + Valkey 0,5 + генератор 2 = 8,5 CPU лимитов на 8 vCPU: на высоких ступенях B4 и C/4 реплики генератор чаще отставал, такие ступени недействительны.
- Виртуальный диск WSL2 меняет цену fsync при коммите; сеть между контейнерами — без реальных задержек; профиль 80/20 и чтение первой страницы — один профиль, а не «пропускная способность вообще».
- Ёмкость — дискретная ступень лестницы (шаг 200–400 запросов/с); при остановке лестницы на первом провале (серии A–B) одна шумная ступень обрывает прогон, поэтому контроль и C снимались без остановки.
- Прогоны сняты на коммитах
25f9564и940bc6f; код системы (cmd,internal,migrations,Dockerfile,compose*.yaml,infra) в них одинаков сf5f8040, различаются только скрипты экспериментов. Логи прогонов (compose.log) после снятия сокращены тем же фильтром, который теперь применяетrun-series.sh(state_log: переходы состояния LB и старт/остановка реплик, остальное — счётчиком), а посекундные метрики сжаты gzip (коммитecf89ef); полный лог прогона с перегрузкой занимал до 50 МБ.
Ограничения и следующие шаги
Что выдерживается и что нет. Стенд выдерживает остановку и падение любой одной реплики API, перезапуск всего стенда с сохранением volumes и замену всех реплик под нагрузкой. Не выдерживает:
- отказ HAProxy — единственная точка входа (в проде — пара LB с VRRP/keepalived или облачный LB);
- отказ PostgreSQL — единственный источник истины, без реплики и бэкапов;
- отказ Valkey — без него не аутентифицируется ни один запрос (503);
- отказ хоста или диска — всё на одном Docker-host. Несколько процессов API не делают единственные БД и LB высокодоступными (COURSE.md).
Узкое место — PostgreSQL, и это ожидаемо: единственный узел, через который проходит каждый запрос, и одновременно единственная точка отказа. Как поднимать потолок дальше — по возрастанию цены; каждый шаг — серьёзное решение со своими проблемами, а не «тормозит база — добавь реплик»:
- Пулер соединений (PgBouncer) между репликами и базой. Сейчас каждая реплика держит свой пул, и число серверных процессов PostgreSQL растёт с числом реплик (
max_connections=150подобран под 10 слотов LB × 10). Пулер отвязывает число backend'ов от числа реплик. Цена: ещё один компонент и ещё одна точка отказа; в transaction-режиме нельзя полагаться на состояние сессии (session advisory lock goose работает только мимо пулера — миграции должны идти напрямую). - Вертикальное масштабирование. Контрольный эксперимент показал прямую отдачу: 2 CPU базы вместо 1 дали +67 % ёмкости. Цена: потолок железа, рост стоимости непропорционален, простой при смене машины; отказоустойчивости не прибавляет.
- Реплики для чтения. 80 % профиля — чтения истории, их можно увести на асинхронные реплики. Цена: задержка репликации и нарушение «прочитал свою запись» (отправитель может не увидеть только что отправленное сообщение), маршрутизация чтений и записей в коде или прокси, failover реплики в primary, мониторинг отставания.
- Шардирование (например, по
chat_id: история и ключи идемпотентности чата живут вместе). Цена: выбор ключа навсегда, запросы через несколько шардов (список чатов пользователя), перебалансировка при росте, распределённые транзакции для операций над несколькими шардами, на порядок сложнее эксплуатация.
До любого из этих шагов дешевле уменьшить работу базы на запрос: сейчас каждый GET истории делает два запроса (проверка участия и выборка), их можно слить в один; состав чата в обязательном API неизменен (COURSE.md), поэтому положительный результат проверки участия можно кэшировать.
Учебные упрощения и известные особенности.
- Связь настроек:
maxconn 20в HAProxy рассчитан от пула реплики (10),max_connections=150PostgreSQL — от числа слотов LB и пула. При изменении пула их нужно менять вместе; связь записана в комментариях конфигов. - 503 от LB при переполнении очереди отвечает «no API replica is available»: свободной реплики, способной принять соединение, действительно нет; добавленная реплика сразу добавит места.
- После перезапуска контейнера HAProxy возвращает слот в UP при повторном разрешении DNS, не дожидаясь
rise 2; возможный отказ соединения в этот момент закрываетretry-on conn-failure. - Ключ идемпотентности, просроченный и перехваченный новым сообщением, оставляет старое сообщение в истории (ключ — не часть сообщения).
- Промежуточные коммиты исправлений после ревью не все самостоятельны: в
7fbd781API уже принимает входящийX-Request-Id, а HAProxy начинает его перезаписывать только вce47c13. Итоговое состояние согласовано. - HTTP без TLS — только для локального стенда; TLS и отдельная роль БД без прав на схему (её уже позволяет вынесенный
migrate) — lab7. scripts/stop-one.cmdиscripts/restart.cmdнужны только на Windows:tests/resilience.pyзапускает хук без shell.
Что подтверждено, а что гипотеза. Подтверждено измерениями: точка насыщения — CPU PostgreSQL около 1400 запросов/с (контроль вмешательством: +67 % при удвоении CPU базы), реплики при фиксированном бюджете не дают ёмкости и стоят +33 % CPU на запрос, пул — не скрытая переменная, ограничение запросов на реплику убирает коллапс при перегрузке. Гипотезы без замера: эффект слияния двух запросов GET в один, пулера соединений и реплик чтения.