Files
mtusi2026lab2/REPORT.md
T
alenchha 4ee3cbb4ea
Application / app (pull_request) Canceled after 0s
Skeleton contracts / contracts (pull_request) Canceled after 0s
Исправление по замечанию: отзыв сессии выдерживает гонку с наполнением кэша
2026-10-23 23:15:21 +03:00

54 KiB
Raw Blame History

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

  • Автор, группа: Курлова Алёна Алексеевна, БВТ2301
  • Целевая оценка; выбранный трек 5: 5, трек 2 «План запроса и восстановление»
  • Commit/PR: #68
  • Использованные источники, библиотеки и помощь ИИ: FastAPI 0.115.6, Uvicorn 0.34.0, psycopg 3.3.6 (+psycopg-pool), valkey-py 6.2.0, argon2-cffi 25.1.0 — документация перечисленных библиотек; документация PostgreSQL 17 (transactions, EXPLAIN, pg_dump/pg_restore, типы данных), Valkey persistence, RFC 7617, RFC 9106. Реализация, свои тесты и стенд эксперимента написаны с помощью ИИ-ассистента (Claude Code); все прогоны и доказательства выполнены автором. Отдельно просмотрены публичные ревью преподавателя к PR других студентов этой же лабораторной и проверено, закрыты ли названные там случаи в этой работе: сохранение NUL в тексте, отзыв сессии против возврата кэша, зависшая БД, тело запроса на входе, Unicode-пробелы. Четыре из них требовали правок, остальные уже работали; на каждый добавлен свой тест.

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

Нужны Docker (проверено 29.7.2) с плагином Compose (v5.5.1), make, Python 3.9+ на хосте (только для публичных и своих тестов) и свободный порт 8080. Образы закреплены по digest, Python-зависимости — по версиям в requirements.txt.

make bootstrap          # создаёт локальный .env и secrets/ (пароль генерируется на месте)
make up                 # build + postgres + valkey + миграции + api
curl -i http://localhost:8080/health/ready
make test               # публичный smoke
make test-custom        # свои проверки уровня 4

make bootstrap создаёт .env из .env.example и три файла в secrets/: postgres_password (случайный), database_url, cache_url. Каталоги secrets/, backups/ и .env закрыты .gitignore; в репозиторий попадают только пути к секретам, не значения.

Миграции применяет отдельный одноразовый сервис migrate (python scripts/migrate.py), от которого api зависит через service_completed_successfully. Повторный запуск (make migrate) печатает skip 0001_init и ничего не меняет: применённые версии и их sha256 лежат в таблице schema_migrations, при изменении уже применённого файла запуск падает с ошибкой. Выполняется под advisory lock, поэтому одновременный запуск двух runner-ов безопасен.

Все проверки и эксперименты одной командой — она пересоздаёт стенд с нуля и складывает вывод каждого шага в evidence/:

make evidence

Те же сценарии по отдельности:

make test-persistence ACTION_SCRIPT=scripts/restart.sh   # рестарт API и всех хранилищ
make expiry                                              # истечение сессии при TTL=2 с
make outages                                             # отзыв сессии против рестарта кэша, зависшая БД
make dependency                                          # отказ Valkey, затем отказ PostgreSQL
make explain                                             # план истории на таблице не меньше 10 000 сообщений
TOTAL=120000 make track2                                 # трек 5: индексы + backup/restore
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load-cache.json
# тот же прогон при остановленном Valkey даёт вторую точку сравнения:
docker compose --env-file .env stop valkey
python3 tests/load.py --duration 30 --concurrency 4 --output evidence/load-nocache.json
docker compose --env-file .env start valkey

Безопасная остановка: make down (том pgdata сохраняется, данные остаются). Намеренное удаление учебных данных: docker compose --env-file .env down -v — удаляет том базы вместе со всеми данными; дополнительно rm -rf backups/ удаляет локальные дампы. student-tests/track2.sh сам удаляет свой временный контейнер и том восстановления (KEEP=1 оставляет их для осмотра). TOTAL задаёт целевой размер истории: засев добивает таблицу до этого числа и при повторном запуске не добавляет ничего, поэтому прогоны воспроизводимы.

Переменные .env.example соответствуют реальной конфигурации: APP_HOST/APP_PORT/GRACEFUL_TIMEOUT читает команда uvicorn в Dockerfile, остальные — app/config.py. DATABASE_URL_FILE и CACHE_URL_FILE в контейнере указывают на docker secrets (/run/secrets/...), которые compose монтирует из secrets/.

