Files
mtusi2026lab2/REPORT.md

40 KiB
Raw Permalink Blame History

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

  • Автор, группа: Боданюк Алексей, БВТ2302
  • Целевая оценка: 5, трек 2 «План запроса и восстановление»
  • Ветка: solution/bvt2302-bodanyuk. Форк: https://gitea.privcloud.tech/wfa/mtusi2026lab2. PR: «ЛР 2 — БВТ2302 — Боданюк — на 5» в mtusi2026/mtusi2026lab2
  • Стек: Python 3.13.16, Starlette 1.7.0, uvicorn 0.54.0, psycopg 3.3.6 + psycopg-pool 3.3.3, redis-py 8.1.0 (протокол Valkey), argon2-cffi 25.1.0; PostgreSQL 18.6, Valkey 8.1.3. Все образы закреплены по тегу и digest, все Python-пакеты — по хешам (requirements.txt)
  • Источники: README, COURSE, контракт (openapi.json, семантика), документация PostgreSQL (transactions, EXPLAIN, pg_dump/pg_restore, pgbench), Valkey persistence, RFC 7617, OWASP Password Storage Cheat Sheet (параметры Argon2id). Учтены замечания преподавателя к PR других студентов этого репозитория (см. раздел «Проверки, на которых ловили другие работы»)
  • Помощь ИИ: код, тесты, скрипты эксперимента и черновик отчёта написаны с помощью ИИ-ассистента Claude Code (Anthropic). Все команды и замеры реально выполнены на стенде ниже, их вывод лежит в evidence/. Пояснения для защиты — docs/DEFENSE.md, запуск на Windows и сценарий защиты по шагам — docs/WINDOWS.md

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

Нужны Git, Docker с Compose v2 (проверено: Docker 29.8.0, Compose 5.5.1) и Python 3.9+ (secrets, публичные тесты). Для своих тестов нужен venv. Учётные данные не хранятся в Git: их создаёт скрипт.

git clone https://gitea.privcloud.tech/wfa/mtusi2026lab2 mtusi2026lab2 && cd mtusi2026lab2 && git checkout solution/bvt2302-bodanyuk
python3 scripts/init_secrets.py           # случайные локальные пароли -> ./secrets (git-ignored), идемпотентно
cp .env.example .env                      # необязательно: значения по умолчанию заданы в compose.yaml
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait   # postgres+valkey healthy -> migrate -> api healthy
curl -i http://127.0.0.1:8080/health/ready             # 200 {"status":"ok"}; Swagger: http://127.0.0.1:8080/docs
make check && make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
  • Миграции: выполняет одноразовый сервис migrate (python -m messenger.migrate) перед стартом api. Повторный запуск: docker compose run --rm migrate → 0001_init: already applied, skipped.
  • Свои тесты: python3 -m venv .venv, затем pip install --require-hashes --no-deps -r requirements.txt и pip install -r requirements-test.txt, затем make student-test. Все тесты — около 3,5 мин. Те, что не требуют стенда: make unit-test.
  • Windows без make: цели Makefile — однострочные команды. Перед публичными тестами нужно $env:PYTHONUTF8=1. Hook сохранности на Windows — scripts/restart.cmd: он запускает тот же restart.sh через Git Bash, потому что Windows не исполняет .sh напрямую.
  • Остановка: безопасно — docker compose down (volumes сохраняются). Намеренное удаление учебных данных — docker compose down -v и rm -rf secrets. После этого стенд поднимается с нуля той же последовательностью.

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

клиент ──HTTP──> api (uvicorn+Starlette, 1 процесс, пользователь app, PID 1)
                  ├─ PostgreSQL 18.6  — источник истины: users, chats, chat_members, messages (volume pgdata)
                  └─ Valkey 8.1.3     — единственное хранилище сессий, AOF appendfsync always (volume valkeydata)
