Files
mtusi2026lab2-fork/REPORT.md

36 KiB
Raw Permalink Blame History

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

  • Автор, группа: Попов Константин Дмитриевич, группа БВТ2303
  • Целевая оценка: 4; трек 5 не заявляется
  • Commit/PR: TODO после публикации
  • Использованные источники, библиотеки и помощь ИИ: Python, FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.2.3 + psycopg-pool 3.2.4, redis-py 5.2.1, argon2-cffi 23.1.0; PostgreSQL 16, Redis 7; документация PostgreSQL (transactions, EXPLAIN), Redis persistence, RFC 7617. Помощь ИИ использовалась при переносе кода lab1 на PostgreSQL, написании тестов и формулировке отчёта.

Исправления по ревью

  1. Отозванный токен снова получал доступ после восстановления связи с Redis. Ошибка записи «надгробия» при logout поглощалась, а положительной записи кэша доверяли до её истечения. Исправлено долгом инвалидации в PostgreSQL: он фиксируется в той же транзакции, что и отзыв, и пока не погашен, кэшу не доверяют. Подробности — в разделе «Роль Redis». Добавлены тесты test_session_cache.py, revocation_partition.py и фаза partition в dependency_failure.py; сравнение до/после — в evidence/revocation_partition.txt. Попутно найдена и исправлена регрессия самого исправления: при недоступной БД ответ занимал 2 × 3 с, теперь 3 с.
  2. Вход принимал JSON-тело. POST /auth/sessions с телом теперь возвращает 400 до проверки пароля и до создания сессии; тест test_login_with_body_rejected.

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

Версии. Образ API: python:3.12.7-slim-bookworm; postgres:16.4-alpine; redis:7.4.1-alpine. Зависимости Python закреплены точными версиями в requirements.txt. Требуются Docker Desktop (Compose v2) и Python 3.9+ для тестов (только стандартная библиотека).

# 1. Локальные секреты (создаются один раз в ./secrets, каталог в .gitignore; значения не печатаются)
python scripts/init_secrets.py
copy .env.example .env            # Linux/macOS: cp .env.example .env

# 2. Проверка конфигурации, сборка и запуск API + PostgreSQL + Redis
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait

# 3. Миграции применяются автоматически при старте API (advisory lock).
#    Явный повторный запуск ничего не дублирует:
docker compose exec api python -m src.migrate     # -> schema is up to date; nothing applied

# 4. Готовность
curl http://localhost:8080/health/ready            # {"status":"ok"}

Проверки (Linux/macOS — через make, Windows — те же команды Python напрямую):

python scripts/check_contract.py                                   # make check
python tests/smoke.py --base-url http://localhost:8080              # make test
# Перезапуск API и всех хранилищ с сохранением volumes:
#   Linux/macOS/WSL/Git Bash:  make test-persistence ACTION_SCRIPT=scripts/restart.sh
#   Windows (cmd/PowerShell):  python tests/resilience.py --mode persistence --action-script scripts/restart.cmd
python student-tests/run_all.py --base-url http://localhost:8080   # make test-student

# Истечение сессии — второй экземпляр API с SESSION_TTL_SECONDS=2 на порту 8081:
docker compose --profile ttl up -d --wait api-short-ttl
python student-tests/run_all.py --expiry-url http://localhost:8081  # make test-expiry

# Rollback на уровне БД с внедрённым сбоем (внутри compose-сети, БД наружу не публикуется):
make test-storage      # + test_session_cache.py: отзыв при сбое инвалидации кэша

# Отказ Redis и PostgreSQL (останавливает и снова запускает контейнеры):
python student-tests/dependency_failure.py --output evidence/dependency_failure.json   # make test-failures

# Отзыв токена при разрыве API<->Redis без рестарта Redis (замечание ревью №1):
python student-tests/revocation_partition.py                        # make test-revocation

# План запроса истории на 52 000 сообщениях (данные создаются и откатываются в одной транзакции):
make explain    # PowerShell: Get-Content scripts/sql/explain_history.sql | docker compose exec -T postgres psql -U messenger -d messenger > evidence/explain_history.txt

Остановка. Безопасная остановка без потери данных: docker compose --profile ttl down (volume pgdata сохраняется). Намеренное удаление всех учебных данных — только вручную: docker compose --profile ttl down -v. Restart-hook и тесты никогда не удаляют volumes.

