23 KiB
Что происходит в лабораторной 2
Lab1 доказала, что контракт можно реализовать процессом в контейнере. Состояние жило в RAM и исчезало вместе с процессом. Lab2 решает другую задачу: подтверждённые данные и ещё действующая сессия должны пережить рестарт, а клиент должен быть аутентифицированным пользователем, а не строкой X-User-Id, которую любой может подставить.
Целевая оценка этой работы — 5, трек согласованность кэша. Ниже — не перечень файлов, а причины решений.
1. Зачем вообще уходить из памяти
In-memory store в lab1 был правильным минимумом: нет внешних зависимостей, легко гонять smoke. Он ломается в тот момент, когда появляется требование «после docker compose restart токен и сообщения на месте».
Память процесса не является хранилищем:
- SIGTERM / OOM /
restartобнуляют словари; - второй экземпляр API (это уже lab3) не увидит тех же пользователей;
- нельзя честно говорить про транзакции и индексы.
Поэтому источник истины для пользователей, чатов, членства и сообщений — PostgreSQL. API становится тонким слоем: проверить контракт, открыть транзакцию, отдать JSON. Если Postgres недоступен, бизнес-путь нельзя обслуживать «из кэша как из правды»: кэш может быть неполным или устаревшим.
SQLite сознательно не используется: стенд должен совпадать с тем, что будет масштабироваться дальше (сеть, пул, WAL, volume).
2. Схема: ограничения в БД, а не только в Python
Проверки в app/validation.py отсекают мусор на границе HTTP. Этого мало. Два клиента могут одновременно пройти проверку «username свободен» и оба сделать INSERT. Поэтому уникальность username — UNIQUE INDEX в Postgres. Гонка даёт UniqueViolation → один 201, остальные 409. Это не «оптимизация», а единственный способ получить корректность без распределённой блокировки на уровне приложения.
Чат создаётся атомарно: строка chats и все строки chat_members в одной транзакции. Если среди member_ids есть несуществующий UUID, транзакция откатывается. Иначе получился бы «чат-сирота» без полного списка участников — объект, которого контракт не описывает и который нельзя честно отдать в GET /chats.
Внешние ключи (chat_members.user_id → users, messages.chat_id → chats) держат инвариант даже если код ошибётся. ON DELETE CASCADE здесь учебный: обязательный API удаления не даёт, но схема не оставляет висящих членов при ручной чистке стенда.
Порядок истории задан контрактом: (created_at, id) по возрастанию, keyset-cursor, limit 1–100. Запрос страницы:
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
ORDER BY created_at, id
LIMIT n
Индекс messages (chat_id, created_at, id) построен под этот предикат, а не «на всякий случай по chat_id». Без него Postgres читает и сортирует всю историю чата (seq scan). На 10 000 сообщений это видно в EXPLAIN (ANALYZE, BUFFERS): Index Scan ~0.06 ms против Seq Scan ~2 ms. Пагинация не должна каждый раз сканировать всю таблицу — иначе стоимость чтения растёт линейно с возрастом чата, а cursor теряет смысл.
Почему не OFFSET? OFFSET 10000 всё равно просматривает 10 000 строк и отбрасывает их. Keyset опирается на уже известную точку (created_at, id) и идёт дальше по индексу.
Cursor непрозрачный (base64 JSON + привязка к chat_id). Клиент не должен листать чужой чат, подставив cursor от другого. Это не криптография, а привязка курсора к ресурсу, как требует контракт.
3. Почему сессия, а не X-User-Id
В lab1 любой, кто знает UUID Алисы, является Алисой. Это учебный ярлык, не аутентификация.
Новая модель:
- Регистрация принимает
password. В таблицу попадает не пароль, а Argon2id. - Вход — только
POST /api/v1/auth/sessionsсAuthorization: Basic. Basic здесь кодированиеusername:passwordв Base64, не шифрование. По HTTP на учебной машине это допустимо; на удалённой демонстрации нужен TLS (это lab7). - Ответ — opaque Bearer (≥256 бит случайности). Это не JWT и не username: сервер не парсит токен как утверждение, а смотрит запись сессии.
- Остальные защищённые пути принимают только Bearer. Basic на
/users/me— 401.X-User-Idигнорируется: иначе старый клиент lab1 обошёл бы новую модель.
Logout удаляет ключ сессии. Повтор с тем же токеном — 401. TTL задаётся SESSION_TTL_SECONDS; рестарт не продлевает жизнь сессии.
Токен в Redis хранится не как есть, а как sess:<sha256(token)>. Утечка дампа Redis не даёт сразу валидный Bearer (нужен прообраз). Это не замена TLS, но снижает ущерб от бэкапа volume.
Если Redis недоступен в момент проверки Bearer, ответ 503, не «ну нет сессии, пустим как анонима» и не 401 «неверный пароль». 401 означает «идентификация не принята». 503 означает «мы не можем её проверить». Путать их опасно: клиент при 401 выкинет токен, при 503 — повторит.
4. Почему сессии в Redis, а не в Postgres
Контракт разрешает оба варианта. Выбран Redis, потому что у сессии другая природа, чем у сообщения:
- сессия — горячий ключ с TTL, частые GET на каждый запрос;
- сообщение — факт, который должен пережить годы и участвовать в JOIN/EXPLAIN;
- logout и expiry — естественный
DEL/ TTL ключа, без cron по таблицеsessions.
Проблема: один TTL в памяти Redis не переживает рестарт. Persistence-тест держит токен в памяти Python-процесса и перезапускает API и хранилища, volumes не трогая. Если сессии только в RAM Redis, после restart токен внезапно 401 — тест красный, хотя Postgres цел.
Поэтому Redis запущен с AOF (appendonly yes, appendfsync everysec) и дополнительным RDB save 60 1. AOF после рестарта восстанавливает ключи вместе с оставшимся TTL. everysec — компромисс: можно потерять до ~1 с записей при crash процесса Redis, зато не платить fsync на каждый SET. Для учебных сессий это честная граница durability, её нужно называть на защите.
Кэш истории живёт в том же Redis, но это не источник истины. Потеря кэша допустима: страница перечитывается из Postgres. Потеря сессий без AOF — уже нарушение контракта «действующая сессия переживает рестарт».
5. Кэш истории и трек 5: какую ошибку мы чиним
Контракт: после успешного POST сообщения следующее чтение через любую реплику должно его видеть. Кэш имеет право существовать, но не имеет права отдать страницу старше успешной записи.
Наивный кэш GET → Redis → иначе SQL → SET ломается двумя способами.
Stale read. Страница уже в Redis. POST пишет в Postgres и не трогает кэш. GET отдаёт старый items без нового сообщения. В эксперименте это воспроизводится флагом invalidate=false: так мы показываем баг, а не оставляем его в проде. Защита — версия histver:<chat_id>. Ключ страницы включает версию. После INSERT делается INCR histver. Старые ключи просто перестают попадать в lookup (и истекают по TTL). Не нужно SCAN/DEL всех страниц чата.
Cache stampede. Истёк TTL или сменилась версия. 24 клиента одновременно делают miss. Без координации — 24 одинаковых SELECT. На горячем чате это бьёт в Postgres в тот момент, когда кэш как раз должен был его разгрузить.
Singleflight: первый waiter запускает load, остальные ждут тот же asyncio.Task и получают тот же результат. Измерение: 24 SQL → 1 SQL при 24 конкурентных GET. Задержка 250 ms на load в lab-режиме нужна, чтобы HTTP-клиенты успели попасть в одно окно miss; без неё на localhost первый GET заполняет кэш раньше остальных, и stampede «не виден», хотя код всё ещё гоночный.
Это in-process защита. Одна реплика lab2 — ок. На lab3 с двумя API понадобится lock в Redis (SET NX), иначе каждая реплика выполнит свой SQL.
6. Инфраструктура: почему Compose и named volumes
Skeleton даёт пустой compose.example.yaml — это список ролей, не стенд. Свой compose.yaml фиксирует:
- версии образов, не
latest; - сеть только внутри compose: Postgres и Redis не публикуются на хост (API слушает
127.0.0.1:8080); - volumes
pg_data/redis_data— данные переживают recreate контейнера; - healthcheck: API не стартует, пока Postgres/Redis не
healthy;/health/readyтребует оба ping.
scripts/restart.sh (на Windows — restart.bat) делает docker compose restart postgres redis api без -v. Persistence-тест не умеет отличить честный рестарт от no-op, поэтому в отчёте лежат compose ps до и после.
Пул соединений ограничен (1–10) и с таймаутами: без этого при зависании Postgres запросы копятся бесконечно, а при всплеске легко исчерпать max_connections.
Пароль — Argon2id, не SHA-256: SHA быстрый специально, его можно перебирать миллиардами попыток в секунду. Argon2 специально медленный и память-затратный. Параметры в этой работе учебные (memory_cost=8192), чтобы гонка 16 регистраций не убила контейнер на 512 MiB. В lab7 ждут более жёсткий Argon2id.
7. Ошибки зависимостей
| Ситуация | Код | Почему так |
|---|---|---|
| Процесс жив, зависимости не важны | /health/live 200 |
оркестратор не должен убивать процесс из-за рестарта Redis |
| Postgres или Redis не отвечают | /health/ready 503 |
нельзя обещать безопасный синхронный путь |
| Bearer, Redis лежит | 503 | нельзя ни принять, ни отвергнуть сессию |
| Неверный пароль / нет токена | 401 + WWW-Authenticate |
идентификация не удалась, сервис здоров |
| Чат чужой или не существует | 404 | 403 раскрыл бы факт существования чата |
| Username занят | 409 | конфликт уникальности, не «неверный запрос» |
Сообщения ошибок не содержат SQL и stack trace.
Вопросы на защите (из README)
Что подтверждает COMMIT и какие гарантии зависят от настройки durability?
COMMIT в PostgreSQL означает: транзакция завершена, изменения видны другим сессиям (с оговорками про уровень изоляции) и записаны в WAL. Это не магия «данные на диск навсегда».
Что именно гарантировано, зависит от synchronous_commit и fsync:
- по умолчанию
synchronous_commit=on: клиент получает успех после сброса WAL на диск (на практике — в page cache ОС + политика fsync Postgres). После краша процесса Postgres транзакция, на которую API уже ответил 201, должна найтись после recovery. synchronous_commit=off: COMMIT возвращается раньше, можно потерять последние транзакции при crash — быстрее, слабее durability.- Один
COMMITчата покрывает и чат, и членов: либо оба факта, либо ни одного. Это как раз граница транзакции в нашей схеме.
Docker volume не равен репликации. COMMIT на одном диске ноутбука не спасает от down -v и от смерти диска. Persistence-тест доказывает другое: контейнеры можно убить и поднять, если volume на месте.
Для Redis «COMMIT» в том же смысле нет. Есть запись в AOF. appendfsync everysec подтверждает SET клиенту, не дожидаясь fsync каждого ключа: окно потери ≈ 1 с. Это сознательная более слабая модель, чем у Postgres, и поэтому сообщения не кладут только в Redis.
Где хранятся сессии и что будет после flush/restart Redis?
Сессия: ключ sess:<sha256(token)> в Redis, TTL = SESSION_TTL_SECONDS, payload {user_id, expires_at}. Пользователь, чат, текст сообщения — в Postgres.
- Штатный restart Redis с volume и AOF: ключи и оставшийся TTL поднимаются. Persistence-тест и
test_redis_restart_keeps_session_and_historyэто показывают. Кэш истории холодный, страницы читаются из Postgres, контракт read-after-write не ломается. FLUSHALL/ удаление volume Redis: все сессии исчезают. Прежний Bearer → 401. Сообщения в Postgres на месте, но клиент должен войти заново. Для обязательного сценария lab2 это уже провал, если Redis — единственное хранилище сессий и persistence не включён.- Истёк TTL: ключ удаляется самим Redis. Рестарт тут ни при чём и не должен оживлять сессию.
Итог: Redis для сессий допустим только вместе с persistence, которая переживает проверяемый рестарт. Один TTL — это политика истечения, не сохранность.
Чем аутентификация отличается от доступа к конкретному чату?
Два независимых решения, и контракт требует именно такого порядка: сначала «кто ты», потом «можно ли этот объект».
- Аутентификация: есть ли действительная сессия. Нет/истекла/отозвана/Redis не смогли проверить → 401 (или 503). На этом шаге чат ещё не смотрим.
X-User-Idне аутентификация. - Авторизация на ресурс: этот user_id есть в
chat_membersданногоchat_id? Нет → 404, не 403. 403 сказал бы клиенту: «чат существует, просто не твой». Для постороннего чат неотличим от несуществующего.
Практический пример: Ева с валидным Bearer читает чат Алисы и Боба. Она аутентифицирована (не 401), но не член → 404. Список GET /chats отдаёт только её чаты.
Создание чата: вызывающий обязан быть в member_ids. Это не «аутентификация», а правило состава объекта. Нарушение → 400 (некорректный список), не 401.
Почему hash пароля и быстрый checksum имеют разные задачи?
Разные угрозы и разные желаемые свойства функции.
Password KDF (Argon2id). Секрет, который человек помнит, короткий и угадываемый. Хеш лежит в БД. Если дамп утечёт, атакующий будет перебирать пароли. Нужна функция, которую дорого считать много раз: память, итерации, уникальная соль в каждом хеше. Быстрый SHA-256 здесь вреден: видеокарта перебирает миллиарды вариантов в секунду. Мы специально платим CPU на каждый login.
Checksum (SHA-256 файла, CRC, хеш токена в ключе Redis). Цель — обнаружить изменение или сделать короткий отпечаток, не спрятать секрет от перебора. Нужна скорость и детерминизм. Для вложений в lab4 SHA-256 исходного PNG сверяет, что download = upload. Для ключа сессии SHA-256(token) — это lookup-индекс, не KDF: токен уже 256 бит случайности, его не подбирают по словарю как qwerty123.
Путать их — типичная ошибка: «у нас пароли в SHA-256, как checksum файла». Checksum не задерживает атакующего. KDF не нужен, чтобы проверить целостность 10 MiB картинки.
Карта «проблема → решение»
| Проблема | Решение |
|---|---|
| Рестарт API стирает чаты | Postgres + named volume |
| Два клиента занимают один username | UNIQUE + обработка UniqueViolation |
| Чат без части участников | Одна транзакция на chat+members |
| Пагинация сканирует всю историю | Составной индекс и keyset (created_at, id) |
| Клиент выдаёт себя за другого UUID | Opaque Bearer, X-User-Id игнорируется |
| Пароль в открытом виде / быстрый хеш | Argon2id |
| Сессия умирает вместе с Redis RAM | AOF + volume |
| GET после POST отдаёт старую страницу | Инвалидация histver |
| Толпа miss бьёт в одну и ту же SQL | Singleflight |
| Redis/Postgres лежат, а API врёт что готов | /health/ready 503; Bearer не downgrade в анонима |
Это ровно переход lab1 → lab2: от «процесс умеет контракт» к «состояние и личность существуют отдельно от процесса и переживают его смерть».