migrate (одноразовый) ──> PostgreSQL: версионированные SQL-миграции, advisory lock, checksum
Роль Service Образ Health / readiness Volume Сеть / порт Credentials
API api mtusi-messenger:lab2 (собирается из исходников) HEALTHCHECK → /health/ready — 127.0.0.1:8080→8080 secrets database_url, cache_url
БД postgres postgres:18.6-bookworm@sha256:afc7e2d4… pg_isready pgdata только внутренняя secret postgres_password
Сессии valkey valkey/valkey:8.1.3-bookworm@sha256:fea8b3e6… valkey-cli ping valkeydata только внутренняя secret valkey_password → include-файл конфига (не в аргументах процесса)
Миграции migrate тот же образ API завершение с кодом 0 — внутренняя secret database_url
  • Модель данных и транзакции — docs/DATA_MODEL.md, схема — migrations/0001_init.sql.

    • PK, FK (в том числе messages (chat_id, sender_id) → chat_members: отправитель обязан быть участником), UNIQUE (username), CHECK.
    • Свободный текст хранится в bytea, потому что контракт разрешает U+0000, а text в PostgreSQL его не хранит.
  • Создание чата — одна транзакция: INSERT chats → INSERT chat_members из unnest(member_ids). Неизвестный участник ломает второй INSERT по FK, и откатывается всё, включая уже вставленный чат.

  • Порядок сообщений. UPDATE chats SET last_message_at = greatest(clock_timestamp(), last_message_at + 1 мкс) … RETURNING блокирует строку чата до COMMIT. Поэтому писатели одного чата идут по очереди, а время строго растёт в порядке коммитов. Это перенос инварианта lab1 («время назначается под замком») в БД.

  • Пагинация — тот же keyset-cursor, что в lab1, но в SQL: (created_at, id) > ($2,$3) по индексу (chat_id, created_at, id). Запросов два — первая страница и после cursor, без IS NULL OR. Cursor проверяет диапазон времени (до 9999 года): дата вне диапазона даёт 400, а не 500.

  • Аутентификация (authhdr.py, sessions.py, passwords.py):

    • Basic принимается только на POST /auth/sessions. Любой битый заголовок (не base64, не UTF-8, без :) даёт 401, пароль может содержать :;
    • пароль: 12–128 code points, не из одних пробелов; Argon2id (m=19 MiB, t=2, p=1) считается в отдельном потоке с ограничением параллельности 2;
    • неизвестный пользователь проверяется против фиктивного хеша: время и ответ такие же, как при неверном пароле;
    • токен — token_urlsafe(32) (256 бит), хранится только SHA-256 токена;
    • X-User-Id и Basic на бизнес-endpoint дают 401 с WWW-Authenticate: Bearer realm="messenger".
  • Сессии — роль Valkey (уровень 4). Источник истины для сессий — Valkey, и это не кэш над PostgreSQL. Значение ключа — {user_id, expires_at}, срок — абсолютный PXAT.

    • Expiry: expires_at проверяется при каждом чтении; рестарт срок не продлевает.
    • Инвалидация: logout = DEL.
    • Persistence: appendonly yes, appendfsync always, maxmemory-policy noeviction — подтверждённые вход и logout переживают рестарт и падение, а сессии не вытесняются молча.
    • Отказ Valkey: проверить сессию нельзя → 503 на защищённые запросы и на logout; анонимный доступ никогда не открывается.

    Копия одна, поэтому нет сценария «logout потерялся в кэше и токен ожил». Переменная SESSION_STORE=postgres переключает сессии на таблицу sessions (проверено тестами и hook сохранности).

  • Ограничения ресурсов (db.py):

    • пул psycopg: min 1, max 10, ожидание соединения ≤ 3 с;
    • сервер: statement_timeout = 2,5 с, lock_timeout = 1,25 с, idle_in_transaction_session_timeout = 10 с;
    • клиентский дедлайн 3 с. Он работает в отдельной задаче: при замороженном PostgreSQL (docker pause) psycopg после отмены ещё до 10 с ждёт ответа на cancel. Без этого ответ приходил через 13 с, с этим — через 3,0 с;
    • Valkey: таймауты сокета 0,5 с, без скрытых повторов;
    • все отказы зависимостей → 503 unavailable.
  • Readiness — 200, только если отвечают PostgreSQL и Valkey (обе зависимости критичны для обязательного пути). Liveness — только жизнь процесса.

  • Из lab1 перенесено без изменений: формат ошибок и X-Request-Id, строгая валидация JSON (лишние поля, типы, NaN, суррогаты, склеенные объекты), JSON-логи без тел и текстов, graceful SIGTERM (≤ 8 с, readiness 503), Swagger. Изменено: хранилище, идентификация, cursor — с проверкой диапазона. Перенос сделан отдельным коммитом 893beaa.

