Files
mtusi2026lab3/REPORT.md
T

68 KiB
Raw Blame History

Отчёт — лабораторная 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/http Server.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/gin v1.12.0, github.com/google/uuid v1.6.0, github.com/jackc/pgx/v5 v5.11.0 (драйвер и пул), github.com/pressly/goose/v3 v3.27.0 (миграции), github.com/redis/go-redis/v9 v9.23.0 (клиент Valkey), golang.org/x/crypto/argon2, в тестах github.com/testcontainers/testcontainers-go v0.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/ready 503, продолжает получать запросы до закрытия порта. Активный 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, и это ожидаемо: единственный узел, через который проходит каждый запрос, и одновременно единственная точка отказа. Как поднимать потолок дальше — по возрастанию цены; каждый шаг — серьёзное решение со своими проблемами, а не «тормозит база — добавь реплик»:

  1. Пулер соединений (PgBouncer) между репликами и базой. Сейчас каждая реплика держит свой пул, и число серверных процессов PostgreSQL растёт с числом реплик (max_connections=150 подобран под 10 слотов LB × 10). Пулер отвязывает число backend'ов от числа реплик. Цена: ещё один компонент и ещё одна точка отказа; в transaction-режиме нельзя полагаться на состояние сессии (session advisory lock goose работает только мимо пулера — миграции должны идти напрямую).
  2. Вертикальное масштабирование. Контрольный эксперимент показал прямую отдачу: 2 CPU базы вместо 1 дали +67 % ёмкости. Цена: потолок железа, рост стоимости непропорционален, простой при смене машины; отказоустойчивости не прибавляет.
  3. Реплики для чтения. 80 % профиля — чтения истории, их можно увести на асинхронные реплики. Цена: задержка репликации и нарушение «прочитал свою запись» (отправитель может не увидеть только что отправленное сообщение), маршрутизация чтений и записей в коде или прокси, failover реплики в primary, мониторинг отставания.
  4. Шардирование (например, по chat_id: история и ключи идемпотентности чата живут вместе). Цена: выбор ключа навсегда, запросы через несколько шардов (список чатов пользователя), перебалансировка при росте, распределённые транзакции для операций над несколькими шардами, на порядок сложнее эксплуатация.

До любого из этих шагов дешевле уменьшить работу базы на запрос: сейчас каждый GET истории делает два запроса (проверка участия и выборка), их можно слить в один; состав чата в обязательном API неизменен (COURSE.md), поэтому положительный результат проверки участия можно кэшировать.

Учебные упрощения и известные особенности.

  • Связь настроек: maxconn 20 в HAProxy рассчитан от пула реплики (10), max_connections=150 PostgreSQL — от числа слотов LB и пула. При изменении пула их нужно менять вместе; связь записана в комментариях конфигов.
  • 503 от LB при переполнении очереди отвечает «no API replica is available»: свободной реплики, способной принять соединение, действительно нет; добавленная реплика сразу добавит места.
  • После перезапуска контейнера HAProxy возвращает слот в UP при повторном разрешении DNS, не дожидаясь rise 2; возможный отказ соединения в этот момент закрывает retry-on conn-failure.
  • Ключ идемпотентности, просроченный и перехваченный новым сообщением, оставляет старое сообщение в истории (ключ — не часть сообщения).
  • Промежуточные коммиты исправлений после ревью не все самостоятельны: в 7fbd781 API уже принимает входящий 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 в один, пулера соединений и реплик чтения.