Files
2026-10-30 12:32:42 +03:00

79 KiB
Raw Permalink Blame History

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

  • Автор, группа: Костылев Артём, БПИ2303
  • Целевая оценка: 5; трек «5» — трек 2 «План запроса и восстановление»
  • Commit/PR: ветка solution/bpi2303-kostylev; код (src/, compose.yaml, Dockerfile, student-tests/) последний раз менялся в коммите bc90266. Все файлы evidence/ сняты на 6468ee2: код там тот же, после bc90266 менялись только скрипты доказательств и архив openspec. Дальше коммиты меняют только отчёт и evidence/. PR «ЛР 2 — БПИ2303 — Костылев — на 5» в репозиторий преподавателя заполняется по .github/pull_request_template.md; его ссылка появляется при публикации
  • Использованные источники, библиотеки и помощь ИИ: FastAPI, gunicorn + uvicorn-worker, dishka, pydantic, structlog, asyncpg, redis-py (redis.asyncio), argon2-cffi, pytest, ruff, ty (версии — evidence/environment.txt и uv.lock); документация PostgreSQL (transactions, EXPLAIN, WAL reliability), Valkey persistence, RFC 7617, OWASP Password Storage Cheat Sheet. Решение перенесено из моей лабы 1 и выполнено с помощью Claude Code; код, стенд и измерения проверены прогонами, перечисленными ниже.

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

Требуются Docker с Compose v2 и make; системный Python 3.9+ — только для публичных проверок. Образы сторонних сервисов закреплены версией и digest, API собирается из исходников.

git clone <repo> && cd mtusi2026lab2 && git checkout solution/bpi2303-kostylev

make secrets        # secrets/*: пароль PostgreSQL, DATABASE_URL, valkey.conf и CACHE_URL, ключ курсора; .env из .env.example
make up             # docker compose up -d --build --wait: postgres и valkey → migrate → api, ждёт healthy
make test           # публичный smoke против http://localhost:$API_PORT
make test-persistence ACTION_SCRIPT=scripts/restart.sh

make down           # безопасная остановка: контейнеры удаляются, volumes с данными остаются
make reset-data     # НАМЕРЕННОЕ удаление учебных данных: docker compose down -v

Стенд останавливают только make down и make reset-data: в них стоит --profile faults --profile track. Простой docker compose down не видит профильные api-shortttl и postgres-restore, которые поднимают make test-faults, трек и make environment-evidence, и не может удалить сеть («Resource is still in use»). При ручном вызове профили нужно указать явно: docker compose --profile faults --profile track down.

make secrets идемпотентен: существующие файлы не перезаписываются, поэтому пароль остаётся согласованным с уже созданным volume. Значения нигде не печатаются. Порты хоста задают API_PORT (по умолчанию 8080) и SHORTTTL_PORT (8082, экземпляр с коротким TTL) в .env. Makefile читает .env, поэтому BASE_URL и SHORTTTL_URL следуют за ними без флагов. Переопределить порты можно переменной окружения (API_PORT=18082 make up: Makefile запоминает её до чтения .env и возвращает после) или аргументом make (make test-faults API_PORT=18082 SHORTTTL_PORT=22082). Доказательства в evidence/ сняты на портах 18082 и 22082. Образ приложения помечается именем compose-проекта (mtusi-messenger:${COMPOSE_PROJECT_NAME}), поэтому клон в другом каталоге собирает свой образ и не перетирает чужой.

Собственные проверки и тулчейн:

make install        # uv sync --group dev (Python 3.14, зависимости из uv.lock, openapi-spec-validator)
make lint           # ruff check + ruff format --check + ty check
make student-test   # собственные тесты; поднимают одноразовые PostgreSQL и Valkey тех же образов в Docker
make student-test PYTEST_ARGS='-v -k cache'   # выборка тестов с именами (аргументы уходят в pytest)
make check          # офлайн-проверка skeleton
make validate       # полная валидация OpenAPI 3.1: берёт .venv/bin/python, если его создал make install
make migrate        # повторный запуск миграций на текущей БД
make test-faults            # поднимает api-shortttl и гоняет 13 тестов отказов против стенда
make seed explain           # 20 000 сообщений в синтетическом чате и EXPLAIN (ANALYZE, BUFFERS)
make track-bench            # трек 5: база track, 1 000 000 сообщений по Ципфу, 4 набора индексов + контроль, pgbench (~10 мин)
make track-recovery         # трек 5: pg_dump → новый postgres-restore → pg_restore → сверка, 100k и 1M × 3 (~1.5 мин)

Без make install каталога .venv нет, и make validate идёт системным python3, где нет openapi_spec_validator (ModuleNotFoundError). Тогда нужен make install или pip install -r requirements-dev.txt.

Короткая проверка трека без перезаписи evidence/track (аргументы уходят в scripts/track.py):

make track-bench TRACK_ARGS='--messages 20000 --write-seconds 2 --write-repeats 1 --out backups/track-quick'      # ~40 с
make track-recovery TRACK_ARGS='--sizes 100000 --repeats 1 --out backups/track-quick'                            # ~15 с

Каждый файл доказательств пишет своя цель, с датой и коммитом в заголовке:

make toolchain-evidence     # check, validate, lint, test → checks.txt; student-test -v и выборки -k → student-tests.txt
make migrations-evidence    # НАМЕРЕННО удаляет volumes: 0001_init на пустом volume, затем повтор → migrations.txt
make persistence-evidence   # persistence-тест + StartedAt сервисов до и после → persistence.txt
make storage-evidence       # \d+ схемы, префикс KDF, правила ignore и volumes проекта → schema/kdf/secrets.txt
make cache-evidence         # AOF, попадания, ключи и отметки отзыва, срок ключа против срока сессии → cache.txt
make faults-evidence        # make test-faults → faults.txt
make load-evidence          # 3 прогона tests/load.py c64 с docker stats и ожиданиями pg_stat_activity → load.txt, load-c64-{1,2,3}.json
make sigterm-evidence       # SIGTERM api при двух запросах в работе: ответы, время и код завершения → sigterm.txt
make environment-evidence   # host, образы, версии пакетов, uid процессов (сам поднимает профильные сервисы), durability → environment.txt

Версии и стенд: Python 3.14.7 в образе python:3.14-slim-trixie@sha256:51dafde8…, postgres:17.11-alpine@sha256:266d3c25…, valkey/valkey:8.1.11-alpine@sha256:2602ace2…, uv 0.9.7 по digest, Docker 28.3.2, Compose 2.38.2. Машина — Apple M4 Max, 16 CPU, 48 ГБ RAM, macOS 15.1; VM Docker Desktop — 16 CPU, 7.65 ГиБ. Полный список — evidence/environment.txt.

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

                         ┌──redis.asyncio, 0.2 с──▶ valkey (кэш сессий, AOF, volume valkeydata)
клиент ──HTTP──▶ api (gunicorn, 4 × UvicornWorker)
                         └──asyncpg pool, 1–2 с──▶ postgres (источник истины, volume pgdata)
                 migrate (тот же образ, одноразово до старта api) ──▶ postgres
                 api-shortttl (профиль faults, SESSION_TTL_SECONDS=2) ──▶ те же postgres и valkey