Переменная Что задаёт Значение по умолчанию
SESSION_TTL_SECONDS срок жизни сессии 3600
SESSION_CACHE_TTL_SECONDS срок жизни записи в кэше сессий 30
SESSION_SWEEP_SECONDS период удаления истёкших сессий из БД 60
SESSION_REVOKED_TTL_SECONDS срок жизни надгробия отозванной сессии в кэше 60
SESSION_STORE источник истины для сессий postgres
DB_POOL_MIN, DB_POOL_MAX границы пула соединений 1, 10
DB_POOL_TIMEOUT, DB_CONNECT_TIMEOUT ожидание свободного соединения и подключения, с 3, 3
DB_STATEMENT_TIMEOUT_MS statement_timeout и lock_timeout на сервере 5000
DB_OP_TIMEOUT клиентский лимит на один SQL-запрос, с 6
DB_READY_TIMEOUT лимит проверки готовности БД, с 1.5
REQUEST_TIMEOUT потолок на обработку всего HTTP-запроса, с 8
CACHE_TIMEOUT таймаут на операцию с Valkey, с 0.2
MAX_INFLIGHT_REQUESTS одновременных запросов, сверх — 429 64
MAX_BODY_BYTES размер тела, сверх — 413 65536
MAX_RSS_MB лимит памяти процесса, сверх — 503 на запись (0 — выключен) 0

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

клиент → uvicorn/FastAPI (app/) ──► PostgreSQL 17.7  (источник истины: users, chats, chat_members, messages, sessions)
                                └─► Valkey 8.1       (кэш сессий с TTL, намеренно без persistence)
         migrate (одноразовый)  ──► PostgreSQL        (versioned SQL из migrations/)

Источник истины. Все обязательные данные и сессии лежат в PostgreSQL на томе pgdata. Valkey — кэш: он ускоряет проверку токена, но не хранит ничего, чего нет в базе. Поэтому потеря Valkey не теряет данные, а только замедляет работу; SESSION_STORE=postgres фиксирует это решение в конфигурации.

Кэш сессий намеренно без persistence. У Valkey выключены и RDB (--save ""), и AOF (--appendonly no). Это не упущение, а требование безопасности: если кэш переживает рестарт, он может воскресить запись об уже отозванной сессии и вернуть доступ по мёртвому токену. С volatile-кэшом после любого рестарта таблица сессий в PostgreSQL остаётся единственным источником правды, и каждый токен проверяется заново. Persistence кэша обязателен только если он единственное хранилище сессий — у нас это не так.

Отзыв сессии устойчив к кэшу и к гонке. DELETE /auth/sessions/current сначала пишет в Valkey надгробие — значение revoked с собственным TTL — и только потом удаляет строку из PostgreSQL. Простого удаления ключа недостаточно: между удалением ключа и удалением строки параллельный запрос успевает прочитать ещё живую строку и заново положить ключ, и тогда после подтверждённого 204 токен продолжает работать до истечения кэша. Надгробие закрывает это окно, потому что наполнение кэша после промаха выполняется условно (SET … NX) и не может перезаписать надгробие, а resolve трактует это значение как «сессии нет» без похода в базу. TTL надгробия не меньше суммы срока жизни кэша и потолка запроса, поэтому ни один начатый до отзыва запрос не успеет положить устаревшую копию. Если кэш недоступен, logout возвращает 503 и сессию не удаляет: выход не подтверждается, пока нельзя гарантировать, что кэш больше не отдаст токен. Проверено тестами logout_is_not_confirmed_while_cache_is_down и revoked_session_cannot_be_resurrected_by_a_race — второй удерживает строку сессии под SELECT … FOR UPDATE, чтобы гонка воспроизводилась детерминированно.

Схема и ограничения (migrations/0001_init.sql). users.username — UNIQUE плюс CHECK (username ~ '^[a-z0-9_]{3,32}$'), так что уникальность username гарантирует база, а не только проверка в коде. chat_members — таблица связи с PRIMARY KEY (chat_id, user_id) и внешними ключами на chats и users. messages ссылается на chats и users. sessions хранит token_hash bytea PRIMARY KEY, user_id, created_at, expires_at.

Почему текст хранится в bytea. display_name, title и messages.text — bytea с UTF-8 байтами, а не text. Причина: контракт разрешает в тексте любые Unicode code points, включая U+0000, а тип text в PostgreSQL физически не может содержать нулевой байт — попытка записи даёт invalid byte sequence for encoding "UTF8": 0x00, то есть 500 на валидном по контракту запросе. Хранение байтами даёт точный round-trip любой строки; длину в code points проверяет приложение (1..100 для имён и заголовков, 1..4000 для текста), а база дополнительно ограничивает octet_length. Цена решения — SQL-запросы к этим столбцам нельзя сравнивать как текст: в своих скриптах используются convert_to, position и encode, а не LIKE по convert_from (последний падает как раз на строках с NUL).

