written to Redis
51 KiB
Отчёт — лабораторная 2
- Автор, группа: Кучерявенко Максим, БВТ2303
- Целевая оценка; выбранный трек 5, если нужен: 5, трек 1 (согласованность кэша)
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: Kotlin 2.3.20, Ktor 3.3.0 (Netty, Auth, ContentNegotiation, StatusPages, CallLogging, Swagger UI), Koin 4.1 с аннотациями и KSP, Exposed 1.0 (+ exposed-migration для генерации миграций), HikariCP 6.3, Flyway 11.9, PostgreSQL JDBC 42.7, Lettuce 6.7 (клиент Redis), BouncyCastle 1.81 (Argon2id), kotlinx-serialization 1.10. Тесты на kotlin.test + JUnit 5, Ktor
testApplicationи Testcontainers 1.21. ИИ (Claude) использовал как парного разработчика.
Запуск из чистого clone
Нужны Docker 24+ с Compose v2, Python 3.9+ для публичных тестов, openssl для генерации секретов. Для ./gradlew test дополнительно нужна JDK 21+ и запущенный Docker (тесты поднимают PostgreSQL и Redis через Testcontainers). Я всё запускал на Docker 28.4, Compose 2.39, JDK 24.
# один раз: пароли для PostgreSQL и Redis в secrets/ (папка в .gitignore, существующие файлы не перезаписываются)
./scripts/init-secrets.sh
# сборка образа и запуск api + postgres + redis, --wait ждёт healthcheck всех трёх
docker compose up -d --build --wait
# миграции Flyway применяются сами при старте API, руками ничего делать не надо
make check
make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
# свои тесты (нужен Docker)
./gradlew test
# план запроса истории на 70 000 сообщений, результат в evidence/explain-history.txt
./scripts/explain-history.sh
# трек 1: вся матрица экспериментов (~25 минут, нужен k6), сводка в evidence/track1/summary.md
./scripts/track1/run-all.sh
# остановка с сохранением данных
docker compose stop # или docker compose down, volume при этом остаётся
# намеренное удаление всех учебных данных (volume postgres-data)
docker compose down -v
Короткий TTL сессии для ручной проверки: SESSION_TTL_SECONDS=5 docker compose up -d --wait api, вернуть обратно: docker compose up -d --wait api.
Локально без Docker: ./gradlew run. Конфиг берётся из run/development/config/*.conf (локальный PostgreSQL, база messenger), API слушает 127.0.0.1:8081, чтобы не мешать контейнеру на 8080. Если локального Redis нет, приложение всё равно работает, просто без кэша.
Архитектура и решения
клиент ──HTTP──▶ api (Ktor, :8080) ──JDBC, пул ≤10──▶ postgres (volume postgres-data) ← источник истины
│
└──RESP, таймаут 500 мс──▶ redis (без persistence) ← кэш сессий
Три контейнера в compose.yaml: api (мой образ), postgres:17.6-alpine3.22, redis:8.4.0-alpine. Наружу опубликован только API и только на 127.0.0.1. API стартует после того, как PostgreSQL и Redis прошли healthcheck. Пароли передаются через Docker secrets из secrets/, в переменных окружения и в Git их нет.
Что перенёс из lab1. Весь API и контракт, формат ошибок, X-Request-Id, курсорную пагинацию со scope внутри курсора, валидацию, Dockerfile (multi-stage, non-root, healthcheck), Swagger UI на /docs.
Что поменял.
- Хранилище в памяти заменил на PostgreSQL. Таблицы
users,chats,chat_members,messages,sessions, миграцияsrc/main/resources/migrations/V1__init.sql. Первичные ключи UUID, внешние ключи сON DELETE CASCADE,usernameуникальный (users_username_key) и проверяетсяCHECKпо формату, время вездеtimestamptzс точностью до микросекунд. - Добавил Koin (модули конфигов, репозиториев и сервисов собираются из аннотаций через KSP) и Exposed. Все запросы идут через DSL Exposed, то есть параметризованы, SQL руками не склеивается.
- Миграции можно генерировать:
./gradlew generateMigration --args="add_something"сравнивает модели Exposed со схемой локальной базы и пишетV<N>__add_something.sql. Модели совпадают сV1, генератор на текущем коде отвечает «schema is up to date». - Аутентификация по контракту. Регистрация с паролем,
POST /api/v1/auth/sessionsпо Basic, все остальные бизнес-запросы по Bearer,X-User-Idбольше ничего не значит. Пароль хешируется Argon2id (m=19456, t=2, p=1, соль 16 байт). bcrypt не подходил, потому что обрезает пароль до 72 байт. Для несуществующего логина хеш всё равно считается, чтобы по времени ответа нельзя было понять, есть ли такой пользователь. - Токен сессии — 32 случайных байта из
SecureRandomв base64url. В базе хранится только SHA-256 токена иexpires_at. TTL задаётсяSESSION_TTL_SECONDS, logout удаляет строку сессии. - Basic и Bearer сделаны своими маленькими провайдерами (
plugins/authentication/providers), потому что встроенные в Ktor пишутrealmбез кавычек и добавляют свойWWW-Authenticate, а в контракте точный формат заголовка.
Транзакционные границы.
- Создание чата — одна транзакция: проверка участников, вставка в
chats, пачка вставок вchat_members. Если что-то падает, откатывается всё (это проверяетExposedChatRepositoryTest). - Регистрация —
INSERT ... ON CONFLICT DO NOTHINGпо уникальномуusername. Из двух одновременных запросов вставится один, второй получит 409, без исключения и без гонки «проверил, потом вставил». - Отправка сообщения — проверка членства и вставка в одной транзакции.
- Каждый HTTP-запрос открывает транзакцию только на свою операцию (
suspendedTransactionнаDispatchers.IO). Обращения к Redis идут вне транзакции, чтобы не держать соединение из пула, пока ждём кэш.
Пагинация. Курсор (created_at, id) вместо offset. Запрос страницы — WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id LIMIT 51, под него индекс messages_chat_id_created_at_id_idx (chat_id, created_at, id). Каждая страница читает из индекса ровно 51 строку, сколько бы сообщений ни было до неё. Для списка чатов отдельный индекс chat_members_user_id_idx, потому что первичный ключ chat_members начинается с chat_id.
Redis: кэш сессий. Источник истины — PostgreSQL, Redis только ускоряет проверку Bearer-токена, которая есть в каждом запросе.
- Ключ
session:<sha256 токена>, значение — JSON с id сессии, пользователем и сроками. - Чтение по схеме cache-aside: сначала Redis, если ключа нет — PostgreSQL, потом запись в Redis через
SET ... NX PXAT. - Срок жизни ключа — меньшее из
expires_atсессии и 60 секунд (sessionCacheTtlSeconds). Срок сессии к тому же сверяется в коде при каждом запросе, так что просроченная сессия не пройдёт, даже если ключ ещё жив. - Logout сначала удаляет сессию в PostgreSQL, потом пишет в ключ метку
revokedдоexpires_at. Заполнение кэша идёт только черезNX, поэтому запрос, который прочитал сессию из базы до logout и пишет её в кэш после, метку не перетрёт. - Метка может не дойти до Redis, если он в этот момент лежит или завис, а копия сессии, закэшированная до сбоя, в Redis при этом останется. Поэтому logout в той же транзакции, что и удаление сессии, пишет строку в
session_revocations(миграцияV2) и удаляет её только после того, как метка записана. После любой ошибки Redis и при старте API кэшу не доверяют: чтения идут в базу, пока один запрос не допишет в Redis все метки изsession_revocations. Неудачная попытка повторяется не чаще раза в секунду. - Если Redis недоступен (отказ соединения или таймаут 500 мс), чтение идёт мимо кэша в PostgreSQL, logout тоже работает: он нужен только базе. После неудачного подключения следующая попытка не раньше чем через секунду, а команды без соединения сразу отклоняются, поэтому лежащий Redis не тормозит запросы.
- Промахи по одному токену схлопываются (single-flight): если поиск сессии в базе для этого токена уже идёт, следующие запросы ждут его результат, а не отправляют свой SELECT. Это защита от cache stampede, подробно в треке 1. Включается
SESSION_CACHE_SINGLE_FLIGHT(по умолчаниюtrue), выключатель оставлен для сравнения в эксперименте. - В лог пишется только смена состояния кэша («unavailable» и «available again»), а не каждый промах. Иначе при лежащем Redis API пишет по предупреждению на запрос.
- Persistence у Redis выключен (
--save "",--appendonly no). Это осознанно: Redis не единственное хранилище сессий, после его рестарта кэш просто заполняется заново из базы. Лимит памяти 64 МБ, вытеснениеvolatile-lru(у всех ключей есть TTL).
Пул и таймауты. HikariCP: максимум 10 соединений, ожидание свободного соединения 2 с, проверка соединения 1 с, statement_timeout 5 с на стороне PostgreSQL. Exposed не повторяет транзакцию (defaultMaxAttempts = 1), иначе при лежащей базе запрос висел бы втрое дольше. Redis: подключение и команда по 500 мс. Если база недоступна (SQLSTATE 08* или 57P*, таймаут пула), API отвечает 503 unavailable в общем формате ошибок. /health/live при этом 200, /health/ready делает SELECT 1 и отвечает 503.
Переменные окружения. .env.example описывает роли, реальные имена у меня такие:
В .env.example |
У меня | Где задаётся |
|---|---|---|
APP_HOST, APP_PORT |
так же | compose.yaml, по умолчанию 0.0.0.0:8080 |
SESSION_TTL_SECONDS |
так же | compose.yaml, берётся из окружения или .env, по умолчанию 3600 |
DATABASE_URL_FILE |
DB_HOST, DB_PORT, DB_NAME, DB_USER + DB_PASSWORD_FILE |
compose.yaml, пароль — Docker secret db_password |
SESSION_STORE, CACHE_URL_FILE |
REDIS_HOST, REDIS_PORT + REDIS_PASSWORD_FILE |
compose.yaml, пароль — Docker secret redis_password. Сессии всегда в PostgreSQL, Redis всегда кэш, переключателя нет |
| — | SESSION_CACHE_SINGLE_FLIGHT |
compose.yaml, по умолчанию true; false только для сравнения в треке 1 |
APP_ENV |
не используется | — |
.env для запуска не обязателен, все значения по умолчанию есть в compose.yaml.
Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
| Публичный smoke | make check, make test на только что поднятом стенде |
PASS: offline skeleton structure..., PASS: lab2 public API scenario |
evidence/smoke.txt |
| Миграции с нуля | docker compose down -v, затем up -d --build --wait |
в flyway_schema_history версия 1 init, success = t, созданы все 5 таблиц |
evidence/clean-start.txt |
| Повторный запуск миграций без дублей | рестарт API на той же базе; DatabaseMigrationTest |
в логе Schema "public" is up to date. No migration necessary; тест прогоняет миграции второй раз и проверяет, что данные на месте |
evidence/persistence.txt, evidence/gradle-tests.txt |
| Ключи, уникальность username | \d sessions и т.д.; UserControllerTest |
PK, FK ON DELETE CASCADE, users_username_key, повторный username — 409 |
src/main/resources/migrations/V1__init.sql, evidence/storage.txt |
| Данные и сессии переживают рестарт API и хранилищ | make test-persistence ACTION_SCRIPT=scripts/restart.sh |
PASS. У всех трёх контейнеров новый StartedAt (api, postgres и redis перезапущены), volume postgres-data тот же |
evidence/persistence.txt |
| Атомарное создание чата | ExposedChatRepositoryTest: второй участник не существует, вставка участников падает на FK |
исключение с SQLSTATE 23503, строки в chats и chat_members не остались |
src/test/.../repositories/chat/ExposedChatRepositoryTest.kt |
| Пароли через KDF | смотрел users.password_hash |
все хеши $argon2id$v=19$m=19456,t=2,p=1$...; тест: пароли, отличающиеся после 72-го байта, различаются |
evidence/storage.txt, DefaultHashingServiceTest |
| Basic только на создании сессии, Bearer на остальном | curl на живом стенде; UserControllerTest, AuthenticationControllerTest |
Basic на /users/me — 401, Bearer на POST /auth/sessions — 401, без токена — 401 с WWW-Authenticate: Bearer realm="messenger" |
evidence/failures.txt |
X-User-Id не даёт доступ |
curl с одним X-User-Id; тесты X-User-Id alone gives no access, X-User-Id does not override bearer identity |
401; при Bearer + чужой X-User-Id отвечает владелец токена |
evidence/failures.txt |
| Opaque-токен ≥ 256 бит, в базе только хеш | код DefaultAuthenticationService, \d sessions |
32 байта из SecureRandom, token_hash длиной 64 (hex SHA-256), самого токена в базе нет |
evidence/storage.txt |
| Logout | curl; logout revokes only the current token |
204, тот же токен потом 401, вторая сессия того же пользователя работает | evidence/failures.txt |
| Expiry при коротком TTL | SESSION_TTL_SECONDS=5, ждал 6 с; тест session expires after SESSION_TTL_SECONDS (TTL 2 с) |
сразу после входа 200, через 6 с 401 | evidence/failures.txt |
| Неверный пароль | curl; тест wrong password and unknown user get the same 401 |
401, ответ одинаковый для неверного пароля и несуществующего пользователя | evidence/failures.txt |
| Secrets и volumes не в Git | git check-ignore, git ls-files secrets |
secrets/ в .gitignore, отслеживаемых файлов 0, данные только в docker volume |
evidence/storage.txt |
| Redis реально используется | curl + redis-cli на живом стенде; SessionCacheTest |
после первого запроса в Redis появляется session:<sha256> с TTL 60 с; после logout значение revoked с TTL ≈ 3600 с |
evidence/failures.txt |
| Источник истины, expiry и инвалидация кэша | SessionCacheTest, RedisSessionCacheRepositoryTest |
после FLUSHALL живая сессия работает, отозванная остаётся отозванной; запоздавшее заполнение кэша не перетирает метку revoked |
evidence/gradle-tests.txt |
| Параметризованные запросы, ограниченный пул, таймауты | код plugins/Database.kt, RedisConnection.kt |
Exposed DSL; пул ≤ 10, ожидание 2 с, statement_timeout 5 с; Redis 500 мс |
src/main/kotlin/com/mtusi/messenger/main/plugins/Database.kt |
| Гонка регистрации одного username | concurrent registrations of one username create exactly one user: 10 параллельных запросов |
ровно один 201 и девять 409 | evidence/gradle-tests.txt |
| Rollback составной операции | chat row is rolled back when inserting members fails |
см. строку про атомарность выше | evidence/gradle-tests.txt |
| Индекс истории и EXPLAIN на ≥ 10 000 сообщений | ./scripts/explain-history.sh |
70 000 сообщений, глубокая страница по курсору: Index Scan, 4 буфера, 0,03 мс. Без индекса: Seq Scan, 914 буферов. Разбор ниже | evidence/explain-history.txt |
| Недоступность Redis | docker compose stop redis; DependencyFailureTest (отказ соединения и docker pause) |
запросы с токеном 200, вход 201, logout 204 и токен сразу 401, анонимный запрос 401; при зависшем Redis запрос дольше максимум на один таймаут | evidence/failures.txt, evidence/gradle-tests.txt |
| Logout при недоступном Redis, потом рестарт API | DependencyFailureTest: logout during a Redis outage is not undone by a stale cached copy, ... survives an API restart; то же на живом стенде (docker compose pause redis, logout, unpause, вернул в ключ старую копию сессии, restart api) |
logout 204; после восстановления Redis и после рестарта API тот же токен 401 на чтение и на отправку сообщения, в ключе снова revoked, в логе Wrote 1 pending session revocations to the cache. Без исправления оба теста падали: токен получал 200 |
evidence/lost-tombstone.txt, evidence/gradle-tests.txt |
| Недоступность БД | docker compose stop postgres; DependencyFailureTest |
/health/live 200, /health/ready 503, запросы с токеном и вход — 503 unavailable примерно за 2 с, без токена и с X-User-Id — 401. После старта базы тот же токен снова 200 |
evidence/failures.txt |
| Свои автотесты | ./gradlew test |
58 тестов, все проходят | evidence/gradle-tests.txt |
| Трек 1: cache stampede на конкурентном сценарии | ./scripts/track1/stampede.sh с VARIANT=off, 200 VU, FLUSHALL раз в секунду |
на каждую сессию за один сброс кэша в базу уходит 3,1 SELECT при 50 сессиях и 10,5 при 10 сессиях; запросов к sessions 4 651 и 3 138 за 30 с |
evidence/track1/summary.md, evidence/track1/stampede/off/ |
| Трек 1: защита и измерение до/после | то же с VARIANT=on (single-flight) |
0,97 SELECT на сессию за сброс в обоих случаях: запросов к sessions в 3,2 и 10,8 раза меньше. RPS и p50/p95/p99 в пределах шума |
evidence/track1/summary.md, evidence/track1/stampede-runs.csv |
| Трек 1: read-after-write из контракта | ./scripts/track1/read-after-write.sh: 300 итераций, 16 параллельных читателей, logout посреди первого заполнения кэша; с защитой и без, Redis работает и остановлен |
1 200 итераций, 1,53 млн запросов, начатых после ответа 204 на logout: ни одного 200. Первый запрос после входа всегда 200. Через секунду ни один отозванный токен не ожил | evidence/track1/read-after-write/ |
| Трек 1: восстановление после рестарта кэша | ./scripts/track1/redis-restart.sh: docker compose restart redis на 10-й секунде замера под 200 VU, 5 повторов на вариант |
0 ответов не 200 за 10 рестартов, кэш недоступен ~0,7 с по логу API, p99 в секунду рестарта ~71–76 мс против ~36 мс до. Первая версия кода на этом сценарии отдавала один 500 на рестарт, разбор ниже | evidence/track1/redis-restart/ |
| Трек 1: тесты single-flight | SessionLookupSingleFlightTest |
50 одновременных промахов: 50 запросов в базу без защиты и 1 с защитой; запрос, пришедший после logout, не присоединяется к поиску, начатому до него | evidence/gradle-tests.txt |
Эксперименты и отказы
План запроса истории
scripts/explain-history.sh в одной транзакции заливает в стенд 70 000 сообщений: один большой чат на 20 000 и 50 соседних чатов по 1 000, потом делает ANALYZE, снимает EXPLAIN (ANALYZE, BUFFERS) и откатывает транзакцию, так что реальные данные не меняются. Соседние чаты нужны, чтобы планировщику было что пропускать, иначе таблица состояла бы из одного чата. Запросы те же, что строит Exposed в ExposedMessageRepository.findPageByChatId. Стенд — ноутбук Apple M4, 10 ядер, 16 ГБ, PostgreSQL 17.6 в Docker, данные целиком в shared buffers.
| Запрос | План | Buffers | Время выполнения |
|---|---|---|---|
Первая страница, LIMIT 51 |
Index Scan по messages_chat_id_created_at_id_idx, условие chat_id |
4 | 0,02 мс |
Страница после 15 000-го сообщения, курсор (created_at, id) > (?, ?) |
тот же Index Scan, условие на курсор тоже внутри индекса | 4 | 0,03 мс |
Та же страница через OFFSET 15000 (для сравнения, API так не делает) |
Index Scan, прочитано 15 051 строка, отдано 51 | 296 | 1,0 мс |
Курсор, но индексы запрещены (enable_indexscan = off и т.д.) |
Seq Scan всей таблицы, отброшено 65 003 строки, затем top-N sort | 914 | 2,1 мс |
Главное здесь не миллисекунды (на 70 000 строк всё и так быстро), а то, как растёт работа. С курсором страница всегда стоит 4 буфера, хоть первая, хоть пятнадцатитысячная. С offset стоимость растёт с номером страницы, без индекса — с размером всей таблицы, включая чужие чаты. Сортировки в плане с индексом нет: строки идут из индекса уже в нужном порядке, и LIMIT останавливает чтение на 51-й.
Индекс именно (chat_id, created_at, id): первым столбцом равенство по чату, дальше ровно порядок сортировки, и id в конце нужен, чтобы курсор был однозначным, когда у двух сообщений совпадает created_at.
Отказы
Всё проверял на живом стенде, вывод в evidence/failures.txt и evidence/persistence.txt. Те же сценарии есть в автотестах (DependencyFailureTest).
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|---|---|---|---|
scripts/restart.sh: stop api, redis, postgres, затем up --wait |
данные и сессии на месте, тот же токен работает | make test-persistence PASS, у всех трёх контейнеров новый StartedAt, Redis поднялся пустым и заполнился заново |
API стартовал через 5 с после PostgreSQL и Redis (ждал их healthcheck), весь hook занял несколько секунд; потерь нет |
docker compose stop redis |
работаем без кэша, анонимов не пускаем | /me с токеном 200 за 7 мс, вход 201, logout 204 и токен сразу 401, без токена 401, /health/ready 200. В логе предупреждение Session cache is unavailable |
после start redis кэш используется снова сам, без рестарта API; потерь нет |
Redis завис (docker pause в тесте) |
запрос замедляется не больше чем на таймаут команды | /me 200 менее чем за 2 с (таймауты 500 мс на чтение и на запись в кэш), logout 204; после unpause отозванная сессия не вернулась, кэш снова работает |
сразу после unpause; потерь нет |
docker compose stop postgres |
ограниченная ошибка, анонимов не пускаем | /health/live 200, /health/ready 503 сразу, /me с токеном и вход 503 unavailable за 2,0 с (таймаут пула), без токена и с X-User-Id 401, неизвестный токен 503 |
после start postgres тот же токен 200 без рестарта API; подтверждённые данные не теряются, неподтверждённые запросы клиент должен повторить |
SESSION_TTL_SECONDS=5 |
сессия истекает | 200 сразу после входа, 401 через 6 с | — |
Трек 1. Согласованность кэша
Кэш у меня один — сессии в Redis, и через него проходит каждый запрос с Bearer-токеном. Поэтому смотрел на две вещи: что происходит с базой, когда ключи пропадают все разом (cache stampede), и не ломает ли кэш гарантии контракта про logout.
Гипотеза. Когда кэш сессий сбрасывается (истёк TTL, FLUSHALL, рестарт Redis), все запросы, которые в этот момент летят с одним токеном, одновременно промахиваются и каждый идёт в PostgreSQL за одной и той же строкой sessions. Ожидал, что лишних SELECT будет примерно столько, сколько параллельных запросов на один токен, и что single-flight (один поиск на токен, остальные ждут его результат) срежет их до одного на сессию. Про latency заранее не был уверен: поиск сессии — это запрос по уникальному индексу, он дешёвый.
Как мерил
Стенд — тот же ноутбук: Apple M4 (10 ядер), 16 ГБ, macOS 27. Docker Desktop, виртуалке выделено 10 CPU и 8 ГБ, лимитов на контейнеры нет. Образы и конфиг те же, что в compose.yaml: пул PostgreSQL 10 соединений, таймаут Redis 500 мс, TTL копии сессии в кэше 60 с. k6 2.3 на той же машине. Варианты «до» и «после» — это один и тот же образ, разница только в SESSION_CACHE_SINGLE_FLIGHT=false/true, и перед каждым прогоном API пересоздаётся (--force-recreate), чтобы не тянуть состояние JVM из прошлого прогона.
Что считал:
- SQL — через
pg_stat_statements(включил вcompose.yaml). Счётчики сбрасываются на границе прогрева и замера, потом берётся число вызовов SELECT поsessionsи всех запросов вообще. - Промахи и попадания Redis —
INFO stats(keyspace_misses,keyspace_hits), тоже со сбросом перед замером. - Latency и RPS — k6, только фаза замера. Прогрев и замер — один сценарий k6, иначе на старте замера k6 заново открывает 200 соединений через проброс порта Docker Desktop и часть из них рвётся (это то же, что я видел в lab1).
Все прогоны запускает scripts/track1/run-all.sh. Повторы идут по кругу: сначала все комбинации по разу, потом второй круг, потом третий. Сводка — evidence/track1/summary.md, сырые данные по каждому прогону — в evidence/track1/<эксперимент>/<вариант>/.... Токены живут только во временном файле с правами 600, который удаляется после прогона.
Эксперимент 1. Stampede при массовом сбросе кэша
scripts/track1/stampede.sh. Перед прогоном создаётся N пользователей с одной сессией у каждого. Дальше 200 VU без пауз дёргают GET /api/v1/users/me, каждый VU всегда со своим токеном из N, то есть на одну сессию одновременно приходится 200/N запросов. 5 с прогрев, 30 с замер. Во время замера внутри контейнера Redis раз в секунду выполняется FLUSHALL, это имитирует одновременное истечение всех ключей или рестарт кэша. N = 50 (по 4 запроса на сессию, как у клиента, который параллельно грузит несколько экранов) и N = 10 (по 20, например общий служебный токен). Плюс контрольный прогон без сбросов. По 3 повтора, медиана, в скобках минимум и максимум:
| Сессий | Single-flight | Запросов к sessions за 30 с |
На сессию за один сброс | Промахов Redis | Всего SQL | RPS | p50 / p95 / p99, мс | max, мс |
|---|---|---|---|---|---|---|---|---|
| 50 | нет | 4 651 (4 622–4 689) | 3,10 | 4 651 | 492 085 | 16 270 | 11,2 / 22,9 / 31,6 | 86 |
| 50 | да | 1 451 (1 450–1 451) | 0,97 | 4 653 | 483 729 | 16 106 | 11,5 / 22,6 / 29,9 | 84 |
| 10 | нет | 3 138 (2 893–3 500) | 10,46 | 3 138 | 474 008 | 15 719 | 11,7 / 23,4 / 32,0 | 84 |
| 10 | да | 291 (291–292) | 0,97 | 4 037 | 470 144 | 15 719 | 11,8 / 23,1 / 31,6 | 87 |
| 50, без сбросов | нет / да | 0 / 0 | — | 0 / 0 | 477 952 / 486 664 | 15 966 / 16 251 | 11,5 / 23,3 / 32,1 и 11,4 / 22,4 / 30,6 | 86 / 88 |
Ошибок не было ни в одном прогоне.
Без защиты stampede виден напрямую: на каждый сброс в базу уходит ~3 SELECT на сессию при 4 параллельных запросах и ~10,5 при 20. Это почти ровно число запросов, которые в момент сброса были в полёте с этим токеном. Промахов Redis ровно столько же, сколько SELECT: каждый промах — свой запрос в базу.
С single-flight на сессию за сброс уходит 0,97 SELECT в обоих случаях, разброс между повторами меньше 0,1 %. Не ровно 1, потому что делю на 30 сбросов, а последний FLUSHALL пришёлся на самый конец замера, когда k6 уже остановился: фактически сработало 29 сбросов, и 29 × 50 = 1 450, 29 × 10 = 290 — ровно по одному SELECT на сессию за сброс (плюс один запрос на границе замера). Промахов Redis при этом даже больше, чем без защиты (4 037 против 3 138 при 10 сессиях), но это ожидаемо: промахиваются все, кто пришёл до записи в кэш, просто в базу идёт только один из них. Итого запросов к sessions меньше в 3,2 раза при 50 сессиях и в 10,8 раза при 10.
А вот на latency и RPS защита не повлияла: все различия в пределах разброса между повторами, и контрольный прогон без сбросов кэша даёт те же цифры. Причина видна в top-queries.txt: за 30 секунд 4 689 поисков сессии заняли в PostgreSQL 77 мс суммарно (~0,02 мс на запрос), а 487 009 поисков пользователя для ответа /me — 7 930 мс. Stampede на сессиях — это меньше 1 % работы базы в этом сценарии, и пул на 10 соединений он не забивает. То есть гипотеза про число запросов подтвердилась полностью, а ускорения ответа нет, и я его не заявляю. Выигрыш от защиты вырастет там, где сброс кэша совпадает с тяжёлой базой: много сессий на одном токене, медленный диск, пул, уже занятый другими запросами. Это я не мерил.
Эксперимент 2. Рестарт Redis под нагрузкой
scripts/track1/redis-restart.sh. Та же нагрузка (200 VU, 50 сессий), но вместо FLUSHALL на 10-й секунде замера docker compose restart redis. Раз в секунду скрипт снимает счётчик поисков сессии из pg_stat_statements и попадания Redis, k6 пишет каждый запрос в CSV, из которого потом считаются RPS и задержки по секундам (per-second.csv). Время недоступности кэша — по двум строкам лога API: «Session cache is unavailable» и «available again». 5 повторов на вариант:
| Single-flight | restart redis, с |
Кэш недоступен по логу API, с | Запросов к sessions за прогон |
p99 до рестарта, мс | p99 в секунду рестарта, мс | max в секунду рестарта, мс | Не 200 |
|---|---|---|---|---|---|---|---|
| нет | 0,52 (0,48–0,59) | 0,71 (0,65–0,83) | 5 625 (4 700–6 284) | 36 | 76 (68–163) | 133 (112–225) | 0 |
| да | 0,51 (0,47–0,57) | 0,73 (0,70–0,75) | 3 490 (3 106–3 805) | 37 | 71 (70–89) | 138 (129–153) | 0 |
Пример одного прогона (повтор 3, без single-flight), секунды вокруг рестарта:
| Секунда замера | Запросов | p50, мс | p99, мс | max, мс |
|---|---|---|---|---|
| 9 | 13 687 | 13,2 | 38,3 | 58 |
| 10 (рестарт в 10,08) | 9 334 | 17,7 | 77,4 | 162 |
| 11 | 12 568 | 14,1 | 40,1 | 74 |
| 12 | 13 968 | 13,0 | 34,8 | 53 |
Пока Redis лежит, каждый запрос идёт в PostgreSQL, ошибок нет, только хвост задержек в эту секунду вырастает примерно вдвое. После старта Redis Lettuce переподключается сам, без рестарта API, и уже в следующую секунду p99 возвращается к обычному. Кэш при этом пустой (persistence выключен), заполняется заново из базы при первых запросах. Single-flight во время такого отказа помогает меньше, чем при FLUSHALL (в 1,6 раза меньше SELECT, а не в 3): пока Redis недоступен, промахи идут непрерывным потоком, а не одной пачкой, и запросы с одним токеном реже совпадают по времени с уже идущим поиском.
Что нашёл этим экспериментом. В первом прогоне матрицы (до исправления) в 4 рестартах из 6 ровно один запрос получал 500. В логе API было Unhandled error: java.net.SocketException: Connection reset. Lettuce на команду, которая уже ушла в сокет в момент закрытия соединения, отдаёт не RedisException, а голый IOException. Мой обработчик ловил только RedisException, и этот запрос проваливался в общий 500. Исправил: IOException из кэша теперь тоже значит «кэш недоступен», запрос идёт в базу. После исправления матрица перезапущена целиком, и за 10 рестартов не было ни одного ответа не 200. Тесты из уровня 4 (docker pause, закрытый порт) этот случай не ловили, потому что в них соединение не рвётся посреди команды.
Ещё одна мелочь из того же эксперимента: до этого API писал предупреждение на каждый запрос, который не смог сходить в Redis, — за 0,5 с рестарта это 5 397 строк. Теперь логируется только смена состояния, по этим двум строкам и меряется время недоступности. Иногда в момент переподключения бывает лишний «скачок» unavailable → available за 10 мс (видно в on/t50_r3/cache-availability.log): команда, отправленная в старое соединение, падает уже после того, как новое установилось.
Эксперимент 3. Read-after-write для входа и выхода
В контракте две гарантии, которые кэш может сломать: после 201 на вход токен сразу работает, а после 204 на DELETE /auth/sessions/current тот же токен должен получать 401. Самое опасное место — гонка заполнения кэша с logout: запрос прочитал сессию из базы до удаления, а в Redis записал уже после. Без NX и метки revoked такая копия жила бы до 60 секунд.
scripts/track1/read-after-write.sh. 300 итераций, в каждой:
- вход и сразу
GET /me— должен быть 200 (кэш не хранит «токена нет», так что новый токен виден сразу); - второй вход, чтобы начать с холодного ключа;
- 16 потоков без пауз читают
/meс этим токеном, и через случайные 0–20 мс выполняется logout — то есть ровно в момент, когда первые запросы заполняют кэш; - потоки читают ещё 100 мс; нарушением считается любой 200 на запрос, начатый после того, как клиент получил 204;
- в конце, через секунду после последнего logout, каждый отозванный токен проверяется ещё раз.
Четыре комбинации: с защитой от stampede и без, Redis работает и остановлен.
| Single-flight | Redis | Первый запрос после входа не 200 | Запросов до ответа logout | Запросов после ответа logout | Из них 200 | Токен жив через 1 с |
|---|---|---|---|---|---|---|
| нет | работает | 0 из 300 | 42 545 | 396 511 | 0 | 0 из 300 |
| да | работает | 0 из 300 | 42 692 | 405 818 | 0 | 0 из 300 |
| нет | остановлен | 0 из 300 | 43 034 | 362 801 | 0 | 0 из 300 |
| да | остановлен | 0 из 300 | 42 973 | 361 654 | 0 | 0 из 300 |
Ни одного нарушения на 1,53 млн запросов после logout. Других кодов, кроме 200 и 401, не было.
Здесь честно скажу про силу доказательства: этот эксперимент показывает, что нарушения не случаются на практике, но он не доказывает, что гонка в нём действительно возникала (окно между чтением из базы и записью в кэш — доли миллисекунды). Само опасное чередование проверено детерминированно в тестах: late cache fill cannot overwrite a tombstone (метка, потом запоздавшая запись — остаётся метка) и request arriving after logout does not join a lookup started before it (single-flight не раздаёт результат поиска, начатого до logout, запросам после него). Отдельно single-flight не должен был ухудшить read-after-write: результат поиска отдаётся ведомым сразу после SELECT, а logout выкидывает незавершённый поиск своего токена из таблицы, поэтому запрос, пришедший после 204, всегда делает свой поиск.
Восстановление после рестарта кэша
Redis у меня без persistence, поэтому после рестарта он пустой, и восстановление — это просто повторное заполнение из PostgreSQL:
make test-persistence ACTION_SCRIPT=scripts/restart.shперезапускает api, postgres и redis — тот же токен читает те же данные (уровень 3);SessionCacheTest.emptied cache falls back to PostgreSQL: послеFLUSHALLживая сессия работает и снова попадает в кэш, а отозванная остаётся отозванной (её нет в базе);- эксперимент 2: под нагрузкой 200 VU рестарт Redis проходит без ошибок, через ~0,7 с API снова пользуется кэшем.
Единственное, что теряется при рестарте Redis, — метки revoked. Это не страшно, потому что logout сначала удаляет сессию из PostgreSQL, и без метки поиск всё равно вернёт «нет сессии».
Что может искажать результаты
- k6, API, PostgreSQL и Redis на одном ноутбуке и делят CPU. Повторы одной комбинации отличаются по RPS на 1–5 %.
FLUSHALLраз в секунду — это искусственно частый сброс. В обычной работе ключи истекают по одному (TTL 60 с от первого промаха), и stampede по сессии случается раз в минуту, а не раз в секунду.- Сценарий — только
GET /me. В нём на запрос приходится ровно один дополнительный SELECT пользователя, на других endpoint пропорции другие. - Single-flight работает внутри одного процесса API. Сейчас процесс один, а с несколькими репликами (lab3) каждая будет делать свой поиск, то есть до одного SELECT на сессию на реплику. Для общего на все реплики нужна блокировка в Redis, но при недоступном Redis она бы не работала, а в базу всё равно ходить надо.
- Время недоступности кэша по логу API — это от первой неудачной команды до первой удачной. Оно немного больше, чем
docker compose restart(0,7 против 0,5 с), потому что включает переподключение Lettuce.
Ограничения и следующие шаги
- Недоверие к кэшу после сбоя Redis живёт внутри процесса. С несколькими репликами API (lab3) реплика, которая сама не видела ошибку Redis, может прочитать старую копию отозванной сессии, пока метку не допишет другая реплика (обычно на первом же её запросе) или пока не истечёт TTL копии (до 60 с). Для реплик нужен общий признак, например номер поколения кэша в PostgreSQL.
- Неизвестный токен при лежащей базе получает 503, а не 401. Проверить его без базы нельзя, а пустить нельзя, так что это осознанно.
- PostgreSQL один, без реплик и бэкапов. Если пропадёт volume, пропадут данные. Durability — стандартная для PostgreSQL (
fsync,synchronous_commitпо умолчанию включены): после ответа 201 запись уже в WAL на диске. - Просроченные сессии из таблицы
sessionsне удаляются, они только перестают проходить проверку. Нужна периодическая чистка, сейчас её нет. - Список чатов пагинируется по
(chats.created_at, chats.id)через join сchat_members. Для пользователя с огромным числом чатов это будет сортировка всех его чатов. Для учебных объёмов нормально, EXPLAIN для этого запроса я не снимал. - Защита от stampede в треке 1 уменьшила число запросов к
sessionsв 3–11 раз, но ускорения ответа в моём сценарии не дала, и я его не заявляю. Где она начнёт влиять на latency (тяжёлая база, занятый пул, много запросов на один токен), не проверял. - Single-flight работает в пределах одного процесса API. С несколькими репликами каждая сделает свой поиск. Общая блокировка в Redis тут плохо подходит: она нужна как раз тогда, когда Redis может быть недоступен.
- Swarm не использую, только Compose. Сеть между контейнерами без TLS, это тема следующих лабораторных.