32 KiB
Отчёт — лабораторная 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 используется для двух задач:
- Кэш первой страницы списка чатов (read-through + stampede protection): кэшируется только
ListVisible(after == nil); более глубокие страницы обслуживаются напрямую из PostgreSQL. - Распределённая координация загрузки (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-redis0включает дефолтные 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).
Решение. Два уровня координации, работающие при любом числе реплик:
- Внутри процесса —
singleflight.Group.DoChanпо ключу кэша. Все горутины пода, промахнувшиеся по одному ключу, объединяются в одну операцию; результат клонируется перед возвратом, потому что слайс общий. Это убирает сотни лишних походов в Redis на горячем ключе и раздаёт ошибкуloaderвсем ожидающим, не усиливая нагрузку на упавшую БД внутри пода. Контекст загрузки не отменяется при отмене вызывающего (context.WithoutCancel+ общий таймаутlock_ttl + lock_wait_timeout). - Между процессами — распределённая блокировка Redis
SET NX EX(ключlock:<cache-key>) с уникальным токеном на каждый захват (TTLcache.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 и самоочищаются.