Files
mtusi2026lab3/REPORT.md
T

40 KiB
Raw Blame History

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

  • Автор, группа: Вейнмайер Андрей Андреевич, БВТ2303
  • Целевая оценка: 5 (уровни 3, 4 и трек 1 «Цена масштабирования»)
  • Commit/PR: ветка solution/bvt2303-weinmaier в https://gitea.privcloud.tech/WeinmaierAndrew/mtusi2026lab3, PR в mtusi2026/mtusi2026lab3
  • Основа: собственная lab2 — https://gitea.privcloud.tech/WeinmaierAndrew/mtusi2026lab2
  • Использованные источники:
    • Контракт: contracts/openapi.json, contracts/README.md (раздел «Балансировка и повторная отправка»)
    • Go: net/http (Server.Shutdown), log/slog, sync/atomic, crypto/sha256
    • Библиотеки: github.com/jackc/pgx/v5, github.com/redis/go-redis/v9, golang.org/x/crypto/argon2
    • Документация: HAProxy 3.0 (server-template, resolvers, http-check, retry-on), Docker Compose services/deploy, PostgreSQL INSERT … ON CONFLICT
    • Помощь ИИ: ИИ-ассистент использовался при переносе кода lab2, реализации и отладке; все результаты ниже — реальные прогоны, ссылки на них приведены.

Запуск из чистого clone

Версии

Компонент Образ / версия
API builder / runtime golang:1.26-alpine / alpine:3.20, закреплены по digest в Dockerfile (multi-stage, static, USER 1001)
LB haproxy:3.0.5-alpine
БД postgres:16.4-alpine
Сессии + кэш redis:7.4.1-alpine (AOF, appendfsync everysec)
Миграции migrate/migrate:v4.17.0

Prerequisites: Docker Engine/Desktop с Compose v2, Python 3.9+, POSIX shell (Linux/macOS/WSL или Git Bash).

Команды

# 1. Локальные .env и secrets/ (случайный пароль БД; повторный запуск ничего не перезаписывает)
sh scripts/init-secrets.sh

# 2. Проверка и запуск: postgres/redis → migrate (однократно) → api ×2 → lb
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait

# 3. Готовность и проверки
curl -i http://localhost:8080/health/ready
make test
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
sh scripts/restore.sh                       # вернуть остановленную реплику
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-idempotency
make test-failover-series

# Все доказательства одной командой (пишет в evidence/):
sh scripts/collect-evidence.sh

Windows: python3 там часто заглушка — используйте make ... PYTHON=python и PYTHONUTF8=1. Python на Windows не исполняет .sh напрямую (WinError 193), поэтому для публичных тестов есть обёртки: ACTION_SCRIPT=scripts/win/stop-one.cmd, scripts/win/restart.cmd (вызывают Git Bash).

Число реплик: API_REPLICAS в .env или docker compose up -d --scale api=4.

Остановка без потери данных: docker compose --env-file .env stop. Намеренное удаление учебных данных: docker compose --env-file .env down -v (удаляет volumes pg_data и redis_data).

Архитектура и решения

клиент ──► lb (HAProxy :8080, единственный опубликованный порт; :8404 stats, только 127.0.0.1)
             │  roundrobin, active check GET /health/ready каждые 1 s, DNS Docker
             ▼
           api × N (сеть front+back, портов наружу нет, без container_name)
             │
             ├──► postgres (сеть back): users, chats, chat_members, messages, idempotency_keys
             └──► redis    (сеть back): сессии (AOF), кэш истории (версия чата)
migrate (one-shot) ──► postgres  — до старта api

Перенесено из lab2: API, валидация, Argon2id, keyset-пагинация, сессии в Redis с TTL (переживают рестарт благодаря AOF), кэш истории. Кэш и валидация пароля изменены по замечаниям проверки (см. «Исправления по замечаниям проверки»).