Соответствие .env.example реальной конфигурации (config.py, compose.yaml):

Переменная Значение Где используется
APP_HOST, APP_PORT, APP_ENV 0.0.0.0, 8080, lab bind uvicorn, стартовый лог
SESSION_TTL_SECONDS 3600 срок сессии; compose передаёт его в контейнер (проверено printenv в тесте TTL=2)
DATABASE_URL_FILE /run/secrets/database_url строка подключения из secret-файла
SESSION_STORE valkey (или postgres; redis — синоним valkey) выбор хранилища сессий
CACHE_URL_FILE /run/secrets/cache_url адрес и пароль Valkey из secret-файла
DB_POOL_MIN/MAX, DB_TIMEOUT_SECONDS, CACHE_TIMEOUT_SECONDS, PASSWORD_HASH_CONCURRENCY 1/10, 3, 0.5, 2 пул и таймауты, параллельность Argon2id
LOG_LEVEL, DOCS_ENABLED, APP_PUBLISH_PORT info, true, 8080 логи, Swagger, порт на хосте (только 127.0.0.1)

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

Стенд: Windows 10 22H2, AMD Ryzen 5 3400G (4 ядра / 8 потоков), 16 ГБ RAM, Docker Desktop 29.8.0 (WSL2), дата 2026-10-12. Все проверки уровней 3 и 4 ниже выполнены на стенде, поднятом из чистого clone с пустыми volumes (отдельный compose-проект на порту 8081).