Транзакционные границы. Соединения работают в autocommit, то есть один запрос — одна транзакция. Явная транзакция открывается там, где составная операция должна быть атомарной: создание чата вставляет строку в chats и строки в chat_members одним BEGIN ... COMMIT. Участники добавляются INSERT ... SELECT u.id FROM users WHERE u.id = ANY(%s), и если вставилось меньше строк, чем запрошено, значит кто-то из member_ids не существует — поднимается исключение, транзакция откатывается, клиент получает 400, а в базе не остаётся чата без участников. Отправка сообщения — один оператор INSERT ... SELECT ... WHERE EXISTS (SELECT 1 FROM chat_members ...): проверка членства и запись атомарны, отдельного запроса на проверку доступа нет, посторонний получает 404 (0 строк).

Индекс истории. messages_history_idx (chat_id, created_at, id) повторяет порядок сортировки контракта, поэтому страница читается диапазонным сканом индекса без сортировки. Keyset-пагинация сравнивает кортеж: (created_at, id) > (:ts, :id). Цена страницы не зависит от её номера — измерения в разделе эксперимента.

Пагинация и курсор. Курсор перенесён из lab1: base64 от {scope, created_at, id}, где scope — messages:<chat_id> или chats:<user_id>. Курсор проверяется строго (формат времени с микросекундами, UUID, совпадение с заново закодированным значением), поэтому изменённый вручную курсор и курсор другого чата дают 400. Пустая строка в cursor или limit — это именно неверное значение, а не отсутствие параметра: такой запрос получает 400. Повторов и пропусков при обходе неизменной истории нет; snapshot между HTTP-запросами не гарантируется. Время ставит сервер (clock_timestamp(), микросекунды), порядок внутри одной микросекунды разводится по id.

Аутентификация. POST /api/v1/users принимает password (12–128 code points) и хеширует его Argon2id (argon2-cffi, time_cost=2, memory_cost=19456 KiB, parallelism=1). Хеширование и проверка выполняются в threadpool, чтобы KDF не блокировал event loop. POST /api/v1/auth/sessions принимает только Basic и не принимает тело: любой непустой body даёт 400. Вход выдаёт opaque-токен secrets.token_urlsafe(32) — 256 бит энтропии; в базу пишется только sha256(token), самого токена сервер не хранит. Остальные endpoint принимают только Bearer; Basic на них — 401 с WWW-Authenticate: Bearer, X-User-Id игнорируется полностью. Неверный пароль и несуществующий пользователь дают один и тот же 401: при отсутствии пользователя проверка выполняется против фиктивного хеша, чтобы ответ не отличался ни телом, ни временем. Повреждённый UTF-8 в теле или в Basic-строке не «исправляется» заменой символов, а отклоняется (400 и 401 соответственно).

Валидация входа. Тело читается потоком с лимитом MAX_BODY_BYTES (413), Content-Type обязателен (415 на любой другой), лишние и недостающие поля — 400. Некорректный JSON, в том числе битые числа (1e999, NaN), обрезанное тело и глубокая вложенность, вызывающая RecursionError, дают 400, а не 500. Обязательные строки не могут состоять только из пробельных символов, причём к пробельным приравнены и невидимые U+200B..U+200D, U+2060, U+FEFF.

Кэш сессий. Ключ session:<sha256-hex> — коллизий между пользователями быть не может, значение — публичные поля владельца токена, TTL = min(SESSION_CACHE_TTL_SECONDS, остаток до expires_at). Промах читает sessions JOIN users с условием expires_at > now() и снова наполняет кэш, причём публичный вид пользователя и при входе, и при промахе строит одна функция repo.public_user, поэтому тело ответа не зависит от того, откуда оно пришло. Сериализация значения выполняется до сетевого вызова: иначе ошибка сериализации попадала бы в тот же except, что и недоступность кэша, и выглядела бы как обычный сбой сети, хотя кэш при этом не наполнялся бы никогда. Истёкшие строки убирает фоновая задача раз в SESSION_SWEEP_SECONDS; TTL абсолютный, рестарт его не продлевает.

Пул и таймауты. AsyncConnectionPool с min_size=1, max_size=10, ожиданием свободного соединения 3 с, connect_timeout=3; на каждом соединении выставлены statement_timeout=5000, lock_timeout=5000, idle_in_transaction_session_timeout=10000. Серверных таймаутов недостаточно: если процесс БД заморожен, он не успеет их применить, поэтому каждый SQL-запрос дополнительно обёрнут клиентским лимитом DB_OP_TIMEOUT, а весь HTTP-запрос — потолком REQUEST_TIMEOUT в middleware. Соединение, на котором сработал клиентский таймаут, закрывается, чтобы пул заменил его, а не выдал следующему запросу. Все запросы параметризованы psycopg (%s), конкатенации пользовательских данных в SQL нет.