Действия оператора: создать секреты (init_secrets.py) до первого запуска. Пароль PostgreSQL задаётся только при инициализации пустого volume, поэтому скрипт не перезаписывает существующие файлы секретов.

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

Клиент ──HTTP :8080──► API (FastAPI/Uvicorn, 1 процесс, sync-обработчики в threadpool)
                          │  пул psycopg: min 1 / max 10, ожидание соединения 3 с,
                          │  connect_timeout 3 с, statement_timeout 5 с
                          ├──────────► PostgreSQL 16  (источник истины; volume pgdata)
                          │              users, chats, chat_members, messages, sessions
                          └──────────► Redis 7       (кэш проверок сессий; без persistence)
                                         таймаут 250 мс, circuit breaker 5 с

Что перенесено из lab1 и что изменено

Перенесены: модели Pydantic со строгой валидацией (extra="forbid"), формат ошибок с X-Request-Id, keyset-курсор (created_at, id) с привязкой к ресурсу, Dockerfile (non-root appuser, HEALTHCHECK, exec-форма CMD, graceful shutdown), собственные тесты test_api.py, race.py, run_all.py.

Изменено по объявленному переходу 1 → 2: POST /users требует password; POST /auth/sessions принимает только Basic; все бизнес-endpoint принимают только Bearer; X-User-Id игнорируется; добавлен DELETE /auth/sessions/current. In-memory Storage с RLock заменён на PostgreSQL; пагинация теперь выполняется в SQL (LIMIT n+1 по индексу), а не срезом списка в памяти. Исправление базы lab1: заголовок X-Request-Id от клиента принимается только по шаблону [A-Za-z0-9._:-]{1,128}, иначе генерируется новый.

Схема данных (migrations/001_init.sql)

Таблица Ключи и ограничения Индексы под запросы
users PK id; UNIQUE(username); CHECK формата username и длины display_name уникальный индекс username — вход и гонка регистрации
chats PK id; CHECK длины title —
chat_members PK (chat_id, user_id); FK → chats (CASCADE), FK → users; UNIQUE(chat_id, position) (user_id, chat_id) — «мои чаты»
messages PK id; FK → chats, FK → users; CHECK длины text 1–4000 (chat_id, created_at, id) — история и keyset
sessions PK token_hash (SHA-256 токена, 32 байта); FK → users; expires_at, revoked_at user_id, expires_at
session_cache_invalidations PK token_hash; revoked_at revoked_at — сверка и удаление старых строк

Миграции: 001_init (основная схема) и 002_session_cache_invalidations (долг инвалидации кэша, добавлена по ревью). Они версионируются файлами migrations/NNN_*.sql и таблицей schema_migrations. Каждая миграция и отметка о ней — одна транзакция; одновременный старт нескольких API сериализуется pg_advisory_lock. Повторный запуск — no-op (проверено тестом test_migrations_are_idempotent).

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

  • Регистрация — один INSERT; уникальность гарантирует UNIQUE(username), приложение лишь переводит UniqueViolation в 409 (нет окна «SELECT, потом INSERT»).
  • Создание чата — одна транзакция: INSERT chats → INSERT chat_members (в порядке member_ids). Существование участников проверяет FK; при неизвестном id откатывается всё, включая строку чата и уже вставленных участников → 400.
  • Отправка сообщения — один оператор INSERT … SELECT … WHERE EXISTS(членство): проверка доступа и запись атомарны. created_at назначает БД (clock_timestamp()), ответ отдаётся после COMMIT.
  • Чтение истории — проверка членства и выборка страницы в одном соединении; snapshot между HTTP-страницами не обещается (как в контракте). При конкурентных вставках порядок определяется часами БД; сообщение с меньшим created_at, закоммиченное после чтения страницы, может быть пропущено уже прошедшим курсором — допустимое ограничение keyset по времени.
  • Вход — INSERT sessions (expires_at = clock_timestamp() + TTL по часам БД, поэтому рестарт API не продлевает TTL). Logout — одна транзакция: UPDATE sessions SET revoked_at + строка «долга инвалидации» в session_cache_invalidations (момент отзыва = COMMIT); затем «надгробие» в Redis и удаление долга.

