forked from mtusi2026/mtusi2026lab2
197 lines
23 KiB
Markdown
197 lines
23 KiB
Markdown
# Что происходит в лабораторной 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:<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: от «процесс умеет контракт» к «состояние и личность существуют отдельно от процесса и переживают его смерть».
|