Files
mtusi2026lab4/REPORT.md
T
2026-10-15 20:45:29 +03:00

32 KiB
Raw Blame History

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

  • Автор, группа: Владислав Кунецкий, БВT2303
  • Целевая оценка: 5
  • Выбранный трек 5: трек 1 — согласованность кэша (распределённая защита от stampede)
  • Commit/PR: solution/bvt2303-kunetsky
  • Использованные библиотеки: ogen - генерация транспортного слова из openapi спеки, testify, mockery/v3 - тесты, zap обернутый в slog - логгирование.
  • Помощь ИИ использовалась для обсуждения архитектуры, ревью и подготовки кода; решение проверено и изменено автором.

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

Требования: make, Go 1.27+ / Docker

запуск через go

make run

запуск через docker

cp .env.example .env
docker build -t mtusi-messenger:lab1 .
docker run --rm --name mtusi-messenger-lab1 \
  -p 127.0.0.1:8080:8080 --env-file .env mtusi-messenger:lab1

В другом терминале:

make check
make unit-test
make test

Контейнер останавливается через Ctrl-C или docker stop mtusi-messenger-lab1; приложение принимает SIGTERM и завершает HTTP-сервер с timeout 10 секунд. Состояние хранится только в памяти процесса. Удаление контейнера намеренно удаляет все учебные данные:

docker rm -f mtusi-messenger-lab1

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

Клиент → ogen-generated HTTP transport → REST adapter → user/chat/message services → единый in-memory Store. Store реализован на mutex; создание чата вместе с проверкой участников выполняется атомарно. ID и created_at назначаются in-memory storage. После перезапуска процесса данные исчезают. Store реализован таким образом, чтобы в будущем изменить его на реальную базу данных, без изменения сигнатур и кода в сервисах

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

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab1 public API scenario evidence/smoke.txt
Контракт и структура make check PASS evidence/check.txt
Unit, vet, race, lint make unit-test, go vet ./..., make lint PASS evidence/quality.txt
Docker build/run/health docker build, curl /health/live image built, {"status":"ok"} evidence/docker.txt
Сброс in-memory состояния restart container, old X-User-Id old user receives 401 evidence/restart.txt
100 concurrent messages 10 clients × 10 messages 100 unique messages evidence/concurrency.txt
SIGTERM kill -TERM <pid> graceful stop under 10 seconds evidence/sigterm.txt
Трек 1 benchmark go test -run '^$' -bench '^BenchmarkMessageCreate$' -benchmem -count=5 ./internal/storage/memory и baseline через Go overlay; scripts/track1_benchmark.py --mode ... --requests 100000 изолированная вставка 1k/10k/50k и E2E с ровно 100 000 запросами на комбинацию, concurrency 1/4/16/32: RPS/p95/p99/RSS evidence/track1/
Memory exhaustion point python3 scripts/memory_experiment.py --image mtusi2026lab1-messenger:arm64 --memory 64m --max-messages 20000 --output evidence/memory-experiment.json --plot evidence/memory-experiment.png container OOMKilled, exit 137, 8997 successful messages evidence/memory-experiment.json, evidence/memory-experiment.png

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

В рамках трека оптимизировано добавление новых сообщений в конец отсортированной истории. Если ключ нового сообщения больше ключа последнего сообщения, используется прямой append; бинарный поиск и упорядоченная вставка остаются fallback-путём для сообщений, пришедших не по порядку. Изолированный Go benchmark выполнялся на Apple M5 Pro, darwin/arm64, Go 1.27.1, пять раз для историй 1 000, 10 000 и 50 000. Baseline собран через Go overlay с удалённым fast path, optimized — текущая версия. Полные сырые результаты: evidence/track1/baseline-storage-benchmark.txt и optimized-storage-benchmark.txt.