Аутентификация

  • Пароли: Argon2id (argon2-cffi, m = 19 MiB, t = 2, p = 1 — рекомендация OWASP), пароль 12–128 code points хешируется целиком в UTF-8, без усечения. Для несуществующего username выполняется проверка против хеша-«пустышки», чтобы время ответа не выдавало наличие пользователя; ответ 401 одинаковый.
  • Basic разбирается строго: base64 → UTF-8 → разделение по первому двоеточию (двоеточие в пароле допустимо). Неверные/битые credentials → 401 WWW-Authenticate: Basic realm="messenger", charset="UTF-8". Вход принимает только заголовок: любое тело запроса (JSON или нет) → 400 invalid_request до проверки пароля и до создания сессии (исправлено по ревью, test_login_with_body_rejected).
  • Токен: secrets.token_urlsafe(32) — 256 бит, непрозрачный. В БД и Redis хранится только SHA-256 токена: для 256-битного случайного значения перебор невозможен, а KDF лишь замедлил бы каждый запрос (в отличие от пароля, где KDF защищает низкоэнтропийный секрет).
  • Сначала аутентификация (dependency current_user), затем доступ к чату: посторонний получает 404, а не 403.

Роль Redis: кэш проверок сессии

  • Источник истины для сессий — PostgreSQL. Redis хранит sess:<sha256> → {user, expires_at}.

  • Заполнение: промах → запрос в PostgreSQL → SET NX PX=min(SESSION_CACHE_TTL_SECONDS=60 с, время до expires_at). Запись кэша никогда не живёт дольше сессии, поэтому истечение работает и при попадании в кэш (тест test_session_expires_even_when_cached).

  • Инвалидация при logout: после COMMIT отзыва в PostgreSQL выполняется SET sess:<hash> "revoked" PX=60 с (обычный SET перезаписывает). Заполнение идёт через SET NX, поэтому параллельный запрос, прочитавший сессию до отзыва, не может вернуть в кэш валидную запись поверх «надгробия».

  • Если «надгробие» записать не удалось (исправлено по ревью). В первой версии ошибка Redis при logout поглощалась, и после восстановления связи с тем же, не перезапущенным Redis старая положительная запись снова пускала отозванный токен до своего истечения (~60 с). Теперь:

    1. вместе с revoked_at в той же транзакции фиксируется строка в session_cache_invalidations (миграция 002); она удаляется только после успешной записи «надгробия»;
    2. пока такие строки есть, положительным попаданиям кэша не доверяют: каждый токен проверяется в PostgreSQL, отозванный получает 401. Реплика, выполнившая logout, переключается сразу, до ответа 204;
    3. не чаще раза в секунду API сверяется с этой таблицей. Он дописывает недостающие «надгробия» в Redis и гасит долг. Строки старше SESSION_CACHE_TTL_SECONDS + 5 удаляются без записи: положительная запись к этому моменту уже истекла;
    4. долг хранится в PostgreSQL, поэтому он переживает рестарт API. Новый процесс не доверяет кэшу до первой сверки.

    Отзыв по-прежнему не зависит от доступности Redis: logout возвращает 204, а PostgreSQL остаётся единственным источником истины.

  • Persistence: отключена сознательно (--save "" --appendonly no), maxmemory 64mb, allkeys-lru. После flush/рестарта Redis кэш пуст, все проверки идут в PostgreSQL и заново наполняют кэш; сессии не теряются, потому что Redis не единственное их хранилище.

  • Отказ Redis: таймаут операций 250 мс; при ошибке кэш пропускается на 5 с (circuit breaker), запросы обслуживаются через PostgreSQL. Readiness от Redis не зависит.

  • Эффект: за 30 с нагрузки (счётчики сброшены перед прогоном) Redis показал keyspace_hits=8655, keyspace_misses=1 — проверки токена обслужены без обращения к PostgreSQL.

Отказ PostgreSQL

PostgreSQL — критичная зависимость: /health/ready → 503; запросы к данным → 503 unavailable за ≤ 3 с (ожидание соединения из пула) без текста драйвера/SQL. Анонимный запрос отклоняется 401 ещё до обращения к БД; неизвестный токен при недоступной БД не принимается (503). Кэшу без связи с БД не доверяют: сверка долга инвалидации требует PostgreSQL, поэтому при её недоступности и токен из кэша получает 503 (ошибка сверки сразу превращается в 503, без второго ожидания пула). Пул проверяет соединения при выдаче (check_connection), поэтому после возврата БД API восстанавливается без рестарта.

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