Перенесено из лабы 1: две доменные зоны identity и messaging, порты и адаптеры, UoW, шина событий с журналом аудита, единый ASGI-конвейер (X-Request-Id → предел тела → таймаут, внутри которого аутентификация и обработчик → журнал), курсор с HMAC, pydantic-схемы на границе, structlog за портом Logger, non-root образ. Изменено после ревью (change 2026-10-28-harden-lab2-after-review): предел тела 1 MiB считает фактически принятые байты, поэтому и chunked-тело больше предела получает 413. Изменено после второго ревью (change 2026-10-28-harden-lab2-second-review): выход при сбое PostgreSQL снимает отметку отзыва (см. «Инвалидация»); пустой cursor= даёт 400; воркер uvicorn ждёт принятые запросы 7 с, мастер gunicorn ждёт воркеры 8 с (SHUTDOWN_TIMEOUT_SECONDS), Docker ждёт 10 с (stop_grace_period). В evidence/sigterm.txt два запроса в работе: тот, чьё тело дописано через 1 с после SIGTERM, получает 201. Тот, чьё тело не приходит, воркер сам отменяет через 7.2 с (клиент получает 500) и выходит штатно; контейнер останавливается за 7.68 с с кодом 0. Когда сроки воркера и мастера были равны, мастер успевал убить такой воркер раньше. Удалено: адаптеры в память, реестр участников с проекцией, слоёный конвейер и режимы блокировки — инструменты эксперимента лабы 1, которым в PostgreSQL не с чем сравниваться.

Источник истины — PostgreSQL для всего: пользователей, сессий, чатов, участников и сообщений. API не держит состояния между запросами, поэтому воркеров несколько. Valkey — только кэш сессий: его потеря не теряет данных и не открывает доступ.

Схема и ограничения (src/messenger/migrations/0001_init.sql, вывод \d+ — evidence/schema.txt):

Таблица Ключи и ограничения Индексы и зачем
users PK id; UNIQUE (username); CHECK формата username, длины display_name, префикса $argon2id$ у хеша users_username_key — вход по username и уникальность
sessions PK token_hash (32 байта SHA-256); FK user_id → users; CHECK expires_at > created_at sessions_user_idx — удаление истёкших при входе
chats PK id; CHECK длины title; last_message_at — отметка последнего сообщения —
chat_members PK (chat_id, user_id); FK chat_id → chats, user_id → users; position — порядок member_ids (user_id, chat_created_at, chat_id) — keyset-список чатов одним индексом
messages PK id; FK (chat_id, sender_id) → chat_members; CHECK длины text (chat_id, created_at, id) — keyset-история без сортировки

Составной FK messages → chat_members держит на уровне БД правило «пишет только участник»: вставка от постороннего отклоняется даже в обход API (тест test_sender_must_be_member_even_bypassing_api).

Границы транзакций. Регистрация — один INSERT … ON CONFLICT (username) DO NOTHING RETURNING: при гонке ровно один успешен, остальные получают 409. Вход — один оператор, удаляющий истёкшие сессии пользователя и вставляющий новую. Создание чата — INSERT chats и INSERT chat_members из unnest(…) WITH ORDINALITY в одной транзакции UoW: несуществующий участник даёт нарушение FK, транзакция откатывается целиком, ответ 400. Сообщение — SELECT … FOR UPDATE строки чата с условием членства отправителя (посторонний сразу получает 404 и не встаёт в очередь за участниками, тест test_outsider_does_not_wait_for_members_lock), затем одним оператором INSERT messages и UPDATE chats.last_message_at. Чтения — по одному оператору без явной транзакции. UoW фиксирует только явно, откат — по умолчанию.

Порядок истории при нескольких процессах. Монотонные часы процесса лабы 1 при четырёх воркерах ничего не гарантируют. Агрегат Chat хранит last_message_at и назначает created_at = max(now, last + 1 мкс) под блокировкой строки чата. Порядок фиксации поэтому совпадает с порядком (created_at, id), и keyset-читатель не пропускает сообщение, зафиксированное позже с меньшей отметкой. Цена — запись в один горячий чат сериализуется; разные чаты не мешают друг другу. Идентификаторы — UUIDv7.

Зоны и общая БД. Проекция участников заменена внешним ключом chat_members.user_id → users: проверку «участник существует» делает СУБД внутри той же транзакции. Зоны не вызывают и не импортируют друг друга, SQL зоны messaging не читает users и sessions, зона identity не читает таблиц чатов — это проверяет тест границ по импортам и по текстам SQL; требование lab1-event-publication «Доменные зоны не вызывают друг друга; общая точка — схема БД» заменило прежнее «связаны только событиями». Цена: схемы зон сцеплены, identity нельзя вынести в отдельную БД или сервис, не вернув проекцию участников с outbox; FK при создании чата берёт FOR KEY SHARE на строках users; любое нарушение FK в INSERT chat_members обезличенно становится «неизвестный участник» (400). Триггер пересмотра — отдельная БД для зоны identity.

Пароли и сессии. Argon2id m=19 MiB, t=2, p=1 (минимум OWASP) в пуле потоков под семафором (2 на воркер), чтобы не блокировать event loop и ограничить память при всплеске регистраций. Для неизвестного username выполняется проверка против фиктивного хеша — время не выдаёт существование пользователя. Токен — secrets.token_urlsafe(32) (43 символа, 256 бит); в БД лежит только его SHA-256. Пароль хешируется медленно, потому что у него мало энтропии и перебор надо удорожать; у токена энтропия полная, быстрого хеша достаточно, а утечка таблицы sessions не даёт действующих токенов. Срок абсолютный: expires_at = вход + SESSION_TTL_SECONDS, проверка по часам приложения, рестарт его не продлевает. Выход — удаление строки.