Отдельно выполнен end-to-end benchmark через go run без Docker: истории 1 000, 10 000 и 50 000; конкуренция 1, 4, 16 и 32; ровно 100 000 нагрузочных POST-запросов на каждую комбинацию и 100 warm-up запросов; RSS дочернего исполняемого процесса сэмплировался каждые 100 мс. Baseline запускается через go run -overlay, optimized — обычный go run. Результаты: evidence/track1/go-baseline/results.json, go-optimized/results.json, go-comparison.json.

Оптимизация уменьшила стоимость операции добавления сообщения: медиана составляет 308.2 / 241.8 ns/op для истории 1 000, 335.9 / 242.2 ns/op для 10 000 и 349.8 / 242.5 ns/op для 50 000 (baseline / optimized). Это соответствует ускорению примерно в 1.27×, 1.39× и 1.44× соответственно. Число аллокаций одинаковое: 1 alloc/op, 16 B/op. Вставка в середину по-прежнему использует бинарный поиск и slices.Insert; оптимизирован только наиболее частый сценарий последовательного добавления в конец.

На полном HTTP-пути это ускорение не переносится напрямую в RPS: там дополнительно присутствуют HTTP, JSON, маршрутизация и общий mutex Store. В новом эксперименте число запросов фиксировано, поэтому сравниваются одинаковые объёмы работы, а не разные числа запросов за заданное время. При увеличении объёма до 100 000 запросов результаты стали стабильнее: optimized выигрывает по RPS в 5 из 12 комбинаций, прежде всего при concurrency 4/16; на concurrency 32 система упирается в конкуренцию за общий mutex, поэтому дополнительное увеличение параллелизма не даёт ускорения. Разница остаётся умеренной, поскольку fast path оптимизирует только часть полного HTTP-запроса.

Точка отказа по памяти

Эксперимент запускался с лимитом контейнера 64m, swap отключён (--memory-swap 64m). В каждое сообщение записывалось 4000 Unicode-символов. Контейнер завершился после 8997 подтверждённых сообщений с OOMKilled=true и ExitCode=137. На графике evidence/memory-experiment.png показан рост памяти контейнера до лимита и число подтверждённых сообщений. Причина отказа — in-memory Store удерживает все сообщения и их строки; после достижения cgroup memory limit ядро завершает процесс OOM killer. Это ожидаемая граница выбранной архитектуры: сервер не вводит лимиты количества сообщений и не выполняет controlled degradation.

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
Перезапуск контейнера in-memory данные исчезают старый пользователь получает 401 данные теряются намеренно при restart
SIGTERM сервер прекращает приём и завершает работу остановка менее 10 секунд подтверждённые данные не сохраняются
10 клиентов × 10 сообщений ровно 100 уникальных сообщений 100 уникальных сообщений нет потери в рамках процесса

Трек 1: baseline / optimized

History Concurrency Requests before/after RPS before RPS after p95 before/after ms p99 before/after ms RSS max before/after KiB
1000 1 100000 / 100000 7334.409 7184.594 0.146 / 0.150 0.186 / 0.231 32560 / 32272
1000 4 100000 / 100000 8823.924 8996.523 0.654 / 0.632 0.869 / 0.867 35520 / 35504
1000 16 100000 / 100000 7336.995 7482.719 3.514 / 3.445 4.631 / 4.577 35808 / 35680
1000 32 100000 / 100000 7386.656 7381.500 7.026 / 7.058 8.953 / 9.054 36336 / 36208
10000 1 100000 / 100000 7138.887 7150.931 0.149 / 0.146 0.210 / 0.187 36208 / 36224
10000 4 100000 / 100000 9043.732 9052.965 0.626 / 0.628 0.841 / 0.859 38496 / 38384
10000 16 100000 / 100000 7442.895 7440.817 3.485 / 3.468 4.703 / 4.701 38384 / 38624
10000 32 100000 / 100000 7382.485 7419.326 7.051 / 7.049 9.096 / 9.096 38384 / 38400
50000 1 100000 / 100000 7158.653 7213.610 0.149 / 0.145 0.211 / 0.191 52416 / 52304
50000 4 100000 / 100000 9079.212 9036.335 0.623 / 0.630 0.823 / 0.842 53152 / 53008
50000 16 100000 / 100000 7419.068 7453.530 3.471 / 3.455 4.694 / 4.688 53536 / 53216
50000 32 100000 / 100000 7427.333 7384.536 7.049 / 7.084 9.007 / 9.203 53760 / 53776

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