Переменная Где используется
APP_HOST, APP_PORT APP_PORT — публикуемый порт в compose (127.0.0.1:${APP_PORT}:8080); внутри контейнера Uvicorn слушает 0.0.0.0:8080 (CMD)
APP_ENV передаётся в API, сейчас только информативно
SESSION_TTL_SECONDS TTL сессии основного API (по умолчанию 3600)
SHORT_SESSION_TTL_SECONDS TTL экземпляра api-short-ttl (профиль ttl, порт 8081), по умолчанию 2
DATABASE_URL_FILE /run/secrets/database_url — Compose secret, создаётся init_secrets.py
SESSION_STORE postgres — источник истины сессий (другое значение API отвергает при старте)
CACHE_URL_FILE /run/secrets/cache_url — адрес Redis с паролем; без него API работает без кэша
SESSION_CACHE_TTL_SECONDS верхняя граница TTL записи кэша и «надгробия» logout
DB_POOL_MIN/MAX, DB_POOL_TIMEOUT_SECONDS размер пула и ожидание соединения (→ 503)
DB_CONNECT_TIMEOUT_SECONDS, DB_STATEMENT_TIMEOUT_MS таймаут подключения и любого SQL-оператора
CACHE_TIMEOUT_SECONDS, CACHE_RETRY_AFTER_SECONDS таймаут Redis и длительность обхода кэша после ошибки

Инфраструктура

Роль Service Версия Health/readiness Volume Сеть/порт Credentials
api api (+ api-short-ttl в профиле ttl) сборка из Dockerfile, python:3.12.7-slim-bookworm HEALTHCHECK /health/ready нет (stateless) backend; 127.0.0.1:8080 (8081 для ttl) secrets database_url, cache_url
postgres postgres postgres:16.4-alpine pg_isready pgdata backend, наружу не публикуется secret postgres_password (POSTGRES_PASSWORD_FILE)
redis redis redis:7.4.1-alpine, user redis redis-cli ping нет (кэш) backend, наружу не публикуется secret redis_password (--requirepass)

Bootstrap: схема создаётся миграциями при первом старте API на пустом volume; повтор безопасен. scripts/restart.sh / scripts/restart.cmd: stop api → restart postgres redis → up -d --wait api; без down -v, flush и повторного seed.

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

Стенд, на котором сняты приложенные результаты: Linux x86_64, 2 vCPU Intel Xeon 2.1 GHz, 8 GB RAM; PostgreSQL 16.15 и Redis 7.0.15, запущенные нативно (без Docker), API — тот же код, Uvicorn, Python 3.13; клиент тестов на той же машине. Перед защитой результаты нужно повторить на compose-стенде командами из раздела «Запуск» и обновить файлы в evidence/.

Уровень 3

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab2 public API scenario evidence/smoke.txt
Структура/контракт make check, make validate оба PASS evidence/check.txt
Данные и действующие сессии переживают рестарт API и хранилищ make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS: persistence preserved confirmed data and existing session — тот же токен читает те же сообщения evidence/persistence.txt
Hook реально перезапускает процессы PID до/после hook postgres 1212→1269, redis 1222→1279, api 1228→1286; пользователей 51→51, действующих сессий 42→42 evidence/restart_processes.txt
PK/FK, UNIQUE(username), миграции с нуля migrations/001_init.sql; старт на пустой БД на пустой БД: migrations applied at startup: ['001_init', '002_session_cache_invalidations'] migrations/
Повторный запуск миграций без дублирования python -m src.migrate; test_migrations_are_idempotent schema is up to date; nothing applied; в schema_migrations одна строка evidence/student-tests.txt
Атомарное создание чата test_unknown_member_rolls_back_whole_chat, test_failure_after_inserts_leaves_nothing после ошибки нет ни чата, ни участников evidence/student-tests.txt
Basic только на POST /auth/sessions, остальное Bearer test_basic_on_business_endpoint_rejected, smoke Basic на /users/me → 401 WWW-Authenticate: Bearer evidence/student-tests.txt
X-User-Id не даёт доступа test_x_user_id_gives_no_access, smoke 401 без Bearer; с Bearer владелец не меняется evidence/student-tests.txt
Срок жизни и отзыв сессии test_session_expires_even_when_cached, test_logout_revokes_only_current_session после TTL и после logout → 401; повторный logout → 401; вход с телом → 400 evidence/student-tests.txt
Пароли — password KDF test_passwords_stored_as_argon2id в БД $argon2id$…, plaintext отсутствует evidence/student-tests.txt
Secrets/volumes не в Git .gitignore (secrets/, .env, volumes/, data/), секреты в отдельных файлах после init_secrets.py и git add -A в индекс не попадают secrets/ и .env .gitignore