Деградация. OperationalError, InterfaceError, таймаут пула и клиентские таймауты превращаются в 503 unavailable с Retry-After — недоступность зависимости не маскируется под 500. /health/live отвечает 200, пока жив процесс; /health/ready выполняет SELECT 1 с отдельным лимитом и отдаёт 503, если база недоступна. Valkey в readiness не входит сознательно: без кэша сервис работоспособен. Ошибки кэша считаются в счётчике и логируются не чаще одного раза на 50 отказов.

Что перенесено из lab1: структура приложения и обработка ошибок, единый формат {"error":{code,message,request_id}}, X-Request-Id в каждом ответе, строгая валидация полей и курсора, потоковое чтение тела с лимитом (413), лимит одновременных запросов (429), graceful shutdown по SIGTERM с режимом drain, запуск от uid 10001.

Объявленные переходы относительно lab1: X-User-Id больше не аутентифицирует — вместо него Bearer-сессия; состояние ушло из памяти процесса в PostgreSQL, поэтому требование «ровно один процесс API» снято; счётчики MAX_USERS/MAX_CHATS/MAX_MESSAGES из lab1 убраны — они требовали бы COUNT(*) на каждый запрос, их роль теперь выполняют том базы и квоты СУБД; MAX_RSS_MB сохранён, но по умолчанию выключен (0), так как данные больше не живут в памяти.

Решения по инфраструктуре. Образы закреплены по digest: postgres:17.7-alpine@sha256:bb377b72…, valkey/valkey:8.1-alpine@sha256:081c2f5c…. У Valkey политика allkeys-lru и нет томов — это допустимо именно потому, что это кэш, а не хранилище истины. Пароль PostgreSQL и строки подключения передаются docker secrets, в environment лежат только пути к файлам. Порт API опубликован на 127.0.0.1:8080, внутрь контейнера сервер слушает 0.0.0.0 (иначе проброшенный порт не дошёл бы до процесса). CI (.github/workflows/app.yml) поднимает стек, проверяет повторный запуск миграций и гоняет smoke, свои тесты и persistence.

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