Решение выдерживает конкурентные запросы внутри одного процесса и корректный SIGTERM. Оно не сохраняет состояние после перезапуска и не рассчитано на несколько API-процессов. Авторизация через X-User-Id является учебным механизмом lab1 и не является безопасной аутентификацией. Persistence, внешняя база и горизонтальное масштабирование не реализованы.

Кэш Redis (lab2, оценка 4 и трек 1 оценки 5)

Источник истины и роли Redis

PostgreSQL — источник истины для пользователей, чатов, членства, сообщений и сессий. Сессии хранятся только в PostgreSQL: Resolve по token_hash — это дешёвый lookup по первичному ключу, поэтому отдельный кэш сессий не используется, а отзыв всегда авторитетен (нет рассогласования кэша и БД). Redis 7.4 используется для двух задач:

  1. Кэш первой страницы списка чатов (read-through + stampede protection): кэшируется только ListVisible(after == nil); более глубокие страницы обслуживаются напрямую из PostgreSQL.
  2. Распределённая координация загрузки (distributed lock), чтобы при нескольких репликах холодный ключ грузила только одна.

Реализация — декоратор internal/storage/redis/chat_repository.go над интерфейсом chat.Repository.

Конфигурация и отключение

  • REDIS_ENABLED=false — Redis не подключается; список чатов обслуживается напрямую из PostgreSQL.
  • CACHE_ENABLED=false — кэш списка чатов выключен. CACHE_ENABLED=true при REDIS_ENABLED=false даёт ошибку конфигурации.
  • CACHE_CHAT_LIST_TTL (по умолчанию 5m) — TTL записей списка чатов.
  • CACHE_LOCK_TTL (по умолчанию 10s) и CACHE_LOCK_WAIT_TIMEOUT (по умолчанию 2s) — TTL распределённой блокировки и бюджет ожидания лидера.
  • REDIS_DIAL_TIMEOUT (по умолчанию 300ms), REDIS_READ_TIMEOUT/REDIS_WRITE_TIMEOUT (по умолчанию 200ms), REDIS_MAX_RETRIES (по умолчанию -1). Короткие таймауты и отсутствие ретраев (-1, а не 0 — у go-redis 0 включает дефолтные 3 ретрая) не дают «замороженному» Redis подвешивать API.
  • Бюджет кэш-фазы 500ms (константа декоратора) ограничивает ожидание вызывающего; по истечении — fallback в PostgreSQL.
  • SESSION_TTL_SECONDS (по умолчанию 3600) — TTL серверной сессии; контрактное имя переменной, читается напрямую.
  • Redis настроен с --appendonly yes --appendfsync everysec --save 60 1 и named volume, поэтому переживает рестарт хранилища.
  • Переменные окружения без префикса (SERVER_*, LOG_*, POSTGRES_*, REDIS_*, CACHE_*, SESSION_TTL_SECONDS), что соответствует 12-factor.

Инвалидация

Версия списка чатов хранится в PostgreSQL (user_chat_versions) и увеличивается в той же транзакции, что и вставка чата и участников. Ключ кэша — chat_list:<user>:<version>:<limit>, где версия читается из источника перед обращением к кэшу (ListVersion). Сигнал об устаревании больше не живёт в Redis, поэтому его потеря невозможна: даже если Redis недоступен в момент создания чата, версия в PostgreSQL уже увеличена, и следующий ListVisible читает новый ключ (промах → свежий список). Старые записи под прежней версией становятся недостижимыми и истекают по TTL; персистентность Redis на корректность не влияет.

Порядок «сначала версия, потом данные»: данные под ключом версии v загружаются после чтения v, поэтому могут быть свежее v, но не старше. Гонка даёт лишний промах на следующем запросе, но не устаревшую выдачу.