Уровень 4

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Redis реально используется для сессий с TTL; описаны источник истины, expiry, инвалидация код src/sessions.py; нагрузка keyspace_hits=8655 / misses=1 за 30 с нагрузки; TTL записи ≤ min(60 с, остаток сессии); «надгробие» при logout; без persistence — обосновано выше раздел «Роль Redis», evidence/load.json
Параметризованные запросы src/storage.py только плейсхолдеры %s psycopg; в SQL подставляются лишь константные фрагменты кода src/storage.py
Ограниченный пул и таймауты src/db.py, .env.example пул 1..10, ожидание 3 с, connect 3 с, statement 5 с, Redis 250 мс src/db.py, src/config.py
Гонка регистрации одинакового username test_same_username_parallel_registration (16 параллельных запросов, Barrier) ровно 1×201 и 15×409; входит только победитель evidence/student-tests.txt
Rollback составной операции test_unknown_member_rolls_back_whole_chat (HTTP, FK-ошибка на 3-м участнике), test_failure_after_inserts_leaves_nothing (внедрённый сбой после вставки чата и 3 участников) внутри транзакции строки были видны (1 чат, 3 участника), после — 0 и 0 evidence/student-tests.txt
Индекс истории обоснован EXPLAIN (ANALYZE, BUFFERS) на ≥ 10 000 сообщений make explain 52 000 сообщений, 12 000 в чате; keyset-страница после 10 000-го: Index Scan, 5 буферов, 0.04 мс; OFFSET: Seq Scan + Sort 10 051 строк, 695 буферов, 5 мс; без индекса: Seq Scan 695 буферов, 3–5 мс evidence/explain_history.txt
Пагинация без полного скана тот же EXPLAIN Index Cond: chat_id = … AND ROW(created_at,id) > ROW(…), читается limit+1 = 51 строка evidence/explain_history.txt
Автотест expiry при коротком TTL test_session_expires_even_when_cached на API с SESSION_TTL_SECONDS=2 200, 200 (из кэша) → через TTL+1.5 с 401; logout истёкшим → 401; новый вход → 201 evidence/student-tests.txt
Автотест logout и неверного пароля test_logout_revokes_only_current_session, test_wrong_password_and_unknown_user_look_the_same, test_malformed_basic_headers все PASS evidence/student-tests.txt
Автотест недоступности Redis dependency_failure.py API обходит кэш: чтение/запись/вход/logout работают, max задержка 8 мс, readiness 200 evidence/dependency_failure.json
Отзыв при разрыве связи с живым Redis (замечание ревью №1) dependency_failure.py, фаза partition; revocation_partition.py; test_session_cache.py (заглушка Redis, реальная PostgreSQL) logout → 204; отозванный токен — только 401 во время разрыва, сразу после восстановления и 8 с после (дольше circuit breaker). Первая версия на том же сценарии: [200, 401]. Тест с заглушкой падает, если вернуть доверие положительному кэшу (проверено мутацией) evidence/revocation_partition.txt, evidence/dependency_failure.json, evidence/student-tests.txt
Строгий формат входа (замечание ревью №2) test_login_with_body_rejected правильный Basic + {"unexpected":true} / {} / не-JSON / form → 400, без тела → 201 evidence/student-tests.txt
Автотест недоступности БД dependency_failure.py live 200, ready 503; запись/чтение/вход → 503 unavailable за 3.0 с; анонимный → 401; неизвестный токен → 503; восстановление 0.6 с; отклонённая запись не сохранилась evidence/dependency_failure.json

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

Гипотеза 1. Если PostgreSQL — единственный источник истины для данных и сессий, а Redis только кэш, то перезапуск всех процессов с сохранением volumes не теряет ни подтверждённых сообщений, ни действующих сессий, а потеря Redis не влияет на корректность. Подтверждено test-persistence (тот же токен после рестарта) и dependency_failure.py.

Гипотеза 2. Составной индекс (chat_id, created_at, id) делает стоимость страницы истории независимой от глубины курсора. На 52 000 сообщениях первая и «10 000-я» страница стоят одинаково (4–5 буферов, < 0.1 мс), тогда как OFFSET и запрос без индекса читают весь чат/таблицу (695 буферов) и растут линейно с объёмом.