Окружение: Apple M4, 10 ядер, 16 ГБ RAM, Docker Desktop (лимит 10 CPU / 7.7 ГБ), macOS Darwin 25.6.0 arm64, Docker 29.7.2, Compose v5.5.1, PostgreSQL 17.7 (aarch64, musl), Valkey 8.1.10, образ API — python 3.12.8-slim, хост-Python 3.9.6, 2026-10-23. Полный состав стенда, версии и строка старта API с действующими лимитами — в evidence/stand.txt. Все числа ниже получены одним прогоном make evidence, начатым с удаления тома базы, поэтому относятся к одному и тому же состоянию стенда.

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab2 public API scenario evidence/smoke.txt
Данные и действующие сессии переживают рестарт API и хранилищ make test-persistence ACTION_SCRIPT=scripts/restart.sh (hook: docker compose restart postgres valkey api) PASS: persistence preserved confirmed data and existing session; тот же токен читает ту же историю evidence/persistence.txt (состояние контейнеров до и после, логи postgres о перезапуске)
PostgreSQL содержит users/chats/members/messages, есть PK/FK, уникальность username, миграции с нуля make up на пустом томе, затем make migrate apply 0001_init, повторный запуск — skip 0001_init; в schema_migrations одна версия с checksum 4fd0a8c6… evidence/migrations.txt (включая \d+ messages)
Составная операция создания чата атомарна test_storage_rules.py::unknown_member_rolls_chat_back 400 на неизвестного участника, чат в списке отсутствует evidence/level4-tests.txt
Basic только на POST /auth/sessions, остальное — Bearer; X-User-Id не даёт доступа test_auth_sessions.py 9/9 PASS, в том числе Basic на /users/me → 401 Bearer, вход с телом → 400, повреждённый UTF-8 → 400/401 evidence/level4-tests.txt
Срок жизни сессии и отзыв make expiry (TTL=2 с) 3/3 PASS: истёкший токен → 401, запись истёкшим → 401, expires_at соответствует TTL evidence/expiry.txt
Отозванная сессия не возвращается вместе с кэшом make outages 8/8 PASS; после 204 и restart valkey токен даёт 401 evidence/outages.txt
Отзыв сессии выдерживает гонку с параллельным запросом make outages::revoked_session_cannot_be_resurrected_by_a_race строка сессии удерживается SELECT … FOR UPDATE, параллельный /users/me наполняет кэш во время logout; после 204 токен даёт 401 на чтение и на список чатов evidence/outages.txt
Кэш наполняется после промаха, а не только при входе make outages::cache_is_repopulated_after_a_miss, ::cache_survives_its_own_restart после удаления ключа session:<sha256(token)> ответ 200 из PostgreSQL совпадает с кэшированным телом, ключ восстановлен с TTL; после рестарта Valkey кэш пуст и снова наполняется evidence/outages.txt
Пароли хешируются password KDF app/passwords.py, формат хеша в БД $argon2id$v=19$m=19456,t=2,p=1$…, в API пароль не возвращается evidence/level4-tests.txt
Любая строка Unicode сохраняется без искажений test_storage_rules.py::nul_and_unicode_text_round_trips, ::text_length_limit_counts_code_points a\u0000b, одиночный \u0000, emoji с ZWJ, комбинирующие и RTL, 4000 code points — 201 и точный round-trip; 4001 — 400 evidence/level4-tests.txt
Secrets/volumes не попадают в Git git status --porcelain, git check-ignore -v .env, secrets/, backups/ игнорируются; в рабочем дереве только код, тесты и evidence/ evidence/git-hygiene.txt
Redis/Valkey реально используется для сессий с TTL tests/load.py с кэшем и без него 1276.0 RPS / p95 4.34 мс против 498.2 RPS / p95 11.46 мс, failed_requests: 0 в обоих прогонах evidence/load-cache.json, evidence/load-nocache.json, evidence/load.txt
Параметризованные запросы, ограниченный пул и таймауты test_storage_rules.py целиком — 12/12 PASS, в том числе ::sql_injection_is_not_executed, ::content_type_is_required, ::broken_json_does_not_break_the_api; настройки в app/db.py SQL-пробы → 400, текст с кавычками сохраняется дословно, битый JSON → 400; пул 1..10, statement_timeout=5000, клиентский лимит 6 с, потолок запроса 8 с evidence/level4-tests.txt
Гонка регистрации одинакового username test_storage_rules.py::duplicate_username_race_creates_one_user (12 потоков) один 201, одиннадцать 409 evidence/level4-tests.txt
Индекс истории обоснован EXPLAIN на ≥10 000 сообщениях, пагинация без полного скана make explain (53 293 сообщения в таблице) keyset, первая страница: 24 буфера, 0.021 мс; keyset на глубине 90 %: 53 буфера, 0.032 мс; OFFSET той же глубины: 34 920 буферов, 4.48 мс (34 513 строк пройдено ради 50) evidence/explain-10k.txt
Проверка expiry, logout, неверного пароля и недоступности Redis/БД make dependency, make outages без Valkey 3/3 PASS (кэш обойдён, ошибок нет); без PostgreSQL 4/4 PASS: /health/ready 503, запись 503, неизвестный токен не становится доверенным; зависшая БД (pause) отвечает 503 быстрее 10 с evidence/dependency.txt, evidence/outages.txt
Переменные .env.example соответствуют реальной конфигурации make bootstrap на существующем .env, затем сверка ключей отсутствующие переменные дописываются из .env.example, расхождений по ключам нет evidence/stand.txt (строка cache_ttl в логе старта API)
Трек 5 (трек 2): ≥100 000 сообщений, ≥2 индекса, цена записи, backup → restore → сверка TOTAL=120000 make track2 120 000 сообщений в 68 чатах; варианты A/B/C сравнены; md5 истории источника и копии совпали; маркер после бэкапа в копии отсутствует evidence/track2/run.txt

Проверка инфраструктурного hook: scripts/restart.sh выполняет docker compose --env-file .env restart postgres valkey api, то есть перезапускаются и API, и PostgreSQL, и Valkey; тома не удаляются. Подтверждение — состояние контейнеров до и после в evidence/persistence.txt (у всех трёх сервисов новое время старта) плюс строки database system was shut down → database system is ready to accept connections в логах postgres из того же файла.

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

Трек 2, часть 1: план запроса и цена индекса

Гипотеза. Для keyset-пагинации по контракту (ORDER BY created_at, id внутри одного чата) составной индекс (chat_id, created_at, id) даёт цену страницы, не зависящую от её глубины, а индекс только по chat_id вынуждает поднимать из heap всю историю чата на каждую страницу. Покрывающий индекс с INCLUDE (sender_id, text) должен убрать обращения к heap, но увеличить размер индекса и цену записи.

