# Что происходит в лабораторной 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. Запрос страницы: ```sql 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:`. Утечка дампа 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:`. Ключ страницы включает версию. После 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:` в 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: от «процесс умеет контракт» к «состояние и личность существуют отдельно от процесса и переживают его смерть».