Нагрузка (tests/load.py, closed-loop POST сообщений, без retry): 30 с, concurrency 4, без прогрева; 8 655 успешных запросов, 0 ошибок, 287 RPS; p50 13.2 мс, p95 20.2 мс, p99 24.3 мс (только успешные). До исправлений ревью тот же прогон давал 327 RPS, p95 17.4 мс. Разница в пределах разброса между запусками на общей виртуальной машине: повторов для статистики не делалось. Сверка долга добавляет не больше одного запроса к PostgreSQL в секунду. Стенд: 2 vCPU / 8 GB, без CPU/RAM-лимитов, клиент на той же машине; CPU/RAM процессов не измерялись. Это пропускная способность HTTP-подтверждений в этом профиле, а не максимум системы. Для сравнения, lab1 (in-memory) на другом ноутбуке давала 254 RPS — значения разных машин несопоставимы.

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
Рестарт API + PostgreSQL + Redis (hook) данные и сессии сохраняются тот же токен читает ту же историю; пользователей и сессий столько же готовность через 2.6 с после начала hook; потерь нет
Остановка Redis обход кэша, работа через PostgreSQL все операции 200/201/204, max 8 мс, readiness 200 без восстановления; после возврата кэш наполняется заново
Остановка PostgreSQL 503 на данные, 401 анониму, live 200 503 unavailable за 3.0 с, ready 503, аноним 401 0.6 с после старта БД; запись во время отказа не сохранена (клиент получил 503)
16 одинаковых регистраций одновременно ровно одна успешна 1×201, 15×409 —
Сбой между INSERT chats и chat_members полный откат 0 строк чата и участников —

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

  • Один API, одна PostgreSQL, один Redis на одном Docker-host: отказ host или диска БД не выдерживается; репликации и бэкапов нет (бэкап/восстановление — трек 2 уровня 5, не заявлен).
  • Durability зависит от настроек PostgreSQL по умолчанию (fsync=on, synchronous_commit=on): подтверждённый 201 означает COMMIT, записанный в WAL на локальный диск.
  • Отзыв при сбое Redis: для реплики, выполнившей logout, окна нет. Другая реплика (в compose это api-short-ttl, в lab3 — реплики за LB), у которой связь с Redis не рвалась, узнаёт о долге при следующей сверке, то есть не позже чем через 1 с после ответа 204. Если logout прошёл успешно, окна нет ни у кого.
  • Пока долг инвалидации не погашен (Redis недоступен), все проверки токена идут в PostgreSQL: кэш не разгружает базу до восстановления связи.
  • Basic/Bearer идут по HTTP — допустимо только на локальном учебном стенде; TLS — lab7.
  • Пароль Redis передаётся в redis-server аргументом командной строки внутри контейнера (виден в списке процессов контейнера); hardening — lab7.
  • Приложенные результаты сняты на нативном стенде без Docker (см. «Доказательства»); compose-конфигурация проверена docker compose config, перед сдачей нужно прогнать те же сценарии на compose.
  • Следующие шаги (lab3): несколько реплик API за балансировщиком уже совместимы с выбранной схемой (сессии в общей БД, кэш в общем Redis, миграции под advisory lock); нужно добавить Idempotency-Key и X-Instance-Id.

Вопросы защиты — кратко

  • Что подтверждает COMMIT? Что транзакция записана в WAL и после сбоя процесса/рестарта будет видна. Гарантия зависит от fsync, synchronous_commit и от того, что диск действительно сбрасывает кэш; потеря самого volume не покрывается.
  • Где сессии и что после flush/restart Redis? В PostgreSQL. Redis — кэш; после flush следующие запросы проверяют токен в PostgreSQL и заново кладут его в кэш, пользователи не разлогиниваются.
  • Аутентификация vs доступ к чату: аутентификация отвечает «кто это» (Bearer → user_id), авторизация — «может ли этот пользователь работать с этим чатом» (строка в chat_members); посторонний получает 404.
  • Hash пароля vs checksum: KDF (Argon2id) намеренно медленный и с солью, чтобы перебор слабого пароля по утёкшей базе был дорогим; быстрый checksum (SHA-256) нужен для целостности/поиска и годится для токена только потому, что токен — 256 случайных бит.