Методика. Стенд описан выше, PostgreSQL запущен с shared_buffers=128MB, work_mem=8MB, track_io_timing=on. Данные: student-tests/seed.sql добивает историю до заданного размера, распределяя сообщения по 50 чатам с перекосом power(random(), 3); поверх лежат чаты публичного smoke, своих тестов и нагрузочных прогонов. В этом прогоне засев дописал 66 707 строк до ровно 120 000 сообщений в 68 чатах. Размеры чатов неравномерны: 38 293 строки в самом большом, 14 955 во втором, затем 25, 5 и 3 — разброс в четыре порядка. Точка измерения — страница на глубине 90 % истории самого большого чата. Каждый вариант индекса создаётся внутри транзакции и откатывается (BEGIN … ROLLBACK), поэтому рабочая схема не меняется и порядок вариантов не влияет на результат. Для каждого варианта снимаются: план EXPLAIN (ANALYZE, BUFFERS) одной страницы, время 100 последовательных страниц с разными курсорами (коррелированный LATERAL: без зависимости от номера итерации планировщик выполняет подзапрос один раз и измерение обнуляется — так и произошло в первой версии скрипта), размер индекса и время вставки 10 000 строк при этом наборе индексов. Прогрев: засев и ANALYZE выполняются до измерений, кэш БД тёплый.

Вариант индекса План страницы на глубине 90 % Буферы Время одной страницы 100 страниц Размер индекса Вставка 10 000 строк
A (chat_id, created_at, id) — рабочий Index Scan using messages_history_idx 53 0.047 мс 1.08 мс 11 МБ 0.085 с
B (chat_id) Bitmap Heap Scan + Sort, Rows Removed by Filter: 34 464 510 2.06 мс 2529 мс 856 кБ 0.081 с
C (chat_id, created_at, id) INCLUDE (sender_id, text) Index Only Scan, Heap Fetches: 0 4 0.027 мс 0.73 мс 14 МБ 0.086 с

Что наблюдали. Вариант B на каждой странице поднимает из heap почти весь чат и отбрасывает фильтром 34 464 строки ради 50 нужных; на серии из 100 страниц он медленнее A примерно в 2350 раз (2529 мс против 1.08 мс), и отставание растёт вместе с размером чата, а не фиксировано. Вариант C не ходит в heap вообще (Heap Fetches: 0, 4 буфера против 53) и на серии страниц быстрее A примерно на треть (0.73 мс против 1.08 мс); по одной странице времена A и C различать нельзя — 0.047 и 0.027 мс лежат в пределах разброса единичного замера, поэтому вывод делается по серии и по числу буферов. Цена C — индекс 14 МБ против 11 МБ; разницы во времени вставки между A и C на этих данных не видно (0.086 с против 0.085 с). B пишет быстрее всех (0.081 с) просто потому, что его индекс меньше.

Вывод. В схему взят вариант A: постоянная цена страницы при умеренном размере индекса. C даёт измеримый выигрыш по буферам и по серии страниц и остаётся кандидатом, если история читается существенно чаще, чем пишется; прежде чем переключаться, его цену записи нужно перемерять на длинных текстах, где дублирование текста в индексе должно проявиться. Переключение — одна миграция.

Трек 2, часть 2: бэкап и восстановление в новое хранилище

Гипотеза. pg_dump -Fc даёт согласованный снимок на момент начала дампа; восстановление в чистое хранилище воспроизводит данные точно, а всё подтверждённое после снимка теряется — это и есть граница потери данных при такой схеме бэкапа.

