Files
mtusi2026lab2/solve.md
T
2026-11-07 11:56:38 +03:00

23 KiB
Raw Blame History

Что происходит в лабораторной 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 Алисы, является Алисой. Это учебный ярлык, не аутентификация.

Новая модель:

  1. Регистрация принимает password. В таблицу попадает не пароль, а Argon2id.
  2. Вход — только POST /api/v1/auth/sessions с Authorization: Basic. Basic здесь кодирование username:password в Base64, не шифрование. По HTTP на учебной машине это допустимо; на удалённой демонстрации нужен TLS (это lab7).
  3. Ответ — opaque Bearer (≥256 бит случайности). Это не JWT и не username: сервер не парсит токен как утверждение, а смотрит запись сессии.
  4. Остальные защищённые пути принимают только 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: от «процесс умеет контракт» к «состояние и личность существуют отдельно от процесса и переживают его смерть».