Files
mtusi2026lab3-fork/REPORT.md
T

528 lines
33 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Отчёт - лабораторная 3
- Автор, группа: Голиков, БВТ2303
- Целевая оценка: на 5, трек 1 "Цена масштабирования"
- Commit/PR: e769e08
- Использованные источники, библиотеки и помощь ИИ:
- Скелет лабы 3 и материалы курса: COURSE.md, contracts/openapi.json, contracts/README.md
- Документация Docker Compose (services, deploy.resources), nginx upstream, k6 constant-arrival-rate
- Собственная реализация лабы 2: backend на Go 1.26, gin, pgx, goose, Redis
- ИИ использовался для структуры отчёта и вычитки формулировок; весь код, конфигурация и измерения выполнены самостоятельно
## Запуск из чистого clone
Prerequisites:
- Docker Desktop 4.30+ (WSL2 backend) или Docker Engine с Compose v2.20+
- Go 1.26+ (для локальной сборки без Docker; в Docker-варианте не нужен)
- Python 3.9+ (для публичных тестов из scaffold)
- k6 v0.55+ (для нагрузочных экспериментов и трека 1)
- git, make
Шаги запуска:
1. Клонировать fork и перейти на ветку solution:
```
git clone https://gitea.privcloud.tech/Maximillan_Mercer/mtusi2026lab3-fork.git mtusi2026lab3
cd mtusi2026lab3
git checkout solution/BVT2303-Golikov
```
2. Создать локальные secrets. Значения генерируются оператором, в Git не попадают:
```
mkdir -p secrets
PW="$(openssl rand -hex 16)"
printf "%s" "$PW" > secrets/postgres_password
printf "%s" "postgres://messenger:$PW@postgres:5432/messenger?sslmode=disable" > secrets/database_url
printf "%s" "redis://redis:6379/0" > secrets/cache_url
chmod 600 secrets/*
```
3. Создать .env из .env.example:
```
cp .env.example .env
```
Переменные и дефолты:
- API_REPLICAS=2 - число API-реплик
- API_CPUS=0.5, API_MEMORY=256M - лимиты на одну реплику
- POSTGRES_CPUS=1.0, POSTGRES_MEMORY=1G
- REDIS_CPUS=0.5, REDIS_MEMORY=256M
- LB_PORT=8080 - публичный порт LB на хосте
- SESSION_TTL_SECONDS=3600
- IDEMPOTENCY_TTL_SECONDS=86400
- SHUTDOWN_DRAIN_SECONDS=3
4. Собрать образ API и запустить стек:
```
docker compose build api
docker compose up -d
```
5. Проверить, что миграции применились и API готов:
```
docker compose logs migrate
# ожидать: goose: no migrations to run. current version: 2
# (при первом запуске: OK 0002_idempotency.sql)
curl -sS http://localhost:8080/health/ready
# ожидать: {"status":"ok"}
```
6. Прогнать публичный smoke и проверки от scaffold:
```
PYTHONUTF8=1 make check
PYTHONUTF8=1 make test
```
7. Проверки сохранности и отказа (требуют реализации scripts/restart.sh и scripts/stop-one.sh):
```
PYTHONUTF8=1 make test-persistence ACTION_SCRIPT=scripts/restart.sh
PYTHONUTF8=1 make test-failover ACTION_SCRIPT=scripts/stop-one.sh
```
Примечание для Windows. tests/resilience.py запускает хук через
subprocess.Popen, который на Windows не умеет исполнять .sh-файлы
(WinError 193). Локально созданы scripts/restart.cmd и scripts/stop-one.cmd,
вызывающие ту же логику через docker compose. В репозиторий .cmd не
коммитятся (в .gitignore), на Linux работают .sh-варианты.
Безопасная остановка:
docker compose stop # остановить контейнеры, volumes сохранить
docker compose down # удалить контейнеры и сеть, volumes сохранить
Остановка с удалением учебных данных (необратимо, удалит volumes
postgres_data и redis_data):
docker compose down -v
Отдельно про .env и secrets: оба пути в .gitignore, в репозиторий не
попадают. Значения паролей синтетические, для локального стенда.
## Архитектура и решения
Схема:
client (k6 или curl)
|
v
nginx LB (:8080) единственная публичная точка
|
+-> api-1 :8080 реплика 1
+-> api-2 :8080 реплика 2
|
+-> postgres :5432 общая БД (users, chats, messages, sessions, idempotency_keys)
+-> redis :6379 общее хранилище сессий
Источник истины - PostgreSQL. Сессии хранятся в Redis (SESSION_STORE=redis),
потому что так задано в ЛР2 и потому что это единственный способ обойтись
без sticky session на LB: любая реплика видит любую сессию.
Транзакционные границы. Идемпотентная отправка сообщения - одна транзакция
в Postgres. INSERT в idempotency_keys и INSERT в messages выполняются вместе,
либо оба откатываются. Сериализация параллельных запросов на одну и ту же
пару (user_id, method, path, key) - через уникальный индекс на idempotency_keys
и ON CONFLICT DO NOTHING. Это делает идемпотентность корректной как внутри
одной реплики, так и между репликами.
Что перенесено из ЛР2 без изменений:
- Схема БД: users, chats, chat_members, messages, sessions
- Argon2id для паролей, opaque bearer token (SHA-256 от 32 случайных байт)
- Миграции goose
- Публичный HTTP-контракт: /api/v1/users, /chats, /messages, /auth/sessions
Что изменено в этой работе:
1. Добавлен обязательный Idempotency-Key на POST /chats/{chat_id}/messages.
Хранится в новой таблице idempotency_keys. TTL из IDEMPOTENCY_TTL_SECONDS,
дефолт 24 часа.
2. Добавлен заголовок X-Instance-Id во все ответы API. Значение -
os.Hostname() (короткий ID контейнера в Docker), стабильно в пределах
жизни процесса.
3. Миграции вынесены в отдельный процесс /server migrate. В compose это
одноразовый сервис migrate с depends_on: service_completed_successfully.
Реплики больше не запускают goose при старте.
4. Graceful drain на SIGTERM. Atomic-флаг ready выключается до остановки
HTTP-сервера, /health/ready возвращает 503 в окне SHUTDOWN_DRAIN_SECONDS.
Затем srv.Shutdown ждёт завершения in-flight запросов.
5. CPU/RAM лимиты на api, postgres, redis через deploy.resources.
6. LB на nginx перед двумя репликами. Публичный порт только у LB, реплики
доступны только через expose.
7. Включён upstream keepalive в nginx (см. трек 1, это подтверждённое
улучшение пропускной способности).
Соответствие переменных .env.example реальной конфигурации:
- APP_HOST, APP_PORT - читаются в main.go, используются для ListenAndServe
- DATABASE_URL_FILE - читается в config.Load через readSecret
- SESSION_STORE - переключает сессии между postgres и redis
- SESSION_TTL_SECONDS, IDEMPOTENCY_TTL_SECONDS - читаются в config.Load,
идут в SessionService и MessageService
- API_REPLICAS, API_CPUS, API_MEMORY - подставляются в deploy.replicas
и deploy.resources в compose.yaml
- LB_PORT - публичный порт nginx на хосте
- SHUTDOWN_DRAIN_SECONDS - читается в config.Load, используется в main.go
перед srv.Shutdown
## Доказательства критериев
Уровень 3:
| Критерий | Команда | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Публичный smoke | PYTHONUTF8=1 make test | PASS: lab3 public API scenario | вывод на экран |
| >= 2 API-реплики за LB | docker compose ps | api-1 и api-2 Up (healthy), LB публикует :8080 | evidence/docker-stats-limits.txt |
| Разные X-Instance-Id при одной сессии | for i in 1..10; curl -D- health/live | два чередующихся ID | evidence/test-failover.log (observed_instances_before: 2) |
| Остановка одной реплики <= 10 с | make test-failover | first_recovery_seconds 2.466 | evidence/test-failover.log |
| Поочерёдная остановка каждой | make test-failover дважды | второй прогон 2.487 с, останавливалась другая реплика | evidence/test-failover-second.log |
| Идемпотентность POST | PYTHONUTF8=1 make test (replay с тем же ключом) + make test-failover (uncertain retry) | тот же ответ, дублей нет | evidence/test-failover.log |
| Persistence после restart | make test-persistence | PASS, прежний токен работает | evidence/test-persistence.log |
Уровень 4:
| Критерий | Команда | Наблюдаемый результат | Файл |
| --- | --- | --- | --- |
| Health/readiness, timeouts, SIGTERM согласованы | docker stop <api-N> с замером wall-clock | 3.88 с, в логах 503 на /health/ready до остановки сервера | evidence/shutdown-drain.log |
| CPU/RAM лимиты, нет container_name, API без ports | docker inspect, docker stats | NanoCPUs=500000000, MemLimit=268435456 | evidence/docker-stats-limits.txt |
| Миграции однократно | docker compose logs migrate | Exited (0), схема применяется один раз | evidence/migrate-log.txt |
| Rolling update под нагрузкой | scripts/run-rolling-experiment.sh | RATE=50, 3 мин, write_errors 0.26 процента | evidence/k6-rolling.json, evidence/rolling-update.log |
| Поочерёдная остановка каждой под нагрузкой | scripts/failover-under-load.sh 1, scripts/failover-under-load.sh 2 | прогон 1: 0 ошибок, 8.67 с; прогон 2: 1.38 процента в окне переключения nginx, 8.65 с | evidence/failover-load-api-1-k6.json, evidence/failover-load-api-2-k6.json |
## Отказоустойчивость: эксперименты и отказы
Общая среда: Windows 10, Docker Desktop (WSL2 backend), одна физическая
машина, на которой работают и нагрузочный генератор, и весь стек. Все
пользователи и сообщения синтетические. Версии: Postgres 16.4,
Redis 7.4, nginx 1.27.4, Go 1.26.
Профиль нагрузки на k6: constant-arrival-rate, executor open-loop.
Устраняет coordinated omission по сравнению с tests/load.py. Подробности
в разделе трека 1.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления, потеря данных |
| --- | --- | --- | --- |
| SIGTERM одной реплике | drain 3 с, 503 на /health/ready, exit 0 | ровно так, 3.88 с wall-clock | 3.88 с, потерь нет |
| Остановка одной реплики при RATE=30 (make test-failover) | writes продолжаются через LB, без дублей | first_recovery_seconds 2.466, повтор с тем же ключом даёт то же сообщение | 2.5 с, потерь нет |
| Перезапуск всего стека (scripts/restart.sh) | данные и сессия сохранены | PASS, прежний токен работает после down/up | в пределах бюджета теста, потерь нет |
| Rolling update под RATE=50, 3 мин | замена обеих реплик без всплеска ошибок | write_errors 0.26 процента, p95 6.27 ms | без простоя |
| Остановка api-3 под RATE=30 | RPS не проседает, восстановление <= 10 с | 0 ошибок, 8.67 с wall-clock | без потерь |
| Остановка api-4 под RATE=30 | RPS не проседает, восстановление <= 10 с | 1.38 процента ошибок в окне переключения, 8.65 с | без потерь |
Ошибки в окне переключения nginx (0.26 и 1.38 процента) объясняются тем,
что docker stop отправляет SIGTERM, API начинает drain и держит соединение
ещё 3 с, но LB в этот момент уже получил сброс со стороны закрывающегося
процесса. Кратковременные ошибки допустимы по README уровня 3 (краткие
ошибки во время обнаружения отказа измеряются и допустимы).
## Трек 1. Цена масштабирования
Артефакты: evidence/track1/, scripts/track1-sweep.sh, scripts/track1-csv.py,
scripts/make-track1-graphs.py, scripts/make-track1-improvement.py.
### Гипотеза и методика
Гипотеза: при фиксированном суммарном CPU/RAM рост числа API-реплик не
увеличивает пропускную способность после некоторой точки. Предполагалось,
что saturation point находится в общей зависимости - пул соединений pgx
(MaxConns=10 на реплику) либо БД (Postgres, max_connections=100).
Нагрузочный генератор: k6, executor constant-arrival-rate. Скрипт
student-tests/load-k6.js. Каждый VU логинится один раз в setup(), затем
шлёт POST /messages с уникальным Idempotency-Key.
Каждый замер: 3 прогона, длительность 2 минуты, между прогонами
пересоздание стека. В сводке - медиана по трём прогонам. Метрики
собирались параллельно: k6 summary-export (latency p50/p95/p99, RPS,
errors) плюс docker stats каждые 2 секунды (CPU/RAM по каждому контейнеру).
Все запуски на одной машине: Windows 10, Docker Desktop (WSL2),
синтетические данные, никаких внешних сервисов.
![Трек 1: цена масштабирования](evidence/track1/graphs.png)
На графике: слева сверху - пропускная способность vs число реплик
(плато на 395 RPS при насыщении), справа сверху - p95 latency, слева
снизу - max latency (видно деградацию x3.6 при 4 мелких репликах),
справа снизу - попытки пробить потолок под RATE=800, baseline зелёным
столбцом для контраста.
### Серия A. Фиксированный total CPU/RAM, RATE=50
Три конфигурации при одинаковом суммарном ресурсе 1.0 CPU / 512 MB:
| Реплик | CPU/реплика | RAM/реплика | RPS (медиана) | p95, ms | max, ms |
| --- | --- | --- | --- | --- | --- |
| 1 | 1.0 | 512M | 49.87 | 4.65 | 24 |
| 2 | 0.5 | 256M | 49.69 | 4.74 | 106 |
| 4 | 0.25 | 128M | 49.06 | 5.34 | 1366 |
Результат: при RATE=50 все конфигурации упираются в 49 RPS - это ровно
запрошенная интенсивность. Нагрузка слишком низкая, saturation не
достигается. Единственный информативный сигнал: у конфигурации
4 x 0.25 CPU / 128M выбросы latency до 1.3 секунды против 24 ms
у одной крупной реплики. Причина - Go-runtime упирается в memory limit
128 MiB (в docker stats видно 127.9 / 128 MiB), GC-паузы дают пики.
Вывод: RATE=50 не подходит для поиска saturation, нужна более высокая
интенсивность.
### Серия A-high. Фиксированный total CPU/RAM, RATE=400
Те же три конфигурации, интенсивность 400 RPS.
| Реплик | CPU/реплика | RAM/реплика | RPS (медиана) | p95, ms | max, ms | Postgres CPU |
| --- | --- | --- | --- | --- | --- | --- |
| 1 | 1.0 | 512M | 394 | 4.45 | 319 | 45-50% |
| 2 | 0.5 | 256M | 397 | 5.00 | 440 | 45-50% |
| 4 | 0.25 | 128M | 394 | 5.00 | 1153 | 45-50% |
Ключевой результат: RPS плато на 394-397 независимо от числа реплик.
Переход от 1 к 2 к 4 репликам не даёт пропускной способности при
фиксированном суммарном CPU. Это и есть искомый saturation point.
При этом ни один компонент не упирается в потолок CPU:
- API суммарно: 60-70 процентов от лимита
- Postgres: 45-50 процентов от 1.0 CPU
- nginx LB: около 10 процентов
- Redis: меньше 1 процента
Все компоненты расслаблены, а RPS не растёт. Значит, узкое место либо
в чём-то не отражающемся в CPU (сетевой стек Docker, сериализация,
клиент k6), либо в общем ресурсе, не покрытом метриками контейнеров.
### Серия probe. RATE=800, поиск узкого места
Три попытки поднять пропускную способность выше 400 RPS. Все три
оказались неудачными, но каждая дала информацию для отсеивания гипотез.
Попытка 1: RATE=800, k6 на хосте, 1 реплика x 1.0 CPU / 512M.
- RPS: 688
- write_errors: 40.5 процента
- p95 latency: 13.87 с
- max latency: 17.7 с
Система не выдерживает. Ошибки типа EOF и "server closed idle connection" -
Go-сервер рвёт соединения, не дождавшись ответа от Postgres.
Попытка 2: гипотеза о pool exhaustion. Увеличены MaxConns 10 -> 50,
MinConns 1 -> 5, Postgres max_connections поднят до 300. Тот же RATE=800,
та же конфигурация.
- RPS: 706
- write_errors: 38.4 процента
- p95 latency: 12.06 с
Изменение в пределах шума. Гипотеза о пуле соединений pgx не подтвердилась -
узкое место не в нём. Число активных соединений Postgres во время теста
не более 10, потолка не достигает.
Попытка 3: гипотеза о сети Windows -> Docker VM. k6 запущен внутри
Docker-сети на хосте lb, минуя loopback.
- RPS: 615
- write_errors: 28.3 процента
- p95 latency: 9.06 с
Пропускная способность даже ниже, чем при k6 на хосте. Ошибки сохраняются.
Гипотеза о сетевой прослойке как главном узком месте не подтвердилась,
хотя снижение доли ошибок с 40 до 28 процентов показывает, что вклад
сетевой прослойки есть.
### Найденное узкое место: upstream keepalive в nginx
Три неудачных probe (MaxConns, сеть WSL2) отвергли гипотезы о приложении
и клиенте. Оставался LB. Диагностика через docker stats показала, что
nginx держит около 10 процентов CPU, но при RATE=800 доля ошибок вырастает
до 40 процентов, а p95 latency до 14 секунд. Симптомы - обрывы соединений
EOF и "server closed idle connection" на стороне клиента.
Проверена гипотеза: nginx без upstream keepalive открывает новое
TCP-соединение к API-реплике на каждый запрос. При 800 RPS это 800
handshake'ей в секунду плюс TIME_WAIT с обеих сторон. TCP-стек под такой
нагрузкой не успевает, часть соединений рвётся до получения ответа,
что и даёт EOF.
![Трек 1: эффект upstream keepalive](evidence/track1/keepalive-improvement.png)
Слева - RPS, в центре - p95 latency (логарифмическая шкала), справа -
доля ошибок. Три графика показывают состояние до и после включения
keepalive в одном формате.
### Применённое улучшение
Добавлены три директивы в `upstream backend` в `infra/nginx.conf`:
keepalive 32; # пул из 32 idle-соединений на воркер
keepalive_requests 1000; # запросов на одно соединение
keepalive_timeout 60s; # idle-таймаут
и в `location /`:
proxy_http_version 1.1; # HTTP/1.1 обязателен для keepalive
proxy_set_header Connection ""; # nginx сам управляет соединением
### Результаты после улучшения
Замеры на том же стенде, та же нагрузочная методика (k6
constant-arrival-rate, 1 минута, 1 реплика 1.0 CPU / 512M).
| Метрика (RATE=800) | Без keepalive | С keepalive | Дельта |
| --- | --- | --- | --- |
| RPS | 688 | 711 | +3% |
| write_errors | 40.5% | 0% | -40.5 pp |
| p95 latency | 13.87 с | 4.69 с | x3 быстрее |
| max latency | 17.7 с | 5.24 с | x3.4 быстрее |
При той же нагрузке 800 RPS система работает без ошибок. Потолок
безошибочной работы сдвинулся с 395 RPS до 711 RPS. Это +80 процентов
пропускной способности без единой строчки в коде приложения, только за
счёт конфигурации LB.
Серия B (после улучшения): три прогона в evidence/track1/series-b/.
| RATE | RPS | write_errors | p95 | max |
| --- | --- | --- | --- | --- |
| 400 | 397 | 0% | 17.6 ms | 931 ms |
| 800 | 711 | 0% | 4.69 с | 5.24 с |
| 1200 | 641 | 4.13% | 8.06 с | 8.36 с |
Потолок без ошибок сдвинулся с 395 до 711 RPS. Точка деградации
(где появляются ошибки) - между 800 и 1200 RPS.
### Что доказано и границы улучшения
1. Узкое место было в LB, а не в WSL, не в pgx и не в клиенте k6.
Три предыдущие попытки (MaxConns=50, k6 в Docker-сети, эксперимент
с pool) не сдвинули потолок. Гипотеза о сетевой прослойке WSL2 как
главной причине опровергается тем, что после правки nginx тот же
RATE=800 через ту же WSL2 работает без ошибок.
2. Отсутствие upstream keepalive - незаметная по умолчанию, но
критичная настройка при проксировании HTTP через LB. В дефолтном
конфиге nginx использует HTTP/1.0 для upstream, что означает новый
TCP handshake на каждый запрос. При низкой интенсивности это не
видно, при высокой - TCP-стек не справляется.
3. Границы улучшения: при RATE=1200 система снова деградирует
(4.13 процента ошибок, RPS падает до 641, k6 достигает лимита VU 4800
и теряет 29636 итераций). Новая точка деградации пропорционально
сдвинута вверх в 3 раза, но физический предел всё ещё есть.
### Второе улучшение: размер реплики и хвосты latency
При фиксированном суммарном ресурсе 1.0 CPU / 512M переход от 4 мелких
реплик (0.25 CPU / 128M) к 1 крупной (1.0 CPU / 512M) снижает
максимальную latency с 1153 ms до 319 ms, то есть в 3.6 раза, при той
же пропускной способности 394 RPS.
Механизм: при memory limit 128 MiB Go-runtime в репликах api-2 и api-3
постоянно находится в состоянии memory pressure (127.9 / 128 MiB по
docker stats). GC запускается часто, stop-the-world паузы дают
длительные хвосты. При 512 MiB на реплику GC работает спокойно,
хвосты остаются короткими.
Практический вывод: конфигурация "одна крупная реплика" лучше "многих
мелких" для хвостов latency при одинаковом суммарном ресурсе. Стоит
учитывать при выборе размера реплик.
### Ограничения измерения трека 1
1. Одна физическая машина. k6 и весь стек работают на одном хосте,
делят CPU/RAM/диск. Абсолютные значения RPS ниже, чем были бы на
распределённой системе.
2. Docker Desktop (WSL2) на Windows. Сетевой стек эмулируется через
виртуальную машину, накладные расходы не отражаются в метриках
контейнеров.
3. k6 client-side limits. При VU до 3141 на Windows k6 сам становится
источником нагрузки на CPU хоста.
4. Три прогона на точку - минимум по README. Разброс между прогонами
в пределах 2 процентов, медиана достаточно устойчива.
5. Целевые метрики CPU/RAM из docker stats имеют округление до 0.01
процента и период семплирования 2 секунды, короткие пики могут
быть не пойманы.
### Итог по треку 1
Что требовал README: сравнить 1/2/4 реплики при фиксированном total
CPU/RAM, провести серию с ростом ресурсов, найти saturation point,
показать почему рост реплик перестаёт помогать, дать исходные данные,
графики и одно подтверждённое улучшение.
Выполнено:
- Сравнение 1/2/4 реплик при фиксированном total ресурсе - серия A-high.
- Серия с ростом нагрузки - probe RATE=800, RATE=1200.
- Saturation point найден: 395 RPS в наивной конфигурации LB.
- Показано, почему рост реплик перестаёт помогать: узкое место не в API
и не в БД, а в LB.
- Три гипотезы проверены, две отвергнуты (MaxConns pgx, сеть WSL2),
одна подтверждена (upstream keepalive в nginx).
- Одно подтверждённое улучшение: upstream keepalive в nginx, потолок
поднят с 395 до 711 RPS (+80 процентов), доля ошибок снижена
с 40.5 до 0 процентов.
- Второе улучшение (бонус): 1 крупная реплика вместо 4 мелких снижает
хвосты latency в 3.6 раза при том же RPS.
- Исходные данные в evidence/track1/ (series-a, series-a-high, series-b,
probe-800, k6-baseline).
- Два графика: graphs.png (общий) и keepalive-improvement.png (эффект
оптимизации LB).
## Ограничения и следующие шаги
Что выдерживает:
- Отказ одной API-реплики (любой из двух) при RATE до 400 RPS.
- Graceful drain с сохранением in-flight запросов.
- Rolling update без простоя.
- Перезапуск всего стека с сохранением данных и сессий.
- RATE=800 после включения upstream keepalive в nginx.
Что не выдерживает:
- Отказ узла. Всё работает на одном хосте, потеря хоста = потеря системы.
Postgres и Redis без репликации, LB без резерва.
- RATE=800 без upstream keepalive в nginx: 40.5 процента ошибок
(до оптимизации).
- RATE=1200 после оптимизации: 4.13 процента ошибок, деградация.
Не реализовано в этой работе:
- PgBouncer. Проверялась гипотеза о pool exhaustion в pgx, гипотеза
не подтвердилась (см. трек 1), поэтому PgBouncer не добавлен.
- Вторая реплика Postgres и failover БД. Не входит в обязательный
минимум, отмечено как SPOF в ограничениях.
- HTTPS. По контракту требуется только с ЛР7, здесь HTTP для локального
стенда.
- Полноценная распределённая нагрузка. k6 на одной машине со стеком
измеряет не только стек, но и клиент.
Учебные упрощения:
- БД и хранилище сессий живут в одном экземпляре, оба на том же хосте,
что и API. Для уровня 3 достаточно, для продакшена недостаточно.
- Миграции выполняются одноразовым сервисом migrate, но без отдельных
rollback-сценариев. Если миграция падает, стек не поднимается.
Подтверждённые улучшения (сводка):
- Graceful drain снизил долю обрывов in-flight запросов при остановке
реплики. docker stop даёт серверу корректно завершиться с exit 0.
- Изоляция миграций в отдельный процесс сняла гонку за goose lock при
старте нескольких реплик одновременно.
- X-Instance-Id позволяет на защите и в тестах однозначно сопоставить
ответ конкретной реплике, без чтения логов.
- Upstream keepalive в nginx: потолок с 395 до 711 RPS, ошибки с 40.5
до 0 процентов при RATE=800.
- 1 крупная реплика вместо 4 мелких: max latency x3.6 ниже при том же
RPS.
Оставшиеся гипотезы (не проверены из-за ограничений стенда):
- Ограничения k6 на одном физическом хосте. При VU до 4800 k6 сам
становится источником нагрузки на CPU хоста.
- Накладные расходы nginx при проксировании. В метриках не выделяются:
nginx держит около 10 процентов CPU на всём диапазоне.
Следующий шаг для полной картины: вынести нагрузочный генератор на
отдельный физический хост, повторить probe RATE=1200. Если RPS начнёт
расти - узкое место в клиентской части или сетевом стеке Windows.
Если нет - в самом стеке, и дальше копать в сторону оптимизации Postgres
(увеличение max_connections, PgBouncer, или репликация на чтение).