Изменено в lab3:

  1. X-Instance-Id — middleware на самом внешнем уровне, есть в каждом ответе API, включая ошибки и health. Значение = hostname процесса; в Docker это короткий ID контейнера, поэтому stop-one.sh однозначно находит контейнер (docker compose ps -q api + сравнение префикса). Переопределяется INSTANCE_ID. В lab7 будет заменён на непрозрачный alias.
  2. Идемпотентность POST сообщения (internal/repository/postgres/message.go, миграция 0002_idempotency):
    • заголовок обязателен, ^[A-Za-z0-9._:-]{1,128}$, иначе 400;
    • область: PRIMARY KEY (user_id, chat_id, key) (метод всегда POST, путь задаётся chat_id);
    • request_hash = SHA-256 от канонического JSON уже разобранного тела, поэтому порядок ключей/пробелы не важны;
    • в одной транзакции: удалить просроченный ключ этой области → INSERT message → INSERT idempotency_keys … ON CONFLICT DO NOTHING. Конкурентный запрос с тем же ключом через другую реплику блокируется на уникальном индексе до COMMIT первой транзакции, получает конфликт, откатывает своё сообщение и возвращает сохранённое (тот же 201 и тот же Message) или 409 при другом body;
    • если первая транзакция откатилась (транзиентная 5xx), ключ не фиксируется и повтор выполняется заново;
    • авторизация и членство в чате проверяются до обращения к ключу, т. е. при каждом повторе;
    • TTL IDEMPOTENCY_TTL_SECONDS (86400); фоновая очистка раз в час (идемпотентный DELETE, безопасен с любой реплики).
  3. Миграции — отдельный one-shot сервис migrate (golang-migrate хранит версию и берёт advisory lock); api зависит от него через service_completed_successfully, поэтому реплики не гоняются за схему. DSN читается из secret, пароль не хранится в compose.yaml (в lab2 был захардкожен — исправлено).
  4. Graceful shutdown: по SIGTERM /health/ready сразу отвечает 503, процесс продолжает обслуживать запросы DRAIN_DELAY=3s (HAProxy за это время исключает его: inter 1s × fall 2), затем http.Server.Shutdown с SHUTDOWN_TIMEOUT=8s. stop_grace_period: 15s > 3 + 8, поэтому SIGKILL не обрывает запросы.
  5. LB HAProxy: server-template api 8 api:8080 + resolvers docker (127.0.0.11) — новые/пересозданные реплики подхватываются без перезапуска LB; retry-on conn-failure + option redispatch — повтор только когда запрос ещё не отправлен, поэтому неидемпотентные POST /users и /chats не дублируются. Sticky sessions нет: состояние общее.
  6. Кэш истории и версия чата. Ключ кэша messages:{chat}:v{version}:{cursor}:{limit}, где version — столбец chats.version в PostgreSQL (миграция 0003_chat_version). Версия увеличивается в той же транзакции, что и вставка сообщения; читатель получает версию тем же запросом, которым проверяет членство (MemberVersion). Поэтому после ответа 201 любое чтение идёт по новому ключу, и отказ Redis в любой команде (или полная недоступность кэша) не может вернуть устаревшую историю — старые ключи просто истекают по TTL 30 s. Redis на пути записи не нужен.
  7. Ресурсы (переопределяются переменными для трека 1): api 0.5 CPU/256M, lb 0.5/128M, postgres 1.0/512M, redis 0.5/256M. Сети: front (lb↔api) и back (api↔хранилища) — LB не видит БД.

Критичные зависимости readiness: PostgreSQL и Redis (сессии нужны каждому защищённому запросу) + флаг drain. /health/live — только жизнь процесса.

Тайминги обнаружения отказа:

Механизм Параметры Максимальное время
Graceful stop (SIGTERM) readiness 503 → inter 1s, fall 2 ≈2 s, всё это время реплика ещё обслуживает запросы → ошибок нет
Падение процесса (kill) conn refused → retry-on conn-failure, redispatch; check fall 2 запросы перенаправляются сразу; из пула ≈2 s
Зависание без ответа timeout server 15s, check timeout = inter ≈2 s до исключения; запросы в полёте получат 504

Соответствие .env.example: APP_HOST/APP_PORT/APP_ENV/SESSION_TTL_SECONDS/IDEMPOTENCY_TTL_SECONDS — как есть; DATABASE_URL_FILE и CACHE_URL_FILE — docker secrets /run/secrets/*; SESSION_STORE=redis (сессии в Redis с lab2); API_REPLICAS → deploy.replicas; DRAIN_DELAY/SHUTDOWN_TIMEOUT — добавлены.

Исправления по замечаниям проверки

Замечание Причина Исправление Проверка
Подтверждённая запись может отсутствовать в следующем чтении: при ACL SETUSER default -incr POST → 201, строка в PostgreSQL есть, GET возвращает прежние два сообщения версия чата для ключа кэша хранилась в Redis и увеличивалась INCR после COMMIT; ошибка INCR игнорировалась (message_cache.go:95), ключ не менялся, чтение попадало в старый кэш версия перенесена в chats.version и растёт в транзакции записи; ключ кэша строится из версии, прочитанной из PostgreSQL вместе с проверкой членства; INCR/GET версии в Redis удалены. Режим CACHE_INVALIDATION=scan теперь только воспроизводит стоимость SCAN для эксперимента и на корректность не влияет student-tests/regressions.py — ровно сценарий проверки (2 сообщения → кэш → ACL -incr → 3-е → чтение) и жёсткий вариант -incr -del -unlink -scan, шесть чтений через обе реплики; в режимах version и scan. Тот же тест против кода до исправления — FAIL (job regression-before-fix)
Принимается пароль из одних пробелов (" " × 12 → 201) validatePassword проверял только длину добавлена проверка strings.TrimSpace(s) == "" → 400; остальные обязательные строки (display_name, title, text) уже проверялись так же unit-тест validate_test.go (пробелы, табуляции, NBSP, границы 12/128); HTTP-регрессия на 3 вариантах

Изменение кэша меняет путь записи и чтения, поэтому все серии трека 1 переизмерены на исправленном коде (прогоны 3 и 4). Данные прогонов 1–2 на коде до исправления сохранены в evidence/track1/legacy_before_review_fix/ и в выводах не используются.

Где запускался стенд

На машине разработки Docker Desktop не запускается: в BIOS выключена аппаратная виртуализация (VirtualizationFirmwareEnabled=False, backend hasNoVirtualization=true). Поэтому все Docker-проверки выполнены на GitHub-hosted runner workflow .github/workflows/lab3-stand.yml — тот же compose.yaml и те же скрипты, что и в инструкции выше.

Прогон Код Что Ссылка
1 fe4b4cf (до исправлений) уровни 3–4 (найден баг rolling update), трек: A, B, D https://github.com/CharaWein/2026_lab3/actions/runs/39970452644
2 0a37181 (до исправлений) уровни 3–4, трек: C, E https://github.com/CharaWein/2026_lab3/actions/runs/39972671424
3 bab82c7 (после исправлений) уровни 3–4 и регрессии — все доказательства ниже; регрессия против кода до исправления; трек: A, B, D, E https://github.com/CharaWein/2026_lab3/actions/runs/40039513675
4 eec3e43 (тот же код приложения) трек: серия C повторно — 5 повторов, контрольная база в начале и в конце https://github.com/CharaWein/2026_lab3/actions/runs/40041006083

Прогоны 1–2 относятся к коду до исправления по замечаниям проверки; их данные лежат в evidence/track1/legacy_before_review_fix/ и в выводах не используются.

Runner: 2 vCPU, 8 GB RAM, Docker 28.0.4, Compose v2.38.2 (evidence/runner.txt). Модель CPU у разных job разная (записана в evidence/track1/runner_*.txt), поэтому сравнения корректны только внутри серии.

До Docker-прогона логика приложения проверялась и нативно (PostgreSQL 17, fakeredis, 2 процесса API за временным прокси) — evidence/local_native_check.txt. Сценарий с ACL Redis нативно не воспроизводится: fakeredis не применяет ACL к командам; он проверен только на настоящем Redis в CI.

Доказательства критериев

Все файлы — из прогона 3.

Уровень 3

Критерий README Команда/сценарий Наблюдаемый результат Файл
Стенд в compose.yaml, одна последовательность запуска scripts/init-secrets.sh → docker compose up -d --build --wait lb, 2×api, postgres, redis healthy; migrate отработал однократно evidence/docker_ps.txt
≥2 реплики, одна точка входа, общая БД и сессии docker compose ps опубликованы только 127.0.0.1:8080 (lb) и :8404 (stats); api — только 8080/tcp внутри сети evidence/docker_ps.txt
Запросы одной сессии обслуживают разные реплики 20 запросов через LB; 40 запросов /users/me в failover-тесте 932349e41b13×10, 9c02b883d167×10; observed_instances_before: 2 evidence/instances.txt, evidence/failover_1.txt
Публичный smoke make test PASS: lab3 public API scenario evidence/smoke.txt
Отказ одной реплики ≤10 s make test-failover ACTION_SCRIPT=scripts/stop-one.sh, 2 прогона, между ними restore.sh PASS ×2; по 144 успешных записи, 0 ошибок, первая запись после hook за 3.37 s и 3.28 s; остановленный контейнер Exited (0) evidence/failover_1.txt, failover_2.txt
Повтор POST с тем же ключом без дублей (конкурентно, через разные реплики) make test-idempotency: 10 раундов × 16 параллельных запросов 160/160 → 201 с одним Message, 1 сообщение на ключ, 2 реплики, duplicates_found: 0; другой body — 409; ключ изолирован по чату и пользователю evidence/idempotency_concurrent.json
Подтверждённая запись видна следующему чтению, даже если Redis отказывает в командах student-tests/regressions.py в режимах version и scan PASS: ACL -incr и ACL -incr -del -unlink -scan — каждое из 6 чтений через обе реплики видит новое сообщение evidence/regressions.txt
Тот же тест против кода до исправления job regression-before-fix (commit 7cd5506) FAIL: read 0 after 201 misses confirmed message (denied: ['incr']); пароль из пробелов → received 201 evidence/regressions_before_fix.txt
Пароль из одних пробелов → 400 regressions.py, go test ./internal/service/ PASS: пробелы, табуляции, NBSP → 400 evidence/regressions.txt
Persistence с прежним токеном make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS; перезапущены postgres, redis, api, lb (uptime до/после в файле), volumes сохранены evidence/persistence.txt

Публичный failover-тест останавливает реплику, обслужившую первый запрос; в обоих прогонах это была api-1. Остановка каждой реплики по очереди показана в серии уровня 4.

Уровень 4

Критерий README Команда/сценарий Наблюдаемый результат Файл
Health/readiness, timeouts, SIGTERM согласованы; LB исключает backend drain 3 s + HAProxy check inter 1 s × fall 2; docker stop после SIGTERM реплика отвечала ещё 1.35 s / 1.34 s, затем исчезла из ответов LB; 0 ошибок. Период проверки 1 s, максимальное время обнаружения ≈2 s evidence/failover_series.json
Поочерёдная остановка каждой реплики: RPS, ошибки, восстановление make test-failover-series (4 потока, POST+GET) таблица ниже evidence/failover_series.json
Параллельная идемпотентность см. уровень 3 0 дублей evidence/idempotency_concurrent.json
CPU/RAM-лимиты, api без портов, нет container_name compose.yaml, docker stats api 0.5 CPU/256M, lb 0.5/128M, postgres 1.0/512M, redis 0.5/256M evidence/docker_stats.txt, evidence/docker_ps.txt
Rolling update под нагрузкой scripts/rolling-update.sh во время 90 s tests/load.py api-1, api-2 → api-3, api-4 за 27 s; 45 591 запрос, 0 ошибок, 506 RPS, p99 19.9 ms evidence/rolling_update.txt, rolling_update_load.json
Миграции однократно и совместимы сервис migrate + docker compose run --rm migrate перед заменой no change; 0002 и 0003 только добавляют таблицу/столбец с DEFAULT (expand) evidence/rolling_update.txt

Эксперименты и отказы

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
docker stop реплики 4f142660cef9 под нагрузкой 0–единицы ошибок благодаря drain 463.0 RPS до → 493.4 RPS в окне 15 s, 0 ошибок; stop занял 3.66 s ошибок нет; после docker start healthy и в LB через 5.93 s; потерь нет
docker stop реплики 29c5ff8f740e то же 480.2 → 484.8 RPS, 0 ошибок; stop 3.98 s ошибок нет; возврат через 6.38 s; потерь нет
Итог серии нет потерь и дублей все 12 741 подтверждённых записей на месте и не изменены, дублей 0 (в истории 12 744 сообщения: несколько записей, ответ на которые клиент не учёл при завершении нагрузки; повтор с тем же ключом дублей не создаёт) —
Rolling update 0 ошибок 0 из 45 591 замена 27 s
Restart всего стенда данные и сессия сохранены PASS с прежним токеном ≈12 s до healthy
Redis отказывает в INCR/DEL/SCAN запись видна сразу видна в каждом из 6 чтений —
Прогон 1: rolling update 0 ошибок найден баг: wait_healthy перезаписывал cid внешнего цикла, удалялась новая реплика; сборка (72 s) не попадала в окно нагрузки исправлено в 0a37181

Трек 5.1: цена масштабирования

Вопрос и гипотезы

Помогает ли добавление API-реплик, где точка насыщения и почему рост реплик перестаёт помогать? Гипотезы A–D записаны до первых измерений в experiments/track1.json. Серия E и её гипотеза добавлены после прогона 1, чтобы проверить, куда смещается насыщение после улучшения. В серию C после прогона 3 добавлена контрольная повторная база.

Серия Что меняем Гипотеза
A_fixed_total 1×1.0 / 2×0.5 / 4×0.25 CPU API (сумма 1.0 CPU) RPS не растёт, p95 чуть хуже; реплики дают только отказоустойчивость
B_scale_out 1/2/4 реплики по 0.5 CPU рост, пока узкое место — CPU API, затем упор в общую зависимость
C_shared_resources 4×0.5 API; PG 1→2, LB 0.5→1, Redis 0.5→1 CPU RPS поднимает только ресурс насыщенной зависимости
D_improvement 4×0.5 API: baseline и 3 кандидата SCAN-инвалидация кэша (наследие lab2) — O(keyspace/100) запросов к Redis на запись; без неё (CACHE_INVALIDATION=version) RPS вырастет
E_scale_out_after_fix 1/2/4 × 0.5 CPU с version после снятия упора в Redis реплики снова помогают до следующей общей зависимости

Методика

  • Отдельный compose-проект mtusi2026lab3-bench (порт 18080). Конфигурация — только переменные окружения (API_REPLICAS, API_CPUS, API_MEMORY, PG_CPUS, LB_CPUS, REDIS_CPUS, DB_POOL_MAX, CACHE_INVALIDATION, LB_BALANCE), образ один.
  • База: PostgreSQL 1.0 CPU / 512M, max_connections=200; Redis 0.5 CPU; LB 0.5 CPU; пул 20 на реплику; CACHE_INVALIDATION=scan (на каждую запись SCAN+DEL ключей чата, как в lab2; корректность от этого режима не зависит — версия ключа в PostgreSQL); фоновый keyspace Redis — 10 000 ключей pad:* (≈ активные сессии).
  • Нагрузка cmd/bench: closed-loop, 50% POST сообщения (уникальный Idempotency-Key) / 50% GET истории limit=50, 8 чатов × 2 участника, без повторов, таймаут 5 s.
  • Фактический объём (сокращён из-за времени работы runner): уровни параллелизма 4/16/64 (C: 16/64, D: 32/64), прогрев 3 s, измерение 15 s; 3 повтора каждой точки (C: 5). Полная методика (6 уровней, 30 s) запускается make track1.
  • Во время прогона раз в 1–2 s снимаются docker stats (CPU нормирован на лимит роли) и pg_stat_activity; до и после — счётчики пула pgx (внутренний порт 9090, не публикуется).
  • Правила анализа в scripts/track1_report.py: медиана повторов; насыщение — первый уровень с ростом RPS < 10%; узкое место — роль с максимальной утилизацией лимита (≥ 0.85 — насыщена); улучшение подтверждено, если min(RPS кандидата) > max(RPS baseline) по всем повторам, p95 не хуже, ошибок не больше. Метрика «CPU хоста» (сумма util × лимит × число контейнеров) добавлена после прогона 2.
  • Сырые данные: evidence/track1/raw.jsonl (одна строка — один прогон, без токенов). Сводка: summary.md, summary.csv. Графики RPS и p95 по сериям: report.html.

Ошибок (error_ratio) не было ни в одном прогоне.

Результаты (медианы повторов, исправленный код)

A — фиксированный бюджет API 1.0 CPU (прогон 3)

config RPS c=4 / 16 / 64 p95 c=16, ms util Redis c=16 util API c=16
1×1.00 400 / 431 / 460 87.6 1.00 0.59
2×0.50 414 / 436 / 432 93.8 1.00 0.72
4×0.25 366 / 431 / 475 93.2 0.93 0.86

RPS от числа реплик не зависит систематически: различия между конфигурациями до 13%, сопоставимы с разбросом повторов (4–14%), и знак меняется от уровня к уровню. p95 при c=16 вырос на 7% (88 → 94 ms) — в пределах разброса, поэтому эту часть гипотезы считаю не подтверждённой. Причина «потолка» не в API, а в Redis: он насыщен уже при одной реплике.

B — рост числа реплик по 0.5 CPU (прогон 3)

config пик RPS × к 1 реплике узкое место на пике
1×0.50 395 1.00 API 1.00
2×0.50 427 1.08 Redis 1.01 (API 0.67)
4×0.50 419 1.06 Redis 1.00 (API 0.37)

Saturation point — 2 реплики. Одна реплика упирается в собственный CPU; со второй упор переходит в Redis (0.5 CPU, 100% лимита), и дальше рост реплик не помогает: CPU API простаивает (0.37), а каждая запись в режиме scan делает SCAN по keyspace общего Redis. Смещение узкого места (API 1.00 → Redis 1.00) видно по утилизации и воспроизводится в прогоне 1 на другой машине. Величину прироста от второй реплики (+8% здесь, +26% в прогоне 1) нужно считать неточной: конфигурация 1×0.50 шла первой в серии, а серия C показала, что первая конфигурация может быть занижена на 10–16%.

C — проверка причины (4×0.5 API) (прогон 4: 5 повторов, базовая конфигурация в начале и в конце серии)

config RPS c=16 / 64 (медиана) min–max c=64 util Redis Δ к базе в конце, c=16 / 64
база (в начале серии) 357 / 411 369–424 0.99 −16% / −10%
PG 2 CPU 428 / 460 442–473 0.97 0% / +0.5%
LB 1 CPU 425 / 443 420–454 0.97 −0.5% / −3%
Redis 1 CPU 442 / 478 467–479 0.50 +3.5% / +4.5%
база (в конце серии) 427 / 458 451–476 0.97 —

Два результата:

  1. Методический: одна и та же базовая конфигурация в начале серии на 10–16% медленнее, чем в конце (первая конфигурация на «холодной» машине). В прогоне 3 база C стояла только в начале, поэтому все три изменения ресурсов выглядели как прирост — тот прогон признан смещённым и заменён (evidence/track1/legacy_before_review_fix/run3_C_superseded.jsonl). В scripts/track1.py добавлен неучитываемый разогрев перед первой конфигурацией серии (--series-warmup, 30 s); в прогонах этого отчёта его ещё не было.
  2. По существу: относительно базы в конце серии ресурсы PostgreSQL и LB не дают ничего, ресурс Redis — единственный, кто снимает насыщение (утилизация 0.97 → 0.50 от удвоенного лимита) и даёт прирост, но лишь +4% (диапазоны повторов почти не пересекаются: 467–479 против 451–476). Гипотеза C подтверждается в слабой форме: Redis — первое узкое место, но за ним сразу CPU двухъядерного узла (контейнеры занимают ≈80% от 2 vCPU, плюс генератор нагрузки). Удвоение квоты Redis на переподписанном узле не добавляет реальных ядер, а вот уменьшение работы Redis (серия D) освобождает общий CPU и даёт +126%. На старом коде (прогон 2) картина та же: Redis ×2 — +9%, PG и LB — 0%.

D — подтверждённое улучшение (4×0.5 API) (прогон 3)

кандидат RPS c=32 / 64 p95 c=32 / 64, ms util Redis / PG подтверждено
baseline (scan) 375 / 362 211 / 421 0.99 / 0.22 —
CACHE_INVALIDATION=version 722 / 818 132 / 244 0.21 / 0.76 да: +126% RPS и −42% p95 при c=64; все 3 повтора лучше всех 3 повторов baseline
DB_POOL_MAX=8 362 / 362 214 / 413 0.97 / 0.21 нет (0%)
LB_BALANCE=leastconn 365 / 315 205 / 451 1.00 / 0.20 нет (−13% при c=64)

Улучшение — отказ от SCAN+DEL при записи: свежесть кэша гарантирует версия чата в PostgreSQL, поэтому удалять старые ключи не нужно, они истекают по TTL (message_cache.go). Режим version — значение по умолчанию в compose.yaml. После улучшения узкое место смещается в PostgreSQL: утилизация 0.76–0.82, до 58 активных соединений, у пула появляются ожидания (10% acquire без свободного соединения, 0.65 ms в среднем). В прогоне 1 на старом коде то же улучшение дало +148% — эффект воспроизводится.

E — рост реплик после улучшения (прогон 3)

config пик RPS p95 c=64, ms util API / PG c=64 активных соединений PG c=64 CPU контейнеров, ядер из 2
1×0.50 527 180 1.00 / 0.49 3 1.21
2×0.50 599 244 0.73 / 0.62 35 1.57
4×0.50 550 392 0.37 / 0.63 59 1.57

После снятия упора в Redis вторая реплика даёт +14% (с той же оговоркой о первой конфигурации серии), а четвёртая уже ухудшает результат: −8% RPS и p95 в 1.6 раза выше (244 → 392 ms) — это сравнение второй и третьей конфигураций, и смещение «холодного старта» его не затрагивает. Ни один контейнер не упирается в свой лимит; вместе они занимают ≈1.57 из 2 vCPU runner, остальное делят генератор нагрузки, dockerd и сетевой стек. Растёт число одновременно активных соединений PostgreSQL (3 → 35 → 59). Интерпретация (не прямое измерение): (1) потолок CPU двухъядерного узла — реплики на одном узле не добавляют вычислительной мощности; (2) конкуренция в PostgreSQL — каждая запись обновляет строку chats.version, а при 8 чатах и 64 клиентах записи в один чат ждут блокировку строки; чем больше реплик и соединений, тем больше ожидающих. Ожидания блокировок (pg_locks, wait_event) не измерялись — это следующий шаг.

Выводы трека

  1. При фиксированном CPU реплики не увеличивают пропускную способность (A); заметного ухудшения p95 в пределах разброса не обнаружено.
  2. При росте ресурсов насыщение наступает на 2 репликах из-за общей зависимости — Redis (B, воспроизводится в прогонах 1 и 3). Серия C с контрольной базой показывает, что за Redis сразу следует CPU узла: удвоение квоты Redis даёт лишь +4%, ресурсы PostgreSQL и LB — 0%.
  3. Подтверждённое улучшение — запись без SCAN-инвалидации при версии кэша из PostgreSQL: +126% RPS и −42% p95 на той же конфигурации (D, воспроизводится в прогонах 1 и 3).
  4. После улучшения насыщение смещается к PostgreSQL и CPU узла (E): больше двух реплик на одном двухъядерном узле только увеличивают задержку. Дальнейшее масштабирование — отдельные узлы и снижение конкуренции за строку чата (например, версия в отдельной таблице или счётчик без блокировки строки), а не реплики.

Ограничения трека

  • Runner 2 vCPU: сумма лимитов в конфигурациях 4×0.5 (3.5–4 CPU) больше, чем у хоста; лимиты Docker — квоты CFS. Поэтому «утилизация лимита < 1» не значит, что CPU свободен.
  • Сокращённая методика: 3 уровня параллелизма, 15 s, 3–5 повторов; точка насыщения определена с шагом ×4 по параллелизму.
  • Разные job — разные модели CPU; абсолютные RPS сравнимы только внутри серии.
  • Первая конфигурация серии занижена на 10–16% («холодный старт», измерено в C). Это затрагивает величину прироста 1 → 2 реплики в B и E, но не смещение узкого места по утилизации и не результат D (+126% намного больше смещения, к тому же baseline D в прогоне 1 тоже уступил кандидату в 2.5 раза). Разогрев серии добавлен в инструмент, но в этих прогонах не применялся.
  • Аномалия: в повторах A 4×0.25 c=64 (и в прогоне 1, и в прогоне 3) сборщик docker stats получил мало замеров — утилизация в этой точке занижена при нормальном RPS. Выводы по A сделаны по c=4/16.
  • CPU генератора нагрузки и ожидания блокировок PostgreSQL не измерялись; выводы о CPU узла и блокировках в E — интерпретация.
  • Только closed-loop; задержки — успешных запросов (ошибок не было).

Ограничения и следующие шаги

  • Выдерживается отказ одной API-реплики (процесс/контейнер) и отказ Redis в отдельных командах кэша. Не выдерживается отказ LB, PostgreSQL, Redis целиком (нужен для сессий) или хоста — это SPOF (один узел, БД не реплицирована).
  • Миграции совместимы с работающей версией только при подходе expand→contract; 0002 и 0003 только добавляют объекты. Деструктивные миграции так применять нельзя.
  • Ключи идемпотентности и версия чата хранятся в PostgreSQL в транзакции записи — атомарность без распределённых транзакций ценой блокировки строки чата на время записи (см. серию E).
  • Ошибки, сгенерированные самим HAProxy (502/503/504), не содержат X-Instance-Id — это допускается контрактом.
  • Docker-стенд на машине разработки не запускается (нет VT-x); доказательства получены на GitHub runner. На любой машине с Docker всё воспроизводится теми же командами.