Методика. student-tests/track2.sh: снимок pg_dump -Fc → запись маркерного сообщения уже после дампа → поднятие отдельного контейнера PostgreSQL 17.7 на новом томе mtusi-lab2-restore-data с новой базой messenger_restored → pg_restore --exit-on-error → сверка. Сверяются количество строк в каждой таблице, количество строк и md5 конкатенации (id, created_at, encode(text,'hex')) в порядке (created_at, id) для самого большого чата, первые три сообщения этого чата и наличие маркера. Сверка идёт по encode, а не по convert_from, потому что в истории есть сообщения с реальным NUL — на них перевод bytea в text падает. Время бэкапа и восстановления снимается внешним таймером с точностью до миллисекунды и включает накладные расходы docker exec.

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
pg_dump -Fc базы с 120 000 сообщений согласованный дамп файл 5.7 МБ бэкап 0.743 с
pg_restore в новый том и новую базу совпадение количества и содержимого users 78/78, chats 68/68, chat_members 1036/1036, messages 120 000/120 000, sessions 45/45; md5 истории большого чата (38 293 строки) f18725746ed1acbdda044e804cdc4c7c в обеих базах; первые три сообщения совпали восстановление 0.354 с; потерь на момент снимка нет
Запись после снимка (маркерное сообщение) в копии отсутствует в источнике 1 маркер, в восстановленной копии 0 потеряно всё, подтверждённое после начала дампа
Рестарт API и обоих хранилищ с сохранением томов данные и действующая сессия живы PASS публичного persistence-теста: тот же токен читает ту же историю, дублей нет простой до readiness < 10 с, потерь нет
Остановка Valkey под нагрузкой кэш обходится, ошибок нет 498.2 RPS против 1276.0 RPS, p95 11.46 мс против 4.34 мс, failed_requests: 0 потерь нет, деградация по скорости ×2.6
Остановка PostgreSQL ограниченная ошибка, доверия нет /health/ready 503, регистрация 503, неизвестный токен → 503/401, анонимный → 401, /health/live 200 запись недоступна полностью до возврата БД
Заморозка PostgreSQL (docker compose pause) быстрый 503, а не зависший запрос 503 быстрее 10 с при потолке запроса 8 с; после unpause доступ восстановился потерь нет
Рестарт Valkey после подтверждённого logout отозванный токен остаётся мёртвым 401 после рестарта кэша потерь нет
Гонка logout и параллельного чтения подтверждённый отзыв нельзя отменить наполнением кэша до правки токен жил ещё 30 с после 204; после правки — 401 сразу потерь нет
Неудавшийся logout при замороженной базе кэш не отказывает сессии, которая ещё жива в базе 503 клиенту, надгробие снято, ответ API совпадает с наличием строки в базе потерь нет
Удаление ключа сессии из кэша ответ из PostgreSQL совпадает с кэшированным, ключ восстановлен с TTL тело идентично, EXISTS = 1, TTL 30 с потерь нет

Нагрузочный профиль (для контекста, не доказательство ёмкости): tests/load.py, closed loop, concurrency 4, длительность 30 с, по одному прогону на точку. С кэшем: 38 293 успешных POST, 0 ошибок, 1275.960 RPS, p50 2.933 / p95 4.335 / p99 7.548 мс. С остановленным Valkey: 14 955 успешных POST, 0 ошибок, 498.216 RPS, p50 7.457 / p95 11.462 / p99 14.472 мс. Разница — цена похода в PostgreSQL за сессией на каждом запросе; ноль ошибок в обоих прогонах показывает, что отказ кэша обходится, а не ломает запись. Это пропускная способность HTTP-подтверждений, а не счётчик COMMIT: закрытый контур страдает coordinated omission, клиент и сервер работают на одной машине, поэтому абсолютные числа занижены относительно отдельного стенда.

Ограничения измерений. Всё измерено на одной машине, с тёплым кэшом БД, по одному прогону на точку, без фиксации частоты CPU и без контроля троттлинга; потребление CPU и RAM по контейнерам не снималось. По одной странице времена вариантов A и C неразличимы, поэтому для них опорой служат серия из 100 страниц и число буферов. Размер индекса измеряется внутри откатываемой транзакции, поэтому при повторных запусках скрипта к индексу добавляются мёртвые записи до VACUUM — сравнивать размеры корректно только внутри одного прогона. Два самых больших чата сформированы нагрузочными прогонами, поэтому тексты в них короткие и однотипные: на длинных текстах разрыв между A и C по размеру индекса и цене записи будет больше. Прогон без кэша выполнялся на уже подросшей таблице, поэтому отношение RPS показывает направление и порядок эффекта, а не точный коэффициент. Числа p50/p95/p99 относятся только к успешным запросам.

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

Какие отказы выдерживаются. Перезапуск API, PostgreSQL и Valkey с сохранением томов: подтверждённые данные и ещё действующие сессии остаются, TTL не продлевается, а уже отозванные сессии не оживают. Полная потеря Valkey: сервис продолжает работать, читая сессии из PostgreSQL, цена — падение пропускной способности примерно в 2.6 раза. Потеря соединения с БД: запросы получают 503 с Retry-After, пул переподключается сам, readiness честно показывает недоступность. Заморозка БД: клиентский лимит и потолок запроса не дают запросу зависнуть.

Какие отказы не выдерживаются. PostgreSQL — единственная точка истины без реплики: при потере тома pgdata данные восстанавливаются только из дампа, то есть теряется всё после последнего pg_dump. WAL-архивирование и PITR не настроены, непрерывного бэкапа нет. API — один экземпляр, балансировщика нет (это тема lab3), поэтому его перезапуск — простой сервиса, а не бесшовное переключение. Rate limiting по пользователю и HTTPS в объём lab2 не входят.

Учебные упрощения. Кэш сессий намеренно volatile: это снимает риск воскрешения отозванной сессии, но после каждого рестарта Valkey первые запросы идут в базу. Logout при недоступном кэше возвращает 503 и не отзывает сессию — выход нужно повторить; альтернатива (удалить строку в БД и надеяться, что кэш очистится) давала бы окно, в котором мёртвый токен работает. Надгробие живёт в кэше дольше самой записи о сессии — это сознательная плата за то, чтобы отзыв нельзя было отменить гонкой. Если удаление строки в базе не удалось, надгробие снимается обратно, поэтому кэш не отказывает сессии, которая в базе ещё существует. При этом клиентский таймаут не означает, что запрос не выполнился: после 503 исход отзыва честно неизвестен, и оба ответа на следующий запрос этим токеном законны. Тест failed_logout_leaves_cache_and_database_consistent поэтому проверяет не конкретный код ответа, а согласованность: смотрит, есть ли строка сессии в базе, и требует от API ровно соответствующего ей ответа. Параметры Argon2id (19 МБ, t=2, p=1) выбраны по RFC 9106 как второй рекомендуемый профиль и снижены относительно умолчаний библиотеки (64 МБ), чтобы одновременные входы не съедали память контейнера. Хранение текста в bytea усложняет SQL-запросы к этим столбцам — это осознанная цена за точный round-trip Unicode. Данные экспериментов (load_* пользователи, load chat *) лежат в той же базе, что и smoke-данные: отдельного стенда для экспериментов нет, поэтому два самых больших чата в выборке — это чаты нагрузочных прогонов.

Что подтверждено, а что пока гипотеза. Подтверждено измерениями: постоянная цена keyset-страницы на 120 тысячах сообщений, деградация варианта B на глубине примерно в 2350 раз, выигрыш покрывающего индекса по буферам (4 против 53) и по серии страниц, выигрыш кэша сессий по RPS и p95 при нулевом числе ошибок, полное совпадение восстановленной копии с источником и отсутствие в ней записей, подтверждённых после снимка, корректная деградация при остановке и при заморозке каждого из хранилищ, устойчивость отзыва сессии к рестарту кэша. Гипотезы, не проверенные здесь: что покрывающий индекс C дороже в записи — на этих данных разница с A укладывается в шум (0.086 с против 0.085 с), и проверять это нужно на текстах, близких к 4000 символов; что C окажется выгоднее на холодном кэше и при большом числе параллельных читателей; что max_size=10 в пуле — оптимум (значение взято с запасом под max_connections=50, но под нагрузкой не подбиралось).

Следующие шаги. Настроить WAL-архивирование и проверить PITR с восстановлением на момент времени; добавить реплику PostgreSQL и измерить переключение; подобрать DB_POOL_MAX и профиль Argon2id под целевой p95; перенести эксперименты на отдельную базу; в lab3 добавить балансировщик и идемпотентность записи.

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

  • Что подтверждает COMMIT и от какой настройки durability это зависит. COMMIT подтверждает, что изменения записаны в WAL и сброшены на диск, поэтому после аварии они будут восстановлены. Зависит от synchronous_commit (у нас on) и fsync (включён): при synchronous_commit=off ответ клиенту приходит раньше фактического fsync, и последние транзакции можно потерять при потере питания.
  • Где хранятся сессии и что будет после flush/restart Valkey. Источник истины — таблица sessions в PostgreSQL; в Valkey только кэш с TTL и без persistence. После FLUSHALL или рестарта Valkey сессии продолжают работать: первый запрос промахивается, читает строку из базы и снова наполняет кэш. Важнее обратное: именно потому, что кэш не переживает рестарт, отозванная сессия не может вернуться вместе с кэшом — это проверено тестом.
  • Чем аутентификация отличается от доступа к конкретному чату. Аутентификация отвечает на вопрос «кто это»: действителен ли Bearer-токен и не истёк ли он; её провал — 401. Доступ отвечает на вопрос «можно ли этому пользователю именно этот чат»: есть ли строка в chat_members; её провал — 404, а не 403, чтобы не раскрывать существование чужого чата.
  • Почему hash пароля и быстрый checksum решают разные задачи. Пароль человек выбирает из небольшого множества, поэтому его хеш должен быть намеренно медленным и требовательным к памяти (Argon2id), чтобы перебор был дорогим. Токен сессии — 256 случайных бит, перебирать его бессмысленно, поэтому для него достаточно быстрого SHA-256: он нужен лишь для того, чтобы в базе не лежал сам токен и утечка таблицы не давала доступа.
  • Почему текст лежит в bytea, а не в text. Потому что контракт разрешает любые Unicode code points, а text в PostgreSQL не может содержать U+0000: такой запрос либо падает с 500, либо строку приходится молча портить. Байты сохраняют её точно, а длину в code points проверяет приложение.