Критерий README Команда / сценарий Наблюдаемый результат Файл
Чистый clone, secrets, миграции с нуля init_secrets.py, compose up --build --wait, compose logs migrate, повтор run migrate все сервисы healthy; 0001_init: applied, повтор — already applied, skipped; uid 10001, PID 1; secrets/ и .env игнорируются Git clean-clone.txt
Контракт make check, make validate PASS, PASS make-check-validate.txt
3: публичный smoke make test PASS: lab2 public API scenario make-test.txt
3: данные и сессии переживают рестарт API и хранилищ make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS; StartedAt api, postgres, valkey изменились, volumes те же test-persistence-valkey.txt, restart-hook-output.txt
то же для SESSION_STORE=postgres тот же тест после SESSION_STORE=postgres compose up -d api PASS, сессии в таблице sessions test-persistence-postgres.txt
3: PK/FK, unique username, миграции с нуля 0001_init.sql, test_migrations_rerun_is_a_noop схема применяется к пустому volume; повтор ничего не меняет student-tests.txt
3: атомарное создание чата test_create_chat_rolls_back_after_the_chat_row_was_inserted n_tup_ins таблицы chats вырос (INSERT был), строки нет, членство не изменилось там же
3: Basic только на входе, Bearer, expiry, отзыв, X-User-Id не даёт доступ, KDF test_api.py (18 проверок аутентификации), test_short_ttl_expires, test_secrets_are_not_stored_in_plain_text 401 с нужным challenge; logout → 401; TTL=2 → 401; хеш $argon2id$v=19$m=19456,t=2,p=1$; в Valkey только session:<sha256> там же
3: secrets и volumes не в Git git check-ignore secrets/database_url .env оба игнорируются; в отчёте и evidence нет паролей и токенов clean-clone.txt, logs-check.txt
4: Valkey реально хранит сессии с TTL и persistence test_logout_during_valkey_outage_is_never_lost, test_restart_does_not_extend_ttl, persistence-тест сессии переживают рестарт Valkey; TTL не продлевается; отозванный токен остаётся 401 после рестарта Valkey и API (10 проверок GET и POST) student-tests.txt
4: параметризованные запросы, ограниченный пул, таймауты repo.py (%s), db.py max 10 соединений; пауза PostgreSQL → 503 за 3,0 с; Valkey → 0,5 с test_postgres_failure[pause], test_valkey_failure[pause]
4: гонка регистрации test_registration_race_exactly_one_201_and_seven_409 8 одновременных → ровно [201] + [409]×7 (сравниваются HTTP-коды), в БД 1 строка student-tests.txt
4: rollback составной операции см. «атомарное создание чата» откат после первого INSERT там же
4: индекс истории и EXPLAIN на ≥ 10 000 make explain, test_late_page_uses_index_range_not_filter 50 189 сообщений, 20 000 в чате; поздняя страница при generic plan: Index Cond: … ROW(created_at, id) > ROW($2, $3), 5 буферов, 0,11 мс; вариант с IS NULL OR — Rows Removed by Filter: 19950, 526 буферов, 3,3 мс; OFFSET — 526 буферов, 4,4 мс explain-history.txt
4: expiry, logout, неверный пароль test_short_ttl_expires[valkey/postgres], test_logout_revokes_only_this_token, test_wrong_password_and_unknown_user_give_the_same_401 401 после expires_at; logout отзывает только этот токен; неверный пароль и неизвестный пользователь — одинаковый 401 student-tests.txt
4: недоступность Redis/БД, аноним не доверенный test_failures.py: stop/pause Valkey и PostgreSQL с действующим токеном, LOCK TABLE, восстановление в finally 503 в пределах дедлайна; аноним — 401; readiness 503; после восстановления тот же токен и данные на месте там же
Логи без секретов и текстов grep по логу api после трафика 0 текстов сообщений, паролей, токенов, паролей БД; события login_failed, session_store_unavailable, access-строки logs-check.txt
SIGTERM сохранён из lab1 docker compose stop api × 3 1,1–1,2 с, exit 0, без OOM sigterm.txt
5: трек 2 bench/track2/*.py см. ниже evidence/track2/

Итог своих тестов на стенде из чистого clone: 108 passed (45 unit + 63 против стенда), 3 мин 28 с (student-tests.txt).

Проверки, на которых ловили другие работы, и наш результат

Замечание к чужим PR У нас Где проверено
logout при упавшем Redis → после восстановления токен снова 200 logout при упавшем Valkey = 503 (ничего не отозвано, клиент это видит). После восстановления logout → 401, и 401 сохраняется после рестарта Valkey и API test_logout_during_valkey_outage_is_never_lost
истёкшая сессия принимается из кэша expiry проверяется при каждом чтении; ключ живёт до абсолютного PXAT test_short_ttl_expires
пауза PostgreSQL → запрос висит 8+ с; ограничено ожидание пула, но не SQL клиентский дедлайн в отдельной задаче + statement_timeout / lock_timeout test_postgres_failure[pause], test_locked_table_gives_bounded_503
отказ БД маскируется под 401 503 unavailable для действующего токена, в обоих режимах сессий test_postgres_failure, test_postgres_session_store
cursor в Filter при generic plan два отдельных запроса test_explain.py
{"text":"hello\u0000world"} → 500 201, текст сохраняется и читается побайтно test_unicode_limits_are_code_points_and_nul_is_stored
пароль из 12 пробелов принимается; Basic é → 500 400; 401 test_bad_password_on_registration_is_400, test_malformed_basic_is_401_not_500
bcrypt и пароли длиной 73–128 символов → 500 Argon2id без ограничения длины; 128 кириллических символов работают test_edge_passwords_register_and_login
дата в cursor вне диапазона → 500 400 test_broken_cursors_are_400_not_500
SESSION_TTL_SECONDS не доходит до контейнера compose передаёт его, тест читает printenv в контейнере test_short_ttl_expires
в инструкции нет создания secrets scripts/init_secrets.py в первой команде clean-clone.txt
нет executable bit у restart.sh 100755 в Git git ls-files -s scripts/restart.sh
тесты отказов засчитывают любую ошибку сравниваются конкретные коды и время, восстановление в finally test_failures.py

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

Гипотезы

  1. С индексом (chat_id, created_at, id) и keyset-запросом стоимость страницы почти не зависит от размера чата и позиции страницы. С индексом только по (chat_id) keyset-запросу приходится сортировать весь чат. OFFSET читает весь префикс до позиции. Без индекса читается вся таблица.
  2. Каждый вторичный индекс удорожает запись: больше WAL и места, ниже пропускная способность.
  3. pg_dump даёт согласованный снимок. Восстановление 100 000+ сообщений в новое хранилище занимает секунды, сверка сходится полностью, а граница потери данных — момент снимка.

Методика

  • Изолированная БД (plans.py): отдельный контейнер postgres:18.6 (тот же digest), --cpus 2 --memory 2g, настройки по умолчанию, без опубликованных портов. Схема — наши миграции.
  • Данные — детерминированный seed: 121 120 сообщений в 200 чатах неравномерно — 1 × 60 000, 2 × 15 000, 8 × 2 000, 189 × 80. Текст 10–380 байт.
  • Генератор: pgbench (-M prepared, как у драйвера) в отдельном контейнере со своими 2 CPU.
  • Чтение: одна страница LIMIT 51 после случайной позиции чата (200 позиций по всей длине). Запрос keyset — это SQL приложения (HISTORY_AFTER), OFFSET — для сравнения. 4 клиента, прогрев 3 с, замер 10 с, 3 повтора. Индексы: keyset_index (наш), chat_id_index, no_index (только PK).
  • Запись: транзакция сообщения приложения (UPDATE chats … RETURNING + INSERT) в случайный из 200 чатов.
    • TPS и задержки: 8 клиентов, 5 повторов по 10 с.
    • WAL: детерминированно — 5 000 транзакций в 1 клиент, autovacuum таблицы выключен, CHECKPOINT перед прогоном, 3 повтора. Первые замеры WAL под 8 клиентами давали разброс в 2 раза из-за checkpoint и autovacuum посреди прогона, поэтому методика заменена.
    • Индексы: без вторичных, наш, наш + (sender_id, created_at).
  • Размер индексов — отдельно на одинаковых 121 120 строках (index_sizes.py).
  • Backup/restore (backup_restore.py) на живой БД стенда: к данным стенда добавлены те же 121 120 сообщений, всего 171 410–171 898. Во время дампа писатель отправляет сообщения через API (~40/с).
    • pg_dump -Fc -Z 6 → новый контейнер PostgreSQL с новым volume → pg_restore -j 2 → ANALYZE → сверка.
    • Сверка: количество строк по таблицам, MD5 всех сообщений (id | created_at | text) каждого чата, первые и последние 50 сообщений самого большого чата, schema_migrations, список индексов. Сообщения писателя в копии должны быть точным префиксом подтверждённых.
    • Затем наш образ API запускается на восстановленной БД: вход по старому паролю и чтение чата писателя через API.
    • 3 раунда.
python bench/track2/plans.py                 # чтение и запись (~25 мин)
python bench/track2/plans.py --writes-only   # только запись (~6 мин)
python bench/track2/index_sizes.py           # размеры индексов
python bench/track2/backup_restore.py --repeats 3
pip install -r requirements-bench.txt && python bench/track2/summarize.py   # summary.md + plans.png

Результаты: чтение одной страницы

Медиана 3 повторов; в скобках — min–max TPS между повторами. Полная таблица — summary.md, сырые данные — reads.csv.

Индекс Запрос Чат TPS p50, мс p95, мс p99, мс
(chat_id, created_at, id) keyset 60 000 2 655 (2 402–3 486) 0,81 2,28 32,8
(chat_id, created_at, id) keyset 15 000 2 991 0,76 1,68 32,8
(chat_id, created_at, id) keyset 80 4 018 0,58 1,69 11,9
(chat_id, created_at, id) OFFSET 60 000 180 11,6 69,2 81,0
(chat_id, created_at, id) OFFSET 15 000 791 2,53 43,9 52,6
(chat_id) keyset 60 000 89,5 27,0 80,9 99,0
(chat_id) keyset 15 000 362 5,64 55,7 59,4
(chat_id) OFFSET 60 000 28,3 120 278 389
только PK keyset 60 000 29,0 112 197 293
только PK keyset 80 36,3 102 182 193

Трек 2

  • Наш индекс + keyset: p50 и p95 почти не зависят от размера чата (0,6–0,8 мс и 1,7–2,3 мс от 80 до 60 000 сообщений). Узел плана Index Scan … Index Cond: ((chat_id = $1) AND (ROW(created_at, id) > ROW($2, $3))) читает ровно 51 строку (explain/keyset_index-big-late-page.txt).
  • OFFSET с тем же индексом: стоимость растёт с позицией. На чате в 60 000 TPS в 15 раз ниже, p95 в 30 раз выше: индекс читается с начала чата до смещения.
  • Индекс только по chat_id: keyset-запрос вынужден взять все строки чата и сделать top-N sort. На 60 000 TPS в 30 раз ниже (89,5 против 2 655). На маленьких чатах (80) разницы нет — сортировать почти нечего.
  • Без индекса: около 30 TPS на любом чате, потому что каждый запрос сканирует всю таблицу. Размер чата почти не влияет, влияет размер таблицы.
  • Почему p99 нашего варианта ~33 мс при p50 < 1 мс. Это хвост стенда, а не плана: Docker Desktop в VM на Windows, CFS-квота --cpus 2 и общий CPU с генератором. Тот же хвост виден на маленьком чате, где работы почти нет. В плане такого хвоста нет (Execution Time 0,1 мс).

Результаты: стоимость записи

Вторичные индексы messages TPS (8 клиентов, min–max) p50, мс p95, мс WAL на вставку, байт (min–max) Размер вторичных индексов на 121 120 строк
нет 1 954 (1 540–2 055) 3,55 7,14 1 930 (1 884–1 940) 0
(chat_id, created_at, id) — наш 1 577 (1 002–1 630) 4,73 8,50 2 910 (2 800–2 926) 6,8 МиБ (59 байт/строку)
наш + (sender_id, created_at) 1 223 (896–1 607) 6,25 9,30 3 318 (3 310–3 414) 9,8 МиБ (85 байт/строку)
  • WAL — самая надёжная метрика (разброс 1–3%). Наш индекс добавляет +51% WAL на вставку, второй индекс — ещё +14%. WAL — это и запись на диск, и трафик репликации, и объём архива для PITR.
  • TPS падает примерно на 19% и 37% (медианы), но разброс повторов большой (до ±30%), поэтому это тенденция, а не точная цифра. Транзакция также упирается в блокировку строки чата и fsync COMMIT, общие для всех вариантов.
  • Индекс только по chat_id занимает 0,9 МиБ против 6,8 МиБ у нашего: B-tree PostgreSQL ≥ 13 дедуплицирует одинаковые ключи. Ради поздних страниц мы сознательно платим местом и записью.
  • Вывод: наш единственный вторичный индекс окупается — чтение страницы большого чата в 30 раз дешевле альтернатив, а запись дорожает умеренно. Второй индекс без запроса, который им пользуется, — чистая потеря.

Результаты: backup → восстановление в новое хранилище → сверка

Раунд Сообщений Дамп, с Размер дампа Восстановление, с ANALYZE, с Сверка Писатель: подтверждено / в копии / после снимка API на восстановленной БД
1 171 410 1,47 5,1 МиБ 2,21 0,57 всё совпало (257 чатов) 237 / 101 / 136 вход ✓, история = копия ✓
2 171 655 1,70 5,1 МиБ 1,90 0,49 всё совпало (258 чатов) 242 / 109 / 133 ✓
3 171 898 1,40 5,1 МиБ 1,76 0,49 всё совпало (259 чатов) 250 / 110 / 140 ✓

Данные — backup.json. «Всё совпало» означает, что одновременно выполнено:

  • MD5 сообщений каждого чата;
  • первые и последние 50 сообщений чата в 60 000;
  • число пользователей, чатов и участников;
  • schema_migrations и список индексов;
  • сообщения писателя в копии — точный префикс подтверждённых.

Время восстановления и границы потери данных

  • Согласованность. pg_dump работает в одной транзакции REPEATABLE READ, то есть это MVCC-снимок на момент старта дампа. В копии нет «рваного» состояния: сообщения писателя — непрерывный префикс без пропусков. Например, в раунде 1 последнее сообщение копии — 17:06:57.831, первое потерянное — 17:06:57.857, а записи шли всё время дампа.
  • RPO. Теряется всё, что подтверждено после старта снимка: в эксперименте 133–140 сообщений за ~3,5 с (дамп плюс 2 с после него). В эксплуатации RPO равен интервалу между дампами: при ночном дампе — до 24 часов подтверждённых сообщений. Сессии в Valkey в этот бэкап не входят: после восстановления пользователи входят заново, что безопасно.
  • RTO на этих данных: около 2,3–2,8 с = pg_restore (1,8–2,2 с, включая перестройку индексов) + ANALYZE (0,5 с), плюс переключение DATABASE_URL и старт API (~2 с). Время восстановления растёт линейно с объёмом данных и индексов. Дамп 5,1 МиБ на 172 000 сообщений — около 31 байта на сообщение после сжатия.
  • Как уменьшить RPO/RTO: непрерывный архив WAL и PITR (pgBackRest или WAL-G) сокращают RPO до секунд и позволяют восстановить состояние на любой момент. Потоковая реплика сокращает RTO до времени переключения. Синхронная реплика — RPO≈0 ценой задержки COMMIT. Проверять восстановление нужно регулярно, как этот скрипт: копия, которую не восстанавливали, — ещё не копия.

Ограничения эксперимента

  • Данные синтетические: равномерное время сообщений, один отправитель на чат в seed. На реальном распределении селективность индексов другая.
  • Настройки PostgreSQL по умолчанию; данные помещаются в shared_buffers и кэш ОС, поэтому замерено «тёплое» чтение. На холодном диске разница между вариантами будет больше.
  • pgbench в режиме closed loop; один хост с Docker Desktop (VM WSL2) — хвосты p99 и TPS записи шумные (разброс указан). Повторов 3 и 5, без статистических тестов.
  • Backup — логический (pg_dump) на небольшом объёме. Для больших баз нужны физические бэкапы с WAL. Valkey не входит в эксперимент восстановления: сессии одноразовые.

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

Воздействие Что ожидаем Что наблюдали Восстановление / потеря данных
restart.sh: stop api → restart postgres, valkey → start api данные и тот же токен работают PASS (оба режима сессий), все три StartedAt новые ~11 с до готовности; потерь нет
docker compose stop postgres с действующим токеном 503, аноним 401, readiness 503 503 < 3,6 с на /users/me, /chats, историю после старта тот же токен и сообщение на месте
docker pause postgres ограниченное время ответа 503 через 3,0 с (до исправления — 13 с) после unpause всё работает
LOCK TABLE messages на 6 с быстрый отказ, а не ожидание 503 < 3,6 с (lock_timeout) после снятия блокировки 200
stop или pause Valkey 503, аноним 401 503 за 0,5 с после старта прежние сессии действуют (AOF)
logout во время отказа Valkey отзыв не теряется 503 (не отозван) → после восстановления logout 204 → 401 и после рестарта Valkey и API токен не «оживает»
SESSION_TTL_SECONDS=2 401 после expires_at 401 (Valkey и PostgreSQL) —
TTL 12 с + рестарт Valkey и API срок не продлевается 200 до expires_at, 401 после —
8 одновременных регистраций одного имени 1 × 201, 7 × 409 ровно так, одна строка в БД —
10 клиентов × 10 сообщений 100 уникальных, строгий порядок 100, 15 страниц по 7, уникальное время —
backup во время записи → restore в новое хранилище согласованный снимок префикс без пропусков, сверка 100% RPO = момент снимка; RTO ≈ 2,5 с на 172 000 сообщений

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

  • Выдерживается:
    • рестарт API и обоих хранилищ без потери подтверждённых данных и сессий;
    • отказ или зависание PostgreSQL или Valkey без зависаний и без анонимного доступа;
    • гонки регистрации и записи в один чат.
  • Не выдерживается:
    • потеря хоста или диска (один узел, нет реплик и архива WAL);
    • отказ Valkey означает отказ всех защищённых запросов: это сознательная плата за отсутствие второй копии сессий. Повысить доступность можно репликой Valkey или SESSION_STORE=postgres.
  • Учебные упрощения: HTTP без TLS (только локальный стенд с синтетическими данными); secret-файлы читаемы на хосте (0644, чтобы их могли прочитать пользователи контейнеров); один экземпляр API (реплики и балансировщик — lab3).
  • Список чатов при одновременном создании. Он сортируется по created_at без глобального замка. Чат, закоммиченный «задним числом», может не попасть в уже идущий обход, но виден при новом. Для сообщений эта проблема закрыта блокировкой строки чата.
  • Подтверждено замерами: выигрыш индекса и keyset, стоимость WAL, восстановление и сверка. Гипотезы (не проверялись): поведение на холодном диске и на данных в десятки ГБ; выигрыш PITR.