54 KiB
Отчёт — лабораторная 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 проверяет приложение.