Аутентификация в конвейере. Страж зоны identity работает в ASGI-конвейере до FastAPI, поэтому 401 приходит раньше 404 и 400, даже при битом JSON. Basic разбирается своим строгим парсером (base64 с validate=True, первое :, UTF-8, ASCII-username) только на POST /api/v1/auth/sessions; остальные /api/v1/* принимают только Bearer. WWW-Authenticate выбирается по пути: Basic realm="messenger", charset="UTF-8" на входе и Bearer realm="messenger" везде, включая Basic на бизнес-endpoint. X-User-Id не читается нигде. Отказ БД при проверке сессии — 503 unavailable, не 401.

Пул и таймауты. asyncpg-пул ленивый (min_size=0, max_size=8 на воркер; 4×8 < max_connections), подключение 1 с, ожидание соединения из пула 1 с, команда 2 с на клиенте и statement_timeout, lock_timeout 2 с на сервере. Сетевые ошибки и отказ сервера превращаются в 503. Готовность /health/ready выполняет SELECT 1 через тот же пул; /health/live от БД не зависит.

Роль Valkey: read-through кэш сессий. Адаптер CachedSessionDirectory оборачивает справочник сессий PostgreSQL за тем же портом чтения SessionDirectory и реализует отдельный порт SessionRevocations для отзыва (без кэша — пустой NoRevocations) — домен и обработчики о кэше не знают.

  • Что лежит: ключ session:<sha256 токена>, значение — user_id и сроки сессии. Токена в кэше нет.
  • Чтение: GET; промах → SELECT в PostgreSQL → SET … NX PXAT. Повторные проверки одного токена обслуживает Valkey (keyspace_hits растёт, evidence/cache.txt, evidence/faults.txt).
  • Expiry: PXAT — абсолютное время, min(expires_at, сейчас + SESSION_CACHE_TTL_SECONDS); повторное заполнение не продлевает сессию, ключ не переживает сессию (pexpiretime ≤ expires_at в evidence/cache.txt). Потолок 300 с — страховка от ошибки инвалидации.
  • Инвалидация: выход сначала пишет отметку отзыва SET key "-" PXAT expires_at, затем удаляет строку в БД. Заполнение идёт только с NX, поэтому читатель, достававший сессию из БД в момент выхода, не перетрёт отметку и не оживит токен (тест test_fill_racing_with_logout_does_not_revive_token). Если отметку записать нельзя, выход отвечает 503 и сессию не трогает: иначе после возвращения Valkey из AOF ожила бы закэшированная запись. Если отметка записана, а удаление или COMMIT в PostgreSQL упали, отметка снимается (DEL, через тот же размыкатель) и выход отвечает 503. Значит, 503 всегда означает «ничего не изменилось»: токен работает, повтор после возвращения БД даёт 204 (тест test_logout_rejected_by_database_changes_nothing). До исправления отметка оставалась: повтор отвечал 401, а после вытеснения отметки или FLUSHALL токен оживал. Остаток без двухфазной фиксации: при неоднозначном COMMIT строка уже удалена, и если в то же окно чтение успеет заполнить кэш, токен проживёт в кэше до 300 с. Клиент же получил 503 и повторит выход.
  • Недоступность: таймаут 0.2 с, один повтор на новом соединении, размыкатель на 1 с. Проверка уходит в PostgreSQL, неизвестный токен получает 401; запрос никогда не становится анонимным. Готовность от Valkey не зависит.
  • Persistence: AOF appendfsync always на volume valkeydata: подтверждённая отметка отзыва уже на диске, рестарт сохраняет тёплый кэш и отметки. FLUSHALL безвреден: источник истины — PostgreSQL. maxmemory 64mb с volatile-lru: вытеснение любой записи безопасно по той же причине.

Курсор подписывается постоянным ключом из secrets/cursor_secret: страница, выданная одним воркером, продолжается другим и после рестарта.

Миграции. python -m messenger.migrate: pg_advisory_lock, schema_migrations(version, checksum, applied_at), каждая версия — в своей транзакции, изменённая применённая миграция останавливает запуск. Одноразовый сервис migrate стартует после postgres: service_healthy, api — после migrate: service_completed_successfully. Применение к пустому volume и безопасный повтор — evidence/migrations.txt.

Инфраструктура (compose.yaml, одна внутренняя сеть backend, наружу — только API на 127.0.0.1):

Роль Сервис Версия / digest Health / readiness Volume Сеть / порт Credentials
api api образ mtusi-messenger:${COMPOSE_PROJECT_NAME} из Dockerfile, python по digest, uid 10001; SIGTERM: воркер ждёт 7 с, gunicorn 8 с, stop_grace_period 10 с GET /health/ready (пингует БД), при старте раз в 200 мс нет 127.0.0.1:${API_PORT:-8080}:8080 secrets database_url, cache_url, cursor_secret через *_FILE
postgres postgres postgres:17.11-alpine@sha256:266d3c25…, uid 70 pg_isready, при старте раз в 200 мс (start_interval) pgdata:/var/lib/postgresql/data backend, порт не публикуется secret postgres_password через POSTGRES_PASSWORD_FILE
cache valkey valkey/valkey:8.1.11-alpine@sha256:2602ace2…, uid 999 valkey-cli ping с паролем valkeydata:/data (AOF) backend, порт не публикуется secret valkey.conf (requirepass); API — secret cache_url
bootstrap migrate образ api код выхода 0 нет backend secret database_url
expiry-тест api-shortttl (профиль faults) образ api, SESSION_TTL_SECONDS=2, 1 воркер как у api нет 127.0.0.1:${SHORTTTL_PORT:-8082}:8080 как у api

Критичная зависимость готовности — только PostgreSQL. Bootstrap: make secrets (идемпотентно), make up (миграции применяет migrate), повтор обеих команд безопасен.

Соответствие .env.example реальной конфигурации:

.env.example В решении Комментарий
APP_HOST, APP_PORT HOST, PORT заданы в образе (0.0.0.0:8080); порт хоста — API_PORT
APP_ENV не используется режимов окружения нет
SESSION_TTL_SECONDS SESSION_TTL_SECONDS по умолчанию 3600
DATABASE_URL_FILE DATABASE_URL_FILE любой параметр читается из <ИМЯ>_FILE
SESSION_STORE=postgres фиксировано PostgreSQL — источник истины сессий, Valkey — кэш поверх него
CACHE_URL_FILE CACHE_URL_FILE без него кэш выключен и всё работает как на уровне «3»
— CURSOR_SECRET_FILE, WEB_CONCURRENCY, API_PORT, SHORTTTL_PORT ключ курсора, число воркеров, порты хоста
— SESSION_CACHE_TTL_SECONDS, CACHE_TIMEOUT_SECONDS, CACHE_COOLDOWN_SECONDS потолок срока ключа 300 с, таймаут 0.2 с, размыкатель 1 с
— DB_POOL_MAX_SIZE, DB_*_TIMEOUT_SECONDS, PASSWORD_HASH_CONCURRENCY пул 8, подключение и acquire 1 с, команда 2 с, Argon2 по 2

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

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test (в make toolchain-evidence) PASS: lab2 public API scenario evidence/checks.txt
Офлайн-проверки и тулчейн make check, make validate (после make install), make lint PASS: offline skeleton structure…, PASS: full OpenAPI 3.1 and JSON Schema validation, ruff и ty — All checks passed! evidence/checks.txt
Persistence: данные и действующие сессии переживают рестарт API и хранилищ make test-persistence ACTION_SCRIPT=scripts/restart.sh (обёртка make persistence-evidence) PASS: persistence preserved confirmed data and existing session; StartedAt у postgres, valkey и api после теста новее, чем до evidence/persistence.txt
Persistence + logout после полного рестарта make test-faults (test_full_restart_keeps_session_until_logout) после scripts/restart.sh прежний токен 200, выход 204, затем 401 evidence/faults.txt
«3» Минимум lab1 сохранён с переходом на новую аутентификацию make student-test PYTEST_ARGS=-v 221 тест PASSED по именам (в процессе против одноразовых PostgreSQL и Valkey), включая перенесённые проверки ошибок, членства, пагинации и конкурентной записи; ещё 13 тестов стенда — make test-faults evidence/student-tests.txt
«3» Keyset-курсор: чужой, испорченный и пустой отклоняются make student-test PYTEST_ARGS="-v -k cursor" 17 PASSED: курсор другого чата → 400; garbage, 1.2.3.4, %20 и пустой cursor= → 400 invalid_request и в истории, и в списке чатов (до второго ревью пустой давал первую страницу 200) evidence/student-tests.txt
«3» PostgreSQL: пользователи, чаты, участники, сообщения; PK/FK/UNIQUE make storage-evidence (\d+ по таблицам) users_username_key UNIQUE, FK chat_members → users, chats, messages → chat_members evidence/schema.txt
«3» Миграции с нуля и повторный запуск без дублей make migrations-evidence: make reset-data && make up, docker compose logs migrate, make test, make migrate на пустом volume migration.applied 0001_init, 0 строк во всех таблицах и одна версия в schema_migrations; после make test повтор — up to date, счётчики 3/2/1/2/2 до и после равны evidence/migrations.txt
«3» Составная операция создания чата атомарна make student-test PYTEST_ARGS="-v -k rolls_back" test_failed_chat_creation_rolls_back_both_tables PASSED: неизвестный участник → 400, строк в chats и chat_members не появилось evidence/student-tests.txt
«3» Basic только на POST /auth/sessions, остальное — Bearer make student-test PYTEST_ARGS="-v -k 'sessions or bearer'" 34 PASSED, в том числе Basic на /users/me → 401 Bearer realm="messenger", без Basic на входе → 401 Basic … evidence/student-tests.txt
«3» Срок жизни сессии и отзыв make student-test PYTEST_ARGS="-v -k 'expire or logout'" 6 PASSED: TTL 1 с → 401; DELETE /auth/sessions/current → 204, затем 401, повтор → 401, вторая сессия жива; удаление в БД упало → 503, токен 200, отметки в Valkey нет, повтор → 204 evidence/student-tests.txt
«3» X-User-Id не даёт доступ make test; make student-test PYTEST_ARGS="-v -k user_id" один X-User-Id → 401; Bearer alice + X-User-Id eve → alice (2 PASSED) evidence/checks.txt, evidence/student-tests.txt
«3» Доступ к чату — по членству, отдельно от аутентификации make test; make student-test PYTEST_ARGS="-v -k outsider" посторонний с действующим токеном получает 404, как на несуществующий чат; запись постороннего не ждёт блокировки чата участником (404 быстрее 0.5 с) evidence/checks.txt, evidence/student-tests.txt
«3» Пароли хешируются password KDF make storage-evidence у всех строк users префикс $argon2id$v=19$m=19456,t=2,p=1$; у 34 настоящих хешей длина 97 символов. Отдельной строкой (seed_stub = t) показан синтетический seed_author из make seed с заглушкой в 44 символа: войти им нельзя, он нужен только для make explain. В sessions только 32-байтовые SHA-256 evidence/kdf.txt
«3» Secrets и volumes не в Git git ls-files secrets .env; git check-ignore -v …; docker volume ls --filter label=com.docker.compose.project=… пусто; пути игнорируются правилами .gitignore; volumes pgdata, valkeydata, pgrestore только у Docker evidence/secrets.txt
Непривилегированные процессы make environment-evidence (сам поднимает api-shortttl и postgres-restore, затем docker compose top без процессов healthcheck) api и api-shortttl — uid 10001, postgres и postgres-restore — uid 70, valkey — uid 999 evidence/environment.txt
Остановка по SIGTERM ≤10 с make sigterm-evidence (два POST /messages с недописанным телом в момент сигнала) дописанный через 1 с после SIGTERM → 201 Created через 1.15 с; недописанный воркер сам отменяет → 500 через 7.24 с (Cancel 1 running task(s) в журнале); остановка за 7.68 с, код 0, при stop_grace_period 10 с evidence/sigterm.txt
Предел тела, в том числе chunked make student-test PYTEST_ARGS="-v -k 'body_limit or chunked'" Content-Length больше предела и chunked-тело больше предела → 413 payload_too_large; chunked в пределах → 201 evidence/student-tests.txt
«4» Valkey реально используется: роль, источник истины make test-faults (test_valkey_serves_repeated_checks); make cache-evidence 5 проверок токена → keyspace_hits 4 → 9; 4 ключа вида session:<sha256>…, из них 1 отметка отзыва evidence/faults.txt, evidence/cache.txt
«4» Политика expiry и инвалидации make student-test PYTEST_ARGS="-v -k cache"; make cache-evidence для сессии из БД pexpiretime ключа ≤ expires_at («ключ не переживает сессию: да»); выход оставляет отметку "-"; гонка заполнения после выхода не оживляет токен; сбой БД при выходе снимает отметку; при недоступном Valkey чат и сообщение создаются (6 PASSED) evidence/student-tests.txt, evidence/cache.txt
«4» Persistence кэша выдерживает рестарт; FLUSHALL make test-faults (restart, flushall); make test-persistence ACTION_SCRIPT=scripts/restart.sh после рестарта Valkey ключей 14 → 14, живой токен 200, отозванный 401; после FLUSHALL то же evidence/faults.txt, evidence/persistence.txt
«4» Параметризованные запросы код адаптеров */infrastructure/postgres.py все значения передаются как $1…$n, SQL — константы модуля src/messenger/*/infrastructure/postgres.py
«4» Ограниченный пул и таймауты make student-test PYTEST_ARGS="-v -k pool" 2 PASSED: пул из 1 занятого соединения → 503 за 0.3 с ожидания; на соединении statement_timeout = lock_timeout равны таймауту команды (в тесте задано 1.5 с, в стенде — 2 с) evidence/student-tests.txt
«4» Гонка регистрации одного username make test-faults (test_registration_race_yields_exactly_one_user) 50 параллельных POST /users → 201×1, 409×49, в users одна строка evidence/faults.txt
«4» Rollback составной операции make test-faults (test_chat_creation_rolls_back_on_unknown_member) 400 invalid_request; в chats и chat_members ноль строк evidence/faults.txt
«4» Индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥10 000 make explain 20 000 сообщений в чате, 30 005 всего; keyset-страница после 10 000-го — Index Scan using messages_history_idx, 51 строка, 4 буфера; OFFSET 10000 — 10 051 строка, 247 буферов; без индекса — Seq Scan всех 30 005 строк + сортировка, 505 буферов evidence/explain-history.txt
«4» Автотест expiry при коротком TTL make test-faults (test_short_ttl_session_expires, test_short_ttl_expires_after_restart_at_original_time) сразу 200, через 3 с 401 Bearer realm="messenger"; после рестарта api-shortttl токен всё равно 401 после исходного expires_at evidence/faults.txt
«4» Автотест logout make test-faults (test_logout_then_token_is_dead) 204 без тела, затем 401, повтор 401 evidence/faults.txt
«4» Автотест неверного пароля make test-faults неверный пароль и неизвестный username — одинаковый 401 Basic realm="messenger", charset="UTF-8", 0.012 с и 0.011 с evidence/faults.txt
«4» Недоступность Valkey: обход кэша, без анонимного доступа make test-faults (test_valkey_stopped_is_bypassed_but_logout_waits) действующий токен 200 за 0.207 с, неизвестный 401, ready 200, вход 201, выход 503, после старта — 204 evidence/faults.txt
«4» Недоступность PostgreSQL: ограниченная ошибка make test-faults (test_postgres_stopped_gives_bounded_503_and_recovers) ready, me, неизвестный токен, вход, регистрация — 503 за 0.992–1.012 с; live 200; после healthy PostgreSQL готовность 200 без рестарта API evidence/faults.txt
«5» трек 2 ≥100 000 сообщений с неравномерными чатами make track-bench база track: 999 993 сообщения в 1 000 чатах по Ципфу s = 1.3; крупнейший чат 284 708 (28.5 %), 50-й — 1 761, мельчайший — 36 evidence/track/bench.json, evidence/track/summary.txt
«5» трек 2 Сравнение ≥2 индексов и запросов, EXPLAIN (ANALYZE, BUFFERS) make track-bench 4 набора индексов × 3 чата × {первая, keyset 90 %, OFFSET 90 %} × {тёплый, холодный}, все запуски — custom-план; составной индекс + keyset — 0.012–0.024 мс и 4–6 буферов везде; (chat_id) — 12.2 мс и сортировка 284 709 строк на крупнейшем; (created_at, id) — 14.7 мс на мельчайшем: планировщик выбирает параллельный Seq Scan всей таблицы (25 704 буфера, 999 993 строки); OFFSET 90 % крупнейшего — 20–63 мс при любом индексе evidence/track/summary.txt, evidence/track/plans.txt
«5» трек 2 Custom против generic плана make track-bench при (created_at, id) generic-план для мельчайшего чата 156.5 мс против 14.9 мс custom (≈10 раз); при (chat_id) на крупнейшем 28.1 против 13.0 мс; при составном индексе планы совпадают (0.015–0.023 мс) evidence/track/summary.txt
«5» трек 2 Стоимость записи make track-bench (pgbench, 5 × 10 с на режим, docker stats в середине прогона, pg_stat_wal, контрольный повтор без индексов A-B-C-D-A) индекс истории 56.2 МБ против 6.8 МБ у (chat_id); каждый индекс — +1 запись WAL на вставку (6.03–6.06 → 7.03–7.06), +75–105 байт у одноколоночного и +133–161 у составного при sync; TPS ниже на 0.4–3.6 % при дрейфе первый/контрольный 1.0–1.2 %, то есть на уровне шума; postgres 266–359 % CPU, 183–190 МиБ evidence/track/bench.json, evidence/track/summary.txt
«5» трек 2 Backup → новое хранилище → сверка make track-recovery (3 повтора на размер) pg_dump -Fc 14.7 МБ за 1.04 с; каждый раз новый postgres-restore с новым volume; pg_restore 0.16 + 2.16 + 0.91 с (медианы); 13 из 13 проверок совпали во всех 6 восстановлениях (счётчики, md5 по чатам и истории, выборка ≈0.1 % строк — 90 и 1 005, миграции, индексы, ограничения) evidence/track/recovery.json
«5» трек 2 RTO и RPO make track-recovery для 100 011 и 999 993 сообщений RTO — медиана 2.17 с (2.17..2.26) и 5.32 с (5.31..5.35), из них новый экземпляр 1.26–1.30 с; 46–48 маркеров, записанных во время дампа 1M после его снимка, в копии отсутствуют — потеря равна всему, что после снимка evidence/track/recovery.json
Нагрузка с конкуренцией 64 make load-evidence (3 × tests/load.py --duration 8 --concurrency 64, снимки pg_stat_activity) медиана 1 676 RPS (1 619..1 711), p50/p95/p99 = 30/87/112 мс, 0 ошибок; на сервере 0×5xx; 81–86 % занятых соединений PostgreSQL ждут блокировку строки чата (Lock:tuple, Lock:transactionid); CPU api ≈1.6 ядра, postgres ≈1.5 evidence/load.txt, evidence/load-c64-{1,2,3}.json

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

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
Рестарт всего стека hook-ом scripts/restart.sh (api, postgres, valkey) прежний токен работает, история побайтно та же; после logout — 401 persistence-тест PASS, StartedAt всех трёх обновился; test_full_restart_keeps_session_until_logout: токен 200, выход 204, затем 401 API стартует через ≈1.6 с после хранилищ (healthy с опросом раз в 200 мс + migrate; до start_interval первая проверка ждала 5 с, и выходило ≈6 с); потерь нет
Рестарт только API (docker compose restart api) данные и сессии на месте, expires_at не меняется test_api_restart_keeps_session_without_extending_it: токен 200, expires_at в БД побайтно равен выданному при входе готовность через ≈0.5 с; потерь нет
Рестарт api-shortttl (TTL 2 с) до истечения сессии рестарт не продлевает срок после исходного expires_at токен 401 Bearer готовность через ≈0.5 с
SIGTERM в контейнер API с двумя запросами в работе принятый запрос дорабатывается, зависший прерывает сам сервер, остановка ≤10 с, код 0 дописанный запрос 201 через 1.15 с; недописанный воркер отменил через 7.24 с (500); остановка за 7.68 с, код 0 docker compose up -d --wait api
docker compose stop postgres live 200, ready и защищённые 503 быстрее 2 с, без 500 503 за 0.99–1.01 с (таймаут подключения и acquire 1 с), live 200 за 0.004 с после healthy PostgreSQL готовность 200 сразу, тот же процесс API; подтверждённые данные целы
docker compose stop valkey проверка уходит в PostgreSQL, никакого анонимного доступа действующий токен 200 за 0.207 с, неизвестный 401, ready 200, вход 201, выход 503. Время зависит от соединения в пуле воркера: на свежем соединении имя остановленного контейнера не резолвится и отказ мгновенный (0.007 с в отдельном прогоне), на зависшем — таймаут 0.2 с и один повтор (до 0.41 с); дальше размыкатель на 1 с после start выход снова 204; потерь нет
docker compose restart valkey кэш и отметки отзыва сохраняются (AOF) ключей 14 → 14, живой 200, отозванный 401 секунды; потерь нет
FLUSHALL в Valkey сессии не теряются, отозванные не оживают живой 200, отозванный 401, кэш заполняется заново мгновенно; потерь нет
Истечение TTL (api-shortttl, 2 с) 401 после expires_at сразу 200, через 3 с 401 Bearer —
Logout 204, затем 401, повтор 401 так и есть; в Valkey отметка - —
Сбой PostgreSQL посреди выхода: отметка записана, DELETE сессии падает 503, сессия цела и в БД, и для кэша 503 unavailable, ключа в Valkey нет, токен 200, повтор 204, затем 401 (до исправления: повтор 401, а после FLUSHALL токен снова 200) сразу после возвращения БД
Посторонний пишет в чужой чат, пока участник держит блокировку строки чата 404 сразу 404 быстрее 0.5 с (до исправления — 503 через lock_timeout 2 с) —
chunked-тело больше 1 MiB 413, тело не дочитывается 413 payload_too_large (до исправления тело читалось целиком и давало 400) —
50 параллельных регистраций одного username ровно один 201 201×1, 409×49, одна строка —
Чат с несуществующим участником 400, откат транзакции 400, ноль строк в chats и chat_members —
Пул исчерпан 503 за время acquire, без зависания 503 за 0.3 с, затем 200 мгновенно после освобождения
Повторный migrate схема и данные не меняются up to date, счётчики строк равны мгновенно
Потеря базы: backup → восстановление в новый postgres-restore (трек 2) все данные снимка на месте, всё после снимка потеряно 13/13 проверок совпали в 6 восстановлениях; 46–48 маркеров после снимка отсутствуют RTO 5.32 с (5.31..5.35) для 1M сообщений, 2.17 с для 100k; RPO — момент снимка pg_dump

Нагрузка HTTP

Гипотеза: запись в один горячий чат упирается в блокировку строки чата, а не в пул (4 × 8 соединений) и не в Argon2. Поэтому при 64 конкурентных клиентах большая часть занятых соединений PostgreSQL ждёт блокировку строки, ошибок и 503 нет, а p99 остаётся в пределах 0.2 с.

Методика (make load-evidence): закрытый контур tests/load.py, 64 потока, 8 с, все записи прогона в один чат (одна строка chats под FOR UPDATE), 3 повтора с паузой 40 с, клиент на хосте macOS, стенд — VM Docker Desktop 16 CPU / 7.65 ГиБ, 4 воркера API × пул 8. Прогрева нет: в окно попадают и регистрация пользователей, и создание чата из tests/load.py. На 4-й секунде снимаются docker stats и 20 снимков pg_stat_activity через 0.1 с: состояние и wait_event всех непростаивающих соединений базы messenger. Статусы ответов берутся из журнала request.handled. Других compose-стендов на VM во время прогона не было (строка в заголовке evidence/load.txt).

Результат: медиана 1 676 RPS (1 619..1 711), p50/p95/p99 = 30/87/112 мс, 0 ошибок из 40 696 запросов; на сервере только 201 и 200, ни одного 5xx. В среднем заняты 14.5–17.4 соединения PostgreSQL из 32, и 81–86 % из них ждут блокировку строки: Lock:tuple (очередь за FOR UPDATE) и Lock:transactionid (ожидание транзакции-держателя). На CPU в момент снимка — 0.5–0.7 соединения, на fsync WAL — до 0.3. CPU: api 162–165 %, postgres 138–157 %, valkey ≈5 %; память: api 254–280 МиБ, postgres 135–144 МиБ. Гипотеза подтверждена: ни CPU (16 ядер), ни пул не насыщены, очередь стоит на строке чата.

Разброс трёх прогонов серии — 5.5 %. Между сериями абсолютный RPS плавает сильнее: прошлая серия дала 1 724, повтор ревьюера при работающем рядом стенде лабы 3 — 1 639. Поэтому выводы опираются на отсутствие ошибок, p99 и долю ожиданий, а не на RPS. Прогон длиннее 8 с упирается в эфемерные порты macOS: клиент открывает новое соединение на каждый запрос (TIME_WAIT ≈14 000), поэтому между повторами пауза. Это пропускная способность HTTP-подтверждений одного горячего чата, а не предел системы.

Трек 5 — трек 2 «План запроса и восстановление»

Гипотезы. H1: составной индекс (chat_id, created_at, id) с keyset-курсором даёт время страницы, не зависящее ни от размера чата, ни от глубины страницы; (chat_id) проигрывает на большом чате (надо отсортировать весь чат), (created_at, id) — на маленьком (надо пройти чужие сообщения), а OFFSET проигрывает на глубине при любом индексе. H2: каждый индекс истории добавляет к вставке измеримую долю WAL и времени; составной индекс дороже (chat_id) на ширину ключа. H3: pg_dump -Fc + pg_restore -j поднимает миллион сообщений в новом хранилище за секунды, заметная доля уходит на перестройку индексов, а граница потери данных — момент снимка дампа.

Методика (scripts/track.py, scripts/sql/track-*.sql, одна команда на часть):

  • Стенд: Apple M4 Max, VM Docker Desktop 16 CPU / 7.65 ГиБ, PostgreSQL 17.11 с настройками образа (shared_buffers = 128MB, fsync и synchronous_commit включены). API в это время простаивает.
  • Данные: отдельная база track, мигрированная тем же runner-ом (python -m messenger.migrate track) — схема, ограничения и индекс те же, что у сервиса. 2 000 пользователей, 1 000 чатов по два участника, n_k = round(N · k^-1.3 / H), N = 1 000 000 (фактически 999 993): крупнейший чат 284 708 (28.5 %), топ-10 — 65 %, 50-й — 1 761, мельчайший — 36. Таблица messages — 200.8 МБ. Построение детерминировано.
  • Чтение: подготовленные запросы приложения с LIMIT 51; первая страница, keyset-страница после 90 % чата и та же страница через OFFSET; 5 тёплых запусков и 3 холодных (перед каждым все буферы базы вытесняются pg_buffercache_evict), медиана. Все запуски матрицы идут с plan_cache_mode = force_custom_plan: при auto шестое выполнение перешло бы на generic-план, и время, форма плана и строки одной ячейки относились бы к разным планам. Форма плана и «строк просмотрено» берутся из медианного запуска, plans.txt снят в том же режиме. «Строк просмотрено» — сумма по узлам Scan величины (Actual Rows + Rows Removed by Filter + Rows Removed by Index Recheck) × Actual Loops: PostgreSQL отдаёт обе величины как среднее на один цикл, и у параллельного узла их надо умножать на число процессов. Generic-план меряется отдельно: для первой страницы — 5 запусков в force_custom_plan и в force_generic_plan.
  • Запись: pgbench -c 4 -j 4, 5 прогонов по 10 с на режим, транзакция приложения (SELECT … FOR UPDATE, INSERT messages + UPDATE chats) в случайный из 1 000 чатов, UUIDv7; перед прогоном CHECKPOINT; WAL — разница pg_current_wal_lsn() в байтах и разница pg_stat_wal в записях WAL и full page images (FPI) на вставку. Режим sync — как в приложении, async — synchronous_commit=off, чтобы отделить обслуживание индекса от ожидания fsync. В середине прогона — docker stats контейнера postgres (в нём и сервер, и клиент pgbench). После прогона вставки удаляются. Наборы идут в фиксированном порядке, поэтому после составного набора запись ещё раз меряется без индексов истории (порядок A-B-C-D-A): если цифры повторного «без индексов» уходят от первого, это дрейф VM и рост PK, а не цена индекса.
  • Восстановление: во время дампа в источник каждые 20 мс пишется маркер; postgres-restore (профиль track) и его volume pgrestore удаляются и создаются заново, время нового экземпляра — up --wait до healthy, при старте pg_isready опрашивается раз в 200 мс (start_interval), так что шаг опроса добавляет не больше 0.2 с; pg_restore по секциям pre-data, data -j 4, post-data -j 4; затем одинаковые проверочные запросы в обеих базах. Начало и конец дампа — clock_timestamp() PostgreSQL-источника, теми же часами, что created_at маркеров, поэтому граница «после снимка» не зависит от часов хоста. Каждый размер — 3 повтора, медиана и диапазон.

Чтение, медиана тёплых запусков, мс (в скобках — холодный; полная матрица с буферами и планами — evidence/track/summary.txt и plans.txt):

Индексы истории Крупнейший: 1-я стр. Крупнейший: keyset 90 % Крупнейший: OFFSET 90 % 50-й чат: 1-я стр. Мельчайший: 1-я стр. Мельчайший: keyset 90 %
нет (только PK) 22.0 (19.8) 17.6 61.3 14.5 14.4 16.2
(chat_id) 12.2 (16.5) 8.3 55.8 0.19 0.024 0.016
(created_at, id) 0.035 (0.092) 0.065 63.1 3.1 14.7 (14.5) 6.6
(chat_id, created_at, id) 0.022 (0.036) 0.024 20.0 (33.4) 0.019 0.017 0.012

Буферы и строки холодного запуска. Составной индекс читает 4–6 буферов на любую keyset-страницу. Без индекса читается вся таблица: 25 698–25 704 буфера, 999 993 строки. (chat_id) на крупнейшем чате читает 7 606 буферов и сортирует 284 709 строк. (created_at, id) на мельчайшем чате тоже читает всю таблицу (25 704 буфера, 999 993 строки): зная по статистике, что чат маленький, custom-план выбирает параллельный Seq Scan с сортировкой, а не проход по индексу времени. Keyset-страница того же чата идёт через bitmap-скан индекса времени: 223 122 строки, 4 496 буферов. OFFSET 90 % по составному индексу читает 8 453 буфера и 256 288 строк, которые выбрасываются. Колонка «строк просмотрено» теперь считается по циклам (см. методику). В прошлой версии отчёта она складывала среднее «Rows Removed by Filter» один раз, и параллельный Seq Scan всей таблицы выглядел как 333 355–523 137 строк.

Custom против generic плана (asyncpg использует prepared statements, PostgreSQL после пяти выполнений может перейти на generic-план):

Индексы Чат custom, мс generic, мс Что меняется
(created_at, id) мельчайший 14.9 (параллельный Seq Scan + Sort) 156.5 (Index Scan по всему индексу времени) generic-план не знает, что чат маленький
(chat_id) крупнейший 13.0 (параллельная сортировка) 28.1 (последовательная) generic теряет параллелизм
(chat_id, created_at, id) крупнейший / мельчайший 0.023 / 0.021 0.022 / 0.015 план не зависит от параметра

Запись (медиана 5 прогонов, в скобках — минимум..максимум; строки в порядке прогонов, последняя — контрольный повтор без индексов истории):

№ Индексы истории Размер индекса, МБ TPS sync TPS async Задержка sync, мс WAL на вставку sync / async, байт Записей WAL на вставку FPI на вставку sync
1 нет — 9 455 (9 314..9 502) 12 681 (12 393..12 820) 0.423 1 511 / 1 205 6.70 / 6.05 0.128
2 (chat_id) 6.8 9 233 (7 941..9 604) 12 497 (10 743..12 721) 0.433 1 588 / 1 303 7.06 / 7.04 0.135
3 (created_at, id) 38.7 9 180 (9 055..9 540) 12 461 (12 429..12 626) 0.436 1 586 / 1 304 7.04 / 7.04 0.132
4 (chat_id, created_at, id) 56.2 9 113 (8 821..9 448) 12 444 (12 368..12 483) 0.439 1 644 / 1 365 7.03 / 7.04 0.146
5 нет (контроль) — 9 346 (9 279..9 601) 12 551 (12 437..12 612) 0.428 1 483 / 1 216 6.03 / 6.06 0.130

(chat_id) весит всего 6.8 МБ из-за дедупликации повторяющихся ключей в B-tree (PostgreSQL 13+); у составного индекса ключи уникальны. Первичный ключ после первого набора прогонов pgbench растёт с 30.1 до 37.8 МБ: удалённые вставки оставляют пустые страницы, VACUUM их не возвращает. CPU postgres — 266–282 % при sync и 306–359 % при async; память — 183–190 МиБ (один замер 282 МиБ в первом прогоне).

Восстановление в новое хранилище:

Набор 100 011 сообщений 999 993 сообщения
Размер pg_dump -Fc 1.6 МБ 14.7 МБ
Дамп 0.15 с (0.15..0.15) 1.04 с (1.03..1.05)
Новый экземпляр (пустой volume, initdb, healthy с опросом раз в 200 мс) 1.26 с (1.26..1.30) 1.27 с (1.27..1.27)
pre-data / data -j 4 / post-data -j 4 0.16 / 0.35 / 0.22 с 0.16 / 2.16 / 0.91 с
Сверка 0.19 с 0.84 с
RTO (экземпляр + восстановление + сверка), медиана [мин..макс] 2.17 с [2.17..2.26] 5.32 с [5.31..5.35]
Проверки: счётчики 4 таблиц, md5 «чат: число», md5 истории 3 чатов, выборка, миграции, индексы, ограничения 13 из 13 × 3 13 из 13 × 3
Маркеры: в источнике / в копии / записаны во время дампа после снимка и потеряны (медиана) 76 / 43 / 6 118 / 43 / 47

Выводы.

  • H1 подтверждена. Составной индекс с keyset — единственный вариант, где страница стоит 0.012–0.024 мс и 4–6 буферов и для чата из 36 сообщений, и для чата из 284 708, на любой глубине. (chat_id) хорош для маленьких чатов и в ≈550 раз хуже на большом (12.2 против 0.022 мс); (created_at, id) — зеркально: хорош на большом и в ≈860 раз хуже на маленьком (14.7 против 0.017 мс). Перекос размеров чатов делает оба одноколоночных индекса непригодными: в одном сервисе есть и те и другие чаты. OFFSET на 90 % большого чата стоит 20 мс даже с лучшим индексом — читает и выбрасывает 256 288 строк; keyset на той же глубине — 0.024 мс. Поэтому курсор приложения — keyset.
  • Находка про prepared statements: с (created_at, id) generic-план для маленького чата в ≈10 раз медленнее custom (156.5 против 14.9 мс). Приложение работает через asyncpg и после пяти выполнений могло бы получить именно его. С составным индексом план от параметра не зависит (0.015–0.023 мс в обоих режимах), и риска нет — ещё один довод за этот индекс.
  • H2 подтверждена для объёма и WAL; по времени эффект на уровне шума. Размер: составной индекс — 56.2 МБ против 6.8 МБ у (chat_id) и 38.7 МБ у (created_at, id). WAL: каждый индекс истории добавляет ровно одну запись WAL на вставку (6.03–6.06 без индекса → 7.03–7.06 с любым индексом, в обоих режимах) и 75–105 байт у одноколоночного или 133–161 байт у составного при sync; при async — 87–99 и 149–160 байт. Диапазон взят относительно первого и контрольного прогона без индексов. Составной дороже одноколоночных примерно на 60 байт: его ключ — 40 байт (uuid, timestamptz, uuid) против 16 и 24. Доля full page writes почти не меняется: 0.128–0.146 FPI на вставку при sync. TPS с индексом падает на 0.4–3.6 %: при sync 9 455 → 9 113 у составного (−3.6 % к первому прогону, −2.5 % к контрольному). Это того же порядка, что дрейф между первым и контрольным прогоном без индексов (−1.2 % и −1.0 %), и диапазоны пересекаются. Значит, направление эффекта ожидаемое (составной самый медленный), но величину по TPS эта VM не различает. Прошлая серия без контрольного повтора дала обратную картину: составной набор при async был на 20 % быстрее, чем без индексов. Скорее всего, это был дрейф VM, и как раз его ловит повтор A-B-C-D-A. Ещё одна оговорка: первый прогон без индексов дал 6.70 записей WAL при sync против 6.03 у контрольного, то есть состояние таблиц сразу после построения базы тоже весит. Цену индекса показывают размер и WAL; на чтении он выигрывает 2–3 порядка.
  • H3 подтверждена. Миллион сообщений поднимается в новом хранилище за 5.32 с (три повтора 5.31–5.35 с), 100 тысяч — за 2.17 с. Запуск пустого экземпляра (initdb, старт, первый успешный pg_isready) занимает 1.27 с: 24 % RTO для миллиона и 58 % для 100 тысяч. Перестройка индексов и ограничений (post-data) — 28 % времени pg_restore миллиона. От 100 тысяч к миллиону время данных выросло в 6.2 раза, post-data — в 4.1 раза, запуск экземпляра не изменился. Прошлая версия отчёта давала RTO 9.75 и 6.68 с и «5.8 с на запуск экземпляра». Из этих 5.8 с около 4.5 с были не PostgreSQL, а ожиданием первой проверки здоровья: без start_interval Docker ждёт 5 с до первого pg_isready. Теперь при старте проверка идёт раз в 200 мс. RPO дампа — момент его снимка: 46–48 сообщений, подтверждённых во время работы pg_dump после снимка, в копии отсутствуют, хотя дамп завершился позже них. Последний маркер копии записан за 1–16 мс до начала дампа по часам источника.
  • Решение по приложению: индекс (chat_id, created_at, id) и keyset-курсор остаются без изменений.

Ограничения трека. VM Docker Desktop шумит, поэтому сравниваются буферы, строки и порядки величин, а абсолютные миллисекунды — только внутри одного прогона. «Холодный» кэш — это пустые shared_buffers; кэш страниц ОС внутри VM не сбрасывается, реальное чтение с диска было бы медленнее. Для параллельных планов «строк просмотрено» считается по циклам: (Actual Rows + Rows Removed by Filter + Rows Removed by Index Recheck) × Actual Loops; строки, прочитанные и отброшенные внутри Sort или Limit, в ней не учтены. Влияние индекса на TPS при записи (0.4–3.6 %) того же порядка, что дрейф между первым и контрольным прогоном (1.0–1.2 %); наборы идут в фиксированном порядке, и один контрольный повтор не заменяет перемешивания. Синтетический текст хорошо сжимается, поэтому дамп в 14 раз меньше таблицы; на реальных сообщениях он будет больше и дольше. Восстанавливается синтетическая база track, а не рабочая messenger. pg_dump -d track не переносит роли и прочие глобальные объекты кластера: восстановление работает, потому что роль messenger в новом экземпляре создаёт POSTGRES_USER. Для настоящего кластера нужен ещё pg_dumpall --globals-only. Восстановленная база сверялась SQL-запросами, а не через API. RTO измерено на одной машине без переключения API на восстановленную базу: это ещё смена DATABASE_URL, рестарт API (≈1.6 с до готовности по evidence/persistence.txt) и make test. Время экземпляра включает шаг опроса healthy (до 0.2 с). Три повтора дают разброс 1–4 %, для доверительного интервала их мало. «Sync»-цифры записи сняты в VM Docker Desktop, где fsync подтверждает запись в виртуальный диск; дошла ли она до носителя хоста, не проверялось. pg_dump даёт RPO, равный интервалу между дампами; для RPO в секунды нужны pg_basebackup и архивирование WAL с восстановлением на момент времени (PITR) — здесь это только обсуждается.

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

Что подтверждает COMMIT и какие гарантии зависят от durability? COMMIT возвращается, когда запись транзакции в WAL сброшена на диск: при synchronous_commit = on сервер ждёт fsync (здесь wal_sync_method = fdatasync) до ответа клиенту, поэтому подтверждённые 201 переживают падение процесса и рестарт (make test-persistence). Настройки стенда — fsync = on, synchronous_commit = on, full_page_writes = on (evidence/environment.txt). С synchronous_commit = off подтверждённые транзакции последних ≈0.6 с (3 × wal_writer_delay) теряются при падении сервера, но база остаётся согласованной; с fsync = off при сбое ОС база может разрушиться; без full_page_writes — разорванные страницы после сбоя питания. Оговорка стенда: fsync в VM Docker Desktop подтверждает запись в виртуальный диск, а дойдёт ли она до носителя (на macOS это F_FULLFSYNC), решает гипервизор — это не проверялось. Коммит с fsync в треке стоит 0.42–0.44 мс против 0.32 мс без него, подозрительно дёшево для честного сброса на SSD, поэтому «sync»-цифры трека — нижняя граница цены durability, а не её значение на реальном сервере.

Где хранятся сессии и что будет после flush/restart Valkey? Источник истины — таблица sessions в PostgreSQL (только SHA-256 токена). Valkey хранит read-through копию и отметки отзыва "-". FLUSHALL теряет только кэш: живой токен 200 (заполнение заново из БД), отозванный 401 (строки в БД уже нет). Рестарт Valkey сохраняет ключи через AOF appendfsync always (14 → 14). Недоступный Valkey обходится, выход в это время отвечает 503 (evidence/faults.txt).

Чем аутентификация отличается от доступа к конкретному чату? Аутентификация отвечает на вопрос «кто это» — страж конвейера проверяет Bearer-сессию до маршрутизации и даёт 401 с WWW-Authenticate. Доступ (авторизация) отвечает на вопрос «можно ли ему этот чат» — зона messaging проверяет членство в chat_members: посторонний с действующим токеном получает 404, неотличимый от несуществующего чата, а не 403, и не узнаёт, что чат есть (test_outsider_* в evidence/student-tests.txt, make test). Запись постороннего не берёт блокировку строки чата и не ждёт участников.

Почему hash пароля и быстрый checksum решают разные задачи? Пароль выбирает человек, энтропии в нём мало, поэтому хеш должен быть медленным и требовать памяти (Argon2id m=19 MiB, t=2), чтобы перебор по утёкшей таблице стоил дорого. Токен сессии — 256 случайных бит, перебирать нечего, поэтому достаточно быстрого SHA-256: он лишь не даёт превратить утечку sessions в действующие токены. Checksum миграции (schema_migrations.checksum) — не защита от противника, а обнаружение изменения уже применённого файла.

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

  • Один Docker-host и один экземпляр PostgreSQL: потеря host или volume теряет всё после последнего дампа; репликации нет, резервная копия снимается вручную (make track-recovery показывает процедуру и RTO).
  • Истёкшие сессии удаляются только при следующем входе того же пользователя; фоновой очистки нет.
  • Запись в один горячий чат сериализуется блокировкой строки чата — цена строгого порядка истории.
  • Выход невозможен, пока недоступен Valkey (503): осознанная плата за то, что отзыв подтверждается только когда он виден и в кэше. Проверка остальных запросов при этом продолжается через PostgreSQL.
  • Нагрузка снята закрытым контуром tests/load.py с клиента на той же машине: согласованные пропуски, новое TCP-соединение на запрос (поэтому прогон ограничен 8 с), все записи в один чат. Это пропускная способность HTTP-подтверждений в одном горячем чате, а не предел системы.
  • Секреты лежат файлами в secrets/ на хосте (каталог 0700, файлы 0644, чтобы их читали непривилегированные пользователи контейнеров); это учебное упрощение вместо менеджера секретов.
  • Отзыв и PostgreSQL не связаны двухфазной фиксацией. Отказ БД при выходе снимает отметку в Valkey, но при неоднозначном COMMIT (сервер зафиксировал, ответ потерян) возможна гонка: чтение заполнит кэш, и токен проживёт в кэше до 300 с, хотя клиент получил 503 и повторит выход.
  • Запрос, который при SIGTERM не дождался своего тела за 7 с, отменяет uvicorn. Клиенту уходит встроенный текстовый 500 Internal Server Error, а не JSON-ошибка контракта: приложение к этому моменту уже отменено.
  • Процесс openspec: правило config.yaml «proposal в пределах 400 слов» нарушено в архивных циклах. Без разметки в add-lab2-postgres-sessions около 483 слов, в harden-lab2-after-review — около 409; wc -w с разметкой даёт 522 и 433, а у add-lab2-session-cache-and-resilience — 427. Архив уже закоммичен, а ЛР3 переносится с коммита 8cddb09, поэтому историю не переписываю. В proposal цикла harden-lab2-second-review 342 слова по wc -w.