Files
mtusi2026lab2/REPORT.md

39 KiB
Raw Permalink Blame History

Отчёт — лабораторная 2

  • Автор, группа: TODO: ФИО, группа
  • Целевая оценка; выбранный трек 5: 5, трек 2 «План запроса и восстановление»
  • Commit/PR: TODO после публикации
  • Использованные источники, библиотеки и помощь ИИ:
    • библиотеки: Starlette 1.7.0, uvicorn 0.54.0, psycopg 3.2.10 + psycopg_pool 3.2.6, redis-py 5.2.1; KDF — hashlib.scrypt (OpenSSL) из стандартной библиотеки Python;
    • документация: PostgreSQL (transactions, EXPLAIN, row comparison, pg_dump/pg_restore), Redis persistence и Lua scripting, RFC 7617, OWASP Password Storage Cheat Sheet (параметры scrypt);
    • ИИ: реализация, тесты, скрипты исследования и этот отчёт подготовлены с помощью ИИ-ассистента Claude (Anthropic). Чужой код из других решений не использовался.

Запуск из чистого clone

Prerequisites: Docker Engine 24+ с Compose v2, Python 3.9+ на хосте (для публичных и собственных тестов, только stdlib), make (Linux/macOS; для Windows — PowerShell-скрипты ниже). Свободны порты 127.0.0.1:8080 (API) и 127.0.0.1:8081 (экземпляр с коротким TTL).

Образы (закреплены тегами): python:3.13.5-slim-bookworm (база API), postgres:16.10-alpine, redis:7.4.2-alpine. API собирается из исходников этого репозитория (Dockerfile), зависимости закреплены в requirements.txt.

# 1. Локальные синтетические secrets и .env (значения не печатаются, существующие не перезаписываются)
./scripts/init-secrets.sh            # = make secrets; создаёт secrets/* и .env из .env.example

# 2. Сборка, миграции (применяются API при старте под advisory lock), ожидание healthcheck
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait          # = make up
curl -s localhost:8080/health/ready                           # {"status":"ok"}

# 3. Проверки
make check
make test                                                     # публичный smoke
make test-persistence ACTION_SCRIPT=scripts/restart.sh        # рестарт API+PostgreSQL+Redis с volumes
make up-ttl                                                   # api-ttl с SESSION_TTL_SECONDS=2 на :8081
make test-student          # test-api, test-expiry, test-cache-race, test-failures (останавливает redis/postgres!)
make research-track2       # трек 5.2: отдельная БД research + сервер postgres-restore (профиль research)
./scripts/collect-evidence.sh                                 # всё сразу, вывод в evidence/

# 4. Остановка
make down            # безопасно: контейнеры удаляются, volumes pgdata/pgrestore сохраняются
make destroy-data    # НАМЕРЕННОЕ удаление всех учебных данных (down -v), спрашивает подтверждение

Windows (PowerShell, без make и WSL). Нужны Docker Desktop (запущен) и Python 3.9+ с python.org. Из корня репозитория:

powershell -NoProfile -ExecutionPolicy Bypass -File scripts\init-secrets.ps1     # secrets\ и .env
docker compose --env-file .env --profile ttl up -d --build --wait
py -3 tests\smoke.py --base-url http://localhost:8080                           # публичный smoke
py -3 tests\resilience.py --mode persistence --action-script scripts\restart.cmd
# Всё сразу (up + все проверки + трек 5.2), вывод в evidence\:
powershell -NoProfile -ExecutionPolicy Bypass -File scripts\collect-evidence.ps1
docker compose --env-file .env --profile ttl --profile research down             # остановка, volumes сохраняются

scripts\restart.cmd — обёртка над scripts\restart.ps1 (тот же хук, что restart.sh): tests/resilience.py запускает хук напрямую, а .cmd Windows исполняет без shell. В Windows PowerShell 5.1 нет оператора && — команды выполняются по одной строке. Ключи collect-evidence.ps1: -SkipFailures (не останавливать redis/postgres), -SkipResearch.

Действия оператора: только шаг 1 (создать secrets). Миграции вручную запускать не нужно; повторно — docker compose --env-file .env exec api python -m messenger migrate (no-op, если всё применено). Пароль БД зафиксирован в volume при первой инициализации: не удаляйте secrets/ при живом volume pgdata.

Важно о доказательствах в evidence/. Решение разрабатывалось в среде, где Docker daemon работал, но Docker Hub/зеркала и PyPI были закрыты политикой сети. Поэтому evidence/* собраны на нативном стенде с теми же компонентами: PostgreSQL 16.15, Redis 7.0.15, тот же код API под Python 3.13.17 (scripts/dev/* — хуки и сборщик для такого стенда; evidence/stack.txt — версии и процессы). Compose-файл проверен docker compose config, раскладка контейнера (код только для чтения, uid 10001, /app/src + /app/migrations) проверена запуском API в такой же раскладке. Перед защитой выполните make up && ./scripts/collect-evidence.sh (Windows: scripts\collect-evidence.ps1, см. выше), чтобы evidence/ содержал вывод именно Compose-стенда; тот же сценарий автоматически гоняет .github/workflows/app.yml.

Архитектура и решения

             127.0.0.1:8080                       сеть backend (internal: true)
 клиент ──HTTP──► api (Starlette/uvicorn, 1 процесс) ──► postgres:16  [volume pgdata]   источник истины
                   │  пул psycopg ≤10 соединений         users, chats, chat_members, messages,
                   │                                     sessions, session_cache_invalidations
                   └──────────────────────────────────► redis:7.4    [без volume]      кэш сессий (TTL)
 127.0.0.1:8081 ──► api-ttl (профиль ttl, SESSION_TTL_SECONDS=2) — только для теста истечения
                    postgres-restore (профиль research) [volume pgrestore] — «новое хранилище» трека 5.2
Роль Service Образ Health/readiness Volume Сеть/порт Credentials
api api сборка Dockerfile → mtusi-lab2-api:local python -m messenger healthcheck → /health/ready нет (stateless) frontend+backend, 127.0.0.1:8080 secrets database_url, cache_url → *_FILE
postgres postgres postgres:16.10-alpine pg_isready pgdata backend, не публикуется POSTGRES_PASSWORD_FILE
redis_or_valkey redis redis:7.4.2-alpine redis-cli ping (пароль через REDISCLI_AUTH) нет — это кэш backend requirepass из secret, конфиг пишется в /tmp

Контейнер API: non-root (uid 10001), read_only, cap_drop: ALL, no-new-privileges, лимиты 1 CPU / 512 MiB; PID 1 — сам uvicorn, SIGTERM → graceful shutdown.

Что перенесено из lab1 и что изменено. Предметная модель и REST-контракт сохранены; хранилище in-memory заменено PostgreSQL. По объявленному переходу 1→2: password обязателен при регистрации, POST /auth/sessions принимает только Basic, все бизнес-endpoint — только Bearer; X-User-Id игнорируется (не даёт доступа и не меняет владельца).

Модель данных (migrations/0001_init.sql): PK у всех таблиц; users.username — UNIQUE + CHECK формата; chat_members (chat_id, user_id) — PK и FK на chats/users, position сохраняет порядок member_ids; messages имеет составной FK (chat_id, sender_id) → chat_members, т.е. «отправитель — участник чата» гарантирует сама БД; CHECK длин (char_length — code points). Время назначает БД (clock_timestamp()), отдаётся как RFC 3339 UTC с микросекундами и Z. Индексы выводятся из запросов: messages (chat_id, created_at, id) — история; chat_members (user_id, chat_id) — список чатов пользователя; sessions (expires_at) — очистка.

Миграции: src/messenger/db.py применяет migrations/NNNN_*.sql по порядку, каждую в своей транзакции, и записывает версию+SHA-256 в schema_migrations; всё под pg_advisory_lock (несколько экземпляров API не применят миграцию дважды — evidence/migrations.txt: два экземпляра стартовали одновременно на пустой БД, один применил обе миграции, второй — applied: []). Изменённая уже применённая миграция — ошибка старта. Seed-данных нет, поэтому повторный запуск ничего не дублирует.

Транзакционные границы.

  • POST /chats: одна транзакция INSERT chats + INSERT chat_members … unnest(member_ids). Неизвестный участник → FK violation → ROLLBACK → 400; чат без участников не возникает (проверено тестом).
  • POST /messages: один оператор INSERT … SELECT … WHERE EXISTS(membership) — проверка доступа и запись атомарны; плюс составной FK.
  • Регистрация: уникальный индекс — окончательный арбитр гонки (предварительный SELECT лишь экономит KDF).
  • DELETE /auth/sessions/current: одна транзакция UPDATE sessions SET revoked_at + строка в outbox инвалидации кэша. COMMIT в PostgreSQL делает отзыв окончательным.

Аутентификация и сессии. Пароль: scrypt N=2^15, r=8, p=3 (вариант OWASP, ≈32 MiB на вычисление), соль 16 байт, формат $scrypt$ln=15,r=8,p=3$salt$hash — параметры можно усилить без потери старых hash. Одновременных KDF ≤ KDF_CONCURRENCY=4 (защита RAM). Для неизвестного username выполняется KDF над фиктивным hash — время ответа не выдаёт существование пользователя; ответ 401 одинаковый. Токен — secrets.token_urlsafe(32) (256 бит), в БД хранится только SHA-256(token) (быстрый hash уместен: токен не перебирается, в отличие от пароля). TTL — SESSION_TTL_SECONDS, expires_at вычисляется в БД и после рестарта не продлевается.

Роль Redis (уровень 4): read-through кэш сессий; источник истины — PostgreSQL.

  • Ключ sess:v1:<sha256> → {user, exp}; TTL записи = min(SESSION_CACHE_TTL_SECONDS=60, остаток сессии) — кэш не продлевает сессию (проверено, pttl=1198ms при остатке 1.2 с).
  • Инвалидация при logout: после COMMIT — Lua-скрипт ставит «надгробие» sess:v1:revoked:<hash> (TTL 75 с) и удаляет ключ. Заполнение кэша — Lua SET, только если надгробия нет. Это закрывает гонку «запрос прочитал сессию из PG до logout и пишет её в кэш после logout» (evidence/test-cache-race.txt).
  • Если Redis недоступен при logout, строка outbox session_cache_invalidations остаётся; любая ошибка Redis переводит экземпляр в режим degraded — кэш не читается, аутентификация идёт в PostgreSQL. Фоновый цикл (раз в 1 с) после успешного PING дообрабатывает outbox и только затем снова включает чтение кэша (тест: outbox=1 во время отказа → 0 после восстановления, отозванный токен остаётся 401).
  • Persistence у Redis выключена намеренно (--save '' --appendonly no): flush/restart Redis = холодный кэш, все сессии в PostgreSQL. Redis не критичен для /health/ready.

Пул и таймауты. AsyncConnectionPool(min=1, max=10, timeout=2s, max_waiting=200, check=check_connection); connect_timeout=3s, statement_timeout=5s, lock_timeout=2s, idle_in_transaction_session_timeout=10s; Redis socket_timeout=0.2s; общий таймаут запроса 10 с; лимит тела 64 KiB (413). Все SQL — параметризованные (psycopg передаёт параметры отдельно от текста, server-side binding); динамически подставляется только выбор из двух литеральных шаблонов SQL.

Ошибки. Единый формат с request_id = X-Request-Id в каждом ответе (включая 404/405 роутера). Недоступность БД/истечение пула/таймаут → 503 unavailable + Retry-After: 1; прочее → 500 без деталей. 405 отдаётся с кодом invalid_request (в enum контракта нет отдельного кода). Логи — JSON в stdout, без query-строк, заголовков, тел, токенов и паролей.

Пагинация. Keyset по (created_at, id), limit+1 для определения next_cursor. Cursor — base64url(JSON: вид списка, область — chat_id или user_id, позиция); cursor другого чата/пользователя → 400. Конкурентные вставки: created_at назначается clock_timestamp() в момент INSERT; транзакция с меньшим временем может закоммититься позже, и читатель, уже прошедший эту позицию, её не увидит при продолжении обхода (повторов нет, пропуск возможен только для записей, закоммиченных «в прошлое» во время обхода). Snapshot между HTTP-запросами контракт не требует.

Соответствие переменных .env.example → реализация.

Переменная Где используется Значение в Compose
APP_HOST, APP_PORT адрес uvicorn 0.0.0.0, 8080
APP_ENV метка окружения lab
SESSION_TTL_SECONDS срок сессии 3600 (api), 2 (api-ttl)
DATABASE_URL_FILE DSN PostgreSQL из secret /run/secrets/database_url
SESSION_STORE только postgres (источник истины) postgres
CACHE_URL_FILE URL Redis из secret /run/secrets/cache_url
SESSION_CACHE (доп.) redis / off / auto redis
SESSION_CACHE_TTL_SECONDS, DB_POOL_*, DB_STATEMENT_TIMEOUT_MS, CACHE_TIMEOUT_SECONDS, REQUEST_TIMEOUT_SECONDS, KDF_CONCURRENCY, SCRYPT_* (доп.) см. src/messenger/config.py значения по умолчанию
API_PORT, API_TTL_PORT (доп.) порты на хосте 8080, 8081

Доказательства критериев

Все файлы — в evidence/. Стенд, на котором они получены, — см. примечание выше и evidence/stack.txt.

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab2 public API scenario smoke.txt
Структура skeleton make check PASS make-check.txt
3: данные и действующие сессии переживают рестарт API и хранилищ без удаления volumes make test-persistence ACTION_SCRIPT=… PASS тем же токеном; PID API/PostgreSQL/Redis до и после различаются persistence.txt, restart-hook.txt
3: PK/FK, UNIQUE username, миграции с нуля, повтор без дублей старт API на пустой БД; python -m messenger migrate 2 миграции применены, повтор {"applied": []}, 13 индексов migrations.txt
3: атомарное создание чата test-api: «compound create-chat rolls back» 400, 0 строк чата с этим title, 0 «сиротских» участников test-api.txt
3: Basic только на /auth/sessions, Bearer везде, X-User-Id не даёт доступа, expiry и logout test-api, smoke 401 + верный WWW-Authenticate; X-User-Id не меняет пользователя; logout → 401, повтор → 401 test-api.txt, smoke.txt
3: password KDF test-api: «stored only as scrypt» $scrypt$ln=15,r=8,p=3$…, у одинаковых паролей разные hash test-api.txt
3: secrets/volumes вне Git .gitignore (secrets/, .env, backups/) в архиве нет secrets/, .env, дампов —
4: Redis с конкретной ролью, TTL, инвалидация test-cache-race, test-failures надгробие блокирует поздний SET; TTL ≤ остатка сессии; outbox дообработан после восстановления test-cache-race.txt, test-failures.txt
4: параметризованные запросы, ограниченный пул, таймауты test-api: injection-payload; конфигурация пула payload сохранён дословно; при остановленной БД ответы 503 за ≈2 с (таймаут пула) test-api.txt, test-failures.txt
4: гонка регистрации test-api: 20 параллельных POST одного username ровно 1×201 и 19×409, 1 строка; все 19 конфликтов отсечены уникальным индексом test-api.txt, race-unique-violations.txt (=19)
4: rollback составной операции см. строку уровня 3 — test-api.txt
4: индекс истории + EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 сообщений; пагинация без полного scan research/track2.py plans на 120 000 сообщений keyset-страница из середины горячего чата: Index Scan, 12 буферов, 0.033 мс track2/explain_V3_chat_created_id_hot.txt, track2/plans.json
4: автоматические проверки expiry, logout, неверного пароля, недоступности Redis/БД test-expiry, test-api, test-failures все PASS; аноним при любом отказе — 401, неизвестный токен при мёртвой БД — не 200 test-expiry.txt, test-api.txt, test-failures.txt
5, трек 2: ≥100 000 сообщений, неравномерные чаты, ≥2 индекса/запроса, стоимость записи research/track2.py 5 вариантов индекса × 3 запроса × 3 чата; WAL/insert и размер индекса track2/dataset.json, plans.json, writes.json
5, трек 2: backup → новое хранилище → сверка research/track2.py backup все таблицы, индексы, ограничения и 200 выбранных сообщений совпали; граница потери данных измерена track2/backup_restore.json
Нагрузка (для профиля) tests/load.py --duration 30 --concurrency 4 598 успешных RPS, 0 ошибок, p50/p95/p99 = 6.3/9.4/12.0 мс load.json, load-resources.json

Эксперименты и отказы

Окружение измерений: 2 vCPU Intel Xeon 2.8 GHz, 8 GiB RAM, без cgroup-лимитов; PostgreSQL 16.15 c shared_buffers=128MB (по умолчанию), Redis 7.0.15; один процесс API. Нагрузка: closed-loop tests/load.py, 4 потока, 30 с, без прогрева (первые запросы включены), история одного чата растёт до ~18 000 сообщений за прогон. Результат: 597.7 RPS успешных, 0 ошибок, p50 6.28 / p95 9.45 / p99 12.03 мс; API занимает ≈1 ядро (0.99) и до 80 MiB RSS — узкое место — однопроцессный Python, а не БД. Генератор closed-loop страдает coordinated omission; число не является пропускной способностью системы.

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
Рестарт API + PostgreSQL + Redis (restart hook) данные и прежний токен живы PASS, тот же токен читает те же сообщения; новые PID у всех трёх ≈3 с до /health/ready; потерь нет
Остановка Redis вход, чтение, запись и logout работают через PostgreSQL всё 2xx; задержка /users/me 10 мс; /health/ready 200 после старта Redis outbox (1 строка) дообработан за ≤1 с; отозванный токен остаётся 401
Остановка PostgreSQL ограниченная ошибка, без доверия анониму /health/live 200, /health/ready 503 за 1.5 с; запись/история/вход/регистрация — 503 unavailable за 2.0 с; без токена — 401 ready снова 200 через 2.2 с после старта БД; данные не изменились
Короткий TTL = 2 с 401 после истечения даже при прогретом кэше PASS; строка сессии не удалена и не отозвана — истекла по expires_at —

Трек 5.2. План запроса истории и восстановление

Гипотезы. H1. На неравномерных чатах индекс только по chat_id достаточен для маленьких чатов, но для горячего чата требует чтения и сортировки всей его истории на каждую страницу; составной (chat_id, created_at, id) делает стоимость keyset-страницы независимой от размера чата и глубины. H2. OFFSET-пагинация на глубине k читает O(k) записей при любом B-tree без покрытия. H3. Каждый дополнительный столбец индекса увеличивает стоимость записи (WAL, размер), покрывающий индекс — заметно. H4. Логический backup (pg_dump) восстанавливается в новое хранилище с полным совпадением данных, а потеря при восстановлении = все транзакции, закоммиченные после снимка pg_dump.

Методика (повторяемая). python3 research/track2.py (по умолчанию все шаги; Compose-команды подставляются сами, для нативного стенда — переменные SRC_PSQL/DST_PSQL/… см. scripts/dev/collect-native.sh).

  1. setup: отдельная БД research, те же миграции, что у приложения (рабочая БД не трогается).
  2. generate (research/generate.sql, setseed(0.42)): 2 000 пользователей, 300 чатов по 2–50 участников, 120 000 сообщений; доля чата ранга k ∝ 1/k^1.1. Получено: крупнейший чат 24 294 (20.2 %), топ-10 — 54.4 %, медиана 98, минимум 38. Сообщения вставлены в глобальном хронологическом порядке, чаты перемешаны во времени — строки горячего чата лежат на 3 614 из ~3 620 страниц heap.
  3. plans: для каждого варианта индекса — DROP/CREATE INDEX, VACUUM ANALYZE, затем EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON) трёх запросов для горячего, медианного и самого маленького чата: первая keyset-страница, keyset-страница с cursor в середине истории и та же страница через OFFSET n/2. Один прогрев + 15 измерений, медиана Execution Time. Буферы — из последнего прогона (кэш тёплый, shared read = 0).
  4. writes: 50 000 однострочных INSERT в таблицу той же формы с тем же индексом (одна транзакция, CHECKPOINT перед прогоном, распределение chat_id как в истории), 5 прогонов, медиана; WAL — по pg_current_wal_insert_lsn().
  5. backup: фоновый писатель коммитит пронумерованные marker-NNNNNN каждые ~10 мс; через 1 с запускается pg_dump -Fc -Z 6, писатель продолжает ещё 1 с после окончания дампа. Затем pg_restore -j 4 в другой сервер PostgreSQL (Compose: postgres-restore со своим volume), сверка: количество и md5-агрегат каждой таблицы, определения индексов и ограничений, 200 выбранных сообщений (первое/последнее в 10 крупнейших чатах + 180 псевдослучайных по md5(id)), страница истории горячего чата с OFFSET 1000, и множество маркеров.

Результаты: чтение (медиана, мс / прочитано буферов по 8 KiB; evidence/track2/plans.json).

Вариант индекса истории Размер hot: keyset 1-я стр. hot: keyset середина hot: OFFSET 12 147 median: keyset сер. small: keyset сер.
V0 нет (только PK) 0 18.13 / 3705 18.34 / 3647 28.46 / 3617 15.64 / 3647 17.62 / 3647
V1 (chat_id) 0.8 MiB 12.67 / 3636 12.08 / 3636 20.12 / 3636 0.081 / 99 0.038 / 40
V2 (chat_id, created_at) 4.7 MiB 0.036 / 10 0.038 / 11 21.45 / 3737 0.070 / 53 0.048 / 23
V3 (chat_id, created_at, id) 6.8 MiB 0.023 / 10 0.033 / 12 25.01 / 3790 0.050 / 52 0.028 / 22
V4 V3 INCLUDE (sender_id, text) 30.0 MiB 0.031 / 5 0.035 / 6 2.14 / 390 0.034 / 5 0.022 / 4

Планы (горячий чат): V0 — Parallel Seq Scan + Sort; V1 — Bitmap Index Scan + Bitmap Heap Scan + Sort всех 24 294 строк; V2 — Index Scan + Incremental Sort (в индексе нет id, сортировка по tie-breaker внутри одинаковых created_at); V3 — чистый Index Scan с Index Cond: chat_id = … AND ROW(created_at, id) > ROW(…) и Limit (полный текст — explain_V3_chat_created_id_hot.txt); V4 — Index Only Scan. Для OFFSET при V1–V3 планировщик выбирает bitmap-скан всех строк чата + sort (и даже external merge на диск 5.4 MB), потому что строки чата разбросаны по всей heap и случайный доступ к 12 000 строкам дороже.

Результаты: запись (evidence/track2/writes.json).

Вариант мкс/INSERT (медиана) к V0 WAL, байт/INSERT индекс после 50 000 строк
V0 12.81 — 360 —
V1 15.56 +21 % 438 (+22 %) 0.44 MiB
V2 15.44 +21 % 471 (+31 %) 3.13 MiB
V3 14.88 +16 % 502 (+39 %) 4.52 MiB
V4 18.58 +45 % 849 (+136 %) 20.95 MiB

Разброс времени между прогонами V1–V3 (660–996 мс на 50 000 строк) больше разницы между ними, поэтому по CPU-времени V1, V2, V3 неразличимы; устойчивая метрика — WAL и размер: каждый столбец ключа добавляет ~30–35 байт WAL на вставку, покрывающий индекс с text — более чем удваивает WAL и в ≈4.6 раза больше по размеру.

Результаты: backup → restore → сверка (evidence/track2/backup_restore.json).

Этап Значение
pg_dump -Fc -Z 6 (120 000 сообщений, 28.3 MiB heap) 0.78 с, 7.2 MB
pg_restore -j 4 в новый сервер (включая построение 13 индексов и 23 ограничений) 0.97 с
Сверка 2.37 с; совпали users 2000, chats 300, chat_members 7720, messages 120 000, schema_migrations 2, индексы 13, ограничения 23; 200/200 выбранных сообщений и страница истории идентичны
Маркеры: подтверждено до старта дампа / к концу дампа / всего 76 / 137 / 221
Маркеры в восстановленной БД 80, ровно 1…80 (непрерывный префикс)

Восстановленная база — согласованный снимок на момент начала pg_dump (маркеры 77–80 закоммичены между чтением счётчика и взятием снимка): ни одной «дырки», но всё, что закоммичено после снимка (141 из 221 маркера, включая 57 подтверждённых клиенту во время дампа), в backup отсутствует.

Выводы.

  • H1 подтверждена: при V1 горячий чат стоит 12 мс и ~3 600 буферов на каждую страницу (вся история чата), при V3 — 0.03 мс и 10–12 буферов независимо от размера чата и глубины cursor; для маленьких чатов V1 уже достаточен — неравномерность распределения и есть причина выбора составного индекса. V3 против V2 убирает Incremental Sort и делает cursor (created_at, id) полностью индексным условием ценой +2.1 MiB и +31 байта WAL на вставку.
  • H2 подтверждена: OFFSET в середине горячего чата — 20–25 мс при любом некрывающем индексе (≈750× медленнее keyset при V3). Покрывающий индекс ускоряет OFFSET до 2 мс, но остаётся O(k) (390 буферов) и стоит +136 % WAL и 4.4× размера индекса — для API выбран keyset + V3, а не покрытие.
  • H3 подтверждена по WAL/размеру; по CPU различия V1–V3 на этом железе в пределах шума.
  • H4 подтверждена: полное совпадение после восстановления в отдельный сервер. RTO этого набора ≈ 4 с (дамп + восстановление + сверка), растёт примерно линейно с объёмом данных и индексов; к нему добавляются запуск нового сервера и переключение DSN приложения. RPO логического backup = интервал между backup: всё после начала последнего pg_dump теряется. Уменьшить RPO до секунд можно непрерывной архивацией WAL + base backup (PITR) или репликой; это не реализовано.

Ограничения измерений. Тёплый кэш (весь набор помещается в shared_buffers+page cache, shared read = 0): измерена CPU/буферная стоимость, а не дисковый I/O; на холодном кэше разрыв V1/V3 для горячего чата будет больше. Один прогон набора с фиксированным seed (UUID случайны); 15 повторов на запрос. В тесте записи нет FK и COMMIT на каждую строку (изолирована стоимость индекса; в API к ней добавляется fsync COMMIT). Планы сняты с литералами; приложение через psycopg после 5 выполнений использует prepared statements — для keyset-запроса generic plan тот же Index Scan, но для сильно неравномерных данных это стоит проверять отдельно (plan_cache_mode). Числа получены на нативном стенде; в Compose с лимитами CPU/RAM их нужно повторить (make research-track2).

Ответы на вопросы защиты

  • Что подтверждает COMMIT? Что запись транзакции сброшена в WAL на диск (synchronous_commit=on, fsync=on — значения по умолчанию, не менялись) и переживёт падение процесса/ОС. При synchronous_commit=off или fsync=off подтверждённые транзакции могут потеряться; от потери диска/хоста COMMIT на одном сервере не защищает — для этого нужны реплика/backup.
  • Где хранятся сессии и что будет после flush/restart Redis? В PostgreSQL (таблица sessions, только SHA-256 токена). Redis — кэш без persistence: после flush/restart кэш пуст, первое обращение читает PostgreSQL и прогревает кэш; ни одна сессия не теряется и отозванная не воскресает.
  • Аутентификация vs доступ к чату. Аутентификация (Bearer → пользователь) — authenticate(); авторизация — проверка членства в каждом запросе к чату. Чужой или несуществующий чат — одинаковый 404, порядок «сначала 401, затем 404/400».
  • Hash пароля vs быстрый checksum. KDF (scrypt) специально медленный и memory-hard с солью, чтобы перебор украденной базы был дорогим; SHA-256 быстрый — годится для целостности и для поиска токена с 256 битами случайности (перебор бессмысленен), но не для паролей с низкой энтропией.

Ограничения и следующие шаги

  • Выдерживается: рестарт любых компонентов с сохранёнными volumes; отказ Redis (полная работоспособность через PostgreSQL); отказ PostgreSQL (ограниченный 503, восстановление без перезапуска API). Не выдерживается: потеря host/диска (одна БД, один host), отказ единственного экземпляра API.
  • Окно устаревания кэша: если Redis был не перезапущен, а только сетево недоступен для экземпляра во время logout, отозванная запись живёт в Redis до дообработки outbox (≤1 с после восстановления связи этого экземпляра); экземпляр, сам не видевший ошибки (появится в lab3 с репликами), может прочитать её в это окно, но не дольше SESSION_CACHE_TTL_SECONDS (60 с). Это задокументированное учебное упрощение.
  • Время сессий в кэше сравнивается с часами API, а expires_at назначает БД: на одном host часы общие; при разных хостах нужен NTP.
  • Нет rate limiting входа (429 в контракте факультативен) — следующий шаг вместе с lab7.
  • evidence/ собраны на нативном стенде (см. выше); повторить на Compose: ./scripts/collect-evidence.sh.