Для защиты от deadlock вход BumpChatListVersions сортируется (ORDER BY m и Go-сортировка) и дедуплицируется (DISTINCT/slices.Compact): параллельные транзакции с пересекающимися участниками берут эксклюзивные блокировки строк user_chat_versions в одном порядке. В AddChatMembers передаётся исходный список участников, поэтому дубликаты по-прежнему дают 409 conflict, как и раньше.

Деградация при потере Redis

  • ChatRepository.ListVisible: ошибка кэша (Redis недоступен, таймаут ожидания, битая запись) → прямой запрос в PostgreSQL; 503 от кэша не возвращается.
  • Ошибка источника (PostgreSQL) пробрасывается клиенту без повторного запроса — декоратор различает ошибку источника и ошибку кэша, поэтому упавшая БД не получает удвоенную нагрузку.
  • GET /health/ready проверяет PostgreSQL через агрегатор internal/health. Redis не является критичной зависимостью: при его потере кэш обходится через PostgreSQL, а readiness остаётся успешным.
  • Сессии и авторизация не зависят от Redis: Resolve всегда читает PostgreSQL, поэтому отозванный, истёкший или анонимный токен даёт 401 независимо от состояния Redis.

Проверка деградации (scripts/redis_outage_check.sh → evidence/cache/redis-outage.txt): скрипт останавливает и «замораживает» (docker pause) Redis, проверяет бюджет по времени и статусы, создаёт чат во время pause и подтверждает, что после unpause список содержит новый чат. Результат прогона: baseline 6 ms; после docker stop 476 ms; 30 параллельных GET /chats при docker pause — max 215 ms, p95 214 ms (бюджет 2000 ms); создание чата при pause = 201; после восстановления новый чат виден за 5 ms; зависших lock:* без TTL нет.

Трек 1: согласованность кэша

Гипотеза. При холодном кэше N одновременных чтений первой страницы вызывают N SQL-запросов к PostgreSQL (cache stampede).

Решение. Два уровня координации, работающие при любом числе реплик:

  1. Внутри процесса — singleflight.Group.DoChan по ключу кэша. Все горутины пода, промахнувшиеся по одному ключу, объединяются в одну операцию; результат клонируется перед возвратом, потому что слайс общий. Это убирает сотни лишних походов в Redis на горячем ключе и раздаёт ошибку loader всем ожидающим, не усиливая нагрузку на упавшую БД внутри пода. Контекст загрузки не отменяется при отмене вызывающего (context.WithoutCancel + общий таймаут lock_ttl + lock_wait_timeout).
  2. Между процессами — распределённая блокировка Redis SET NX EX (ключ lock:<cache-key>) с уникальным токеном на каждый захват (TTL cache.lock_ttl, по умолчанию 10s). Победитель делает double-check, грузит данные и снимает лок атомарным Lua compare-and-delete; удалить можно только свой захват.

Дедлайн загрузки. loader выполняется с дедлайном lock_ttl − 1s; ReleaseLock возвращает признак «лок был наш», поэтому если загрузка превысила TTL, в лог пишется предупреждение lock expired before release: loader slower than lock ttl. Конструктор отвергает конфигурацию с lock_ttl ≤ 1s и wait_timeout > lock_ttl.

Ожидание и таймаут. Проигравшие сначала проверяют кэш без сна, затем опрашивают его с экспоненциальным backoff и jitter (50, 100, 200, 400, 500 ms, cap 500). Исход ожидания явный: waitHit, waitRetry (лок исчез без значения → повторить захват), waitDegraded (Redis недоступен → прямая загрузка), waitTimeout (держатель держит лок дольше cache.lock_wait_timeout). И waitDegraded, и waitTimeout ведут к прямой загрузке из источника: кэш не должен ронять чтение, когда источник истины доступен.

Параметры координации задаются через конфиг (cache.lock_ttl, cache.lock_wait_timeout) и env CACHE_LOCK_TTL, CACHE_LOCK_WAIT_TIMEOUT, что соответствует 12-factor.

Реализация: internal/platform/cache/distributed.go (DistributedCache), примитивы блокировки — AcquireLock/ReleaseLock/LockHeld в RedisCache (internal/platform/cache/redis.go).

Методика. Интеграционный тест internal/storage/redis/chat_repository_test.go использует реальный Redis и сгенерированный мок источника; ожидания мока фиксируют, что источник вызван ровно один раз.

Результат (evidence/cache/consistency.txt):

Сценарий Нагрузка Обращений к источнику
Наивный cache-aside без координации 100 одновременных холодных чтений 96–100
DistributedCache (один инстанс) 100 одновременных холодных чтений 1
DistributedCache (3 экземпляра, общий Redis) 3 × 30 одновременных холодных чтений 1

Строка с тремя экземплярами — доказательство координации через Redis: три независимых объекта DistributedCache (каждый со своим токеном блокировки) работают с общим Redis и дают ровно одну загрузку из PostgreSQL. Это тест нескольких логических инстансов в одном процессе; координация вынесена в Redis, поэтому она не зависит от локальной памяти процесса и работает для реальных реплик. Отдельный cross-process сценарий с несколькими контейнерами API не запускался.

Read-after-write. TestCreateInvalidatesMemberCaches (декоратор) и TestCreateBumpsMemberListVersions (Postgres): после POST /chats версия списка увеличивается у создателя и всех участников в той же транзакции, поэтому следующий GET /chats у обоих сразу видит новый чат — и на прогретом кэше, и после недоступности Redis.

Восстановление после сброса кэша. TestEvictedCacheEntryReloadsFromSource в chat_repository_test.go: после удаления записи из Redis следующее чтение перезагружает данные из PostgreSQL. TestResolveRejectsExpiredToken (postgres) подтверждает, что истёкшая сессия отклоняется.

Persistence. make test-persistence ACTION_SCRIPT=scripts/restart.sh проходит: API и все хранилища (PostgreSQL, Redis) перезапускаются с сохранением volumes, подтверждённые данные и действующая сессия сохраняются.

Эксперимент на уровне репозитория: SQL-запросы и latency

Команда: ./scripts/cache_performance_experiment.sh. Сырые результаты: evidence/cache/performance.txt.

TestCachePerformanceExperiment работает на реальных PostgreSQL и Redis: 150 чатов, concurrency 50, по 10 000 запросов на режим. Baseline выполняет 10 000 SQL-запросов, DistributedCache на холодном кэше делает ровно 1 загрузку, горячий кэш — 0.

Режим SQL-запросов RPS p50 p95 p99
Baseline (no cache) 10,000 6,742 7.23ms 9.14ms 11.26ms
Redis cache (cold) 1 11,886 4.07ms 5.67ms 6.56ms
Redis cache (hot) 0 12,600 3.87ms 5.02ms 5.84ms

Таблица показывает арифметические средние метрик трёх прогонов из performance.txt; средние p95/p99 не являются процентилями объединённой выборки.

API-эксперимент: Redis-кэш под нагрузкой

Команда: ./scripts/api_cache_performance.sh. Сырые результаты: evidence/cache/api-performance.txt.

Создаются 4 пользователя и 60 чатов: каждый пользователь владеет 15 чатами и входит ещё в чаты соседнего пользователя. Для каждого режима выполняется 1000 GET-запросов GET /api/v1/chats?limit=50 с 8 конкурентными worker'ами. Перед запросами пользователи проходят регистрацию и Basic → Bearer-аутентификацию. API пересоздаётся с CACHE_ENABLED=false и CACHE_ENABLED=true; PostgreSQL, Redis и volumes сохраняются. Выполнено два последовательных прогона каждого режима.

Прогон Режим Requests Workers RPS p50 p95 p99
1 Cache disabled 1000 8 2,193 3.34ms 5.24ms 7.38ms
1 Redis cache 1000 8 2,353 3.08ms 5.36ms 6.62ms
2 Cache disabled 1000 8 1,971 3.68ms 6.22ms 8.55ms
2 Redis cache 1000 8 2,430 2.92ms 5.48ms 7.25ms

Среднее: RPS вырос с 2,082 до 2,391 (+15%); p50 снизился с 3.51 до 3.00ms (-15%); p95 — с 5.73 до 5.42ms (-5%); p99 — с 7.97 до 6.93ms (-13%). Это black-box измерение полного HTTP-пути: маршрутизация, Bearer-аутентификация, PostgreSQL/Redis, сериализация JSON и сеть. Прирост меньше, чем в repo-эксперименте, потому что кэшированный путь теперь делает один дополнительный indexed-read версии списка в PostgreSQL на запрос. Сессии в обоих режимах хранятся в PostgreSQL; переключается только кэш списка чатов.

Ограничения

  • cache.lock_wait_timeout — бюджет ожидания для одного вызова. Перед polling выполняется немедленная проверка кэша; если значение ещё не появилось, следующий опрос происходит через 50 ms со случайным jitter.
  • Бюджет кэш-фазы 500ms ограничивает ожидание вызывающего в GetOrLoad; по истечении клиент уходит в PostgreSQL, а фоновая загрузка (context.WithoutCancel) всё равно дорабатывает и заполняет кэш. Цена: при обрыве бюджета возможен второй запрос в PostgreSQL (дублирование). Бюджет заметно больше типичной латентности загрузки (<100 ms), поэтому на штатном пути не срабатывает.
  • Хвост fill после получения данных (синхронные Set ≤200 ms + ReleaseLock ≤300 ms) при blackhole может удерживать ответ до 500 ms; горутины для отложенного релиза не вводятся, чтобы не усложнять остановку сервиса.
  • Худший случай Redis-таймаутов на один запрос при частичной деградации — порядка Get + AcquireLock + fill Get + Set + Release (≈1.4 s); при полном blackhole первый же Get упирается в read_timeout (200 ms) и уходит в PostgreSQL.
  • Ошибки кэша (недоступный Redis, таймаут ожидания, битая запись) деградируют в прямой запрос к PostgreSQL; 503 от кэша не возвращается. Ошибка самого PostgreSQL пробрасывается клиенту без повторного запроса, чтобы не удваивать нагрузку на упавшую БД.
  • Битая запись кэша удаляется сразу при Unmarshal-ошибке, чтобы не гонять мусор до истечения TTL.
  • Ошибки источника не кэшируются. Внутри пода их раздаёт singleflight, поэтому усиление ограничено одним обращением на под; между подами распределённая блокировка не заменяет circuit breaker, и при недоступности БД возможно дополнительное обращение на реплику.
  • Каждый ListVisible(after == nil) читает версию списка из PostgreSQL (один indexed-read); это цена согласованности кэша с источником истины.
  • Кэшируется только первая страница списка чатов; это осознанный компромисс (основная доля чтений).
  • Ключ включает limit, поэтому разные limit не переиспользуют запись.
  • Дедупликация загрузок (DistributedCache) не зависит от локальной памяти процесса: координация вынесена в Redis. При недоступности Redis она теряется: каждый под загружает данные самостоятельно (stampede возвращается), но запросы продолжают обслуживаться — осознанный graceful degradation.
  • Если загрузка лидера превышает cache.lock_ttl, блокировка истекает и другая реплика может начать параллельную загрузку. Продление блокировки (watchdog) и fencing не реализованы; loader ограничен дедлайном lock_ttl − 1s, и превышение фиксируется предупреждением lock expired before release.
  • Сессии хранятся только в PostgreSQL и не кэшируются: Resolve по token_hash — дешёвый lookup по первичному ключу, а отзыв всегда авторитетен (нет рассогласования кэша и БД).
  • Ключи старой схемы chat_gen:* (писались без TTL) больше не читаются; их можно удалить разово. Все актуальные ключи (chat_list:*, lock:*) создаются с TTL и самоочищаются.