36 KiB
Отчёт — лабораторная 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, написании тестов и формулировке отчёта.
Исправления по ревью
- Отозванный токен снова получал доступ после восстановления связи с Redis. Ошибка записи «надгробия» при logout поглощалась, а положительной записи кэша доверяли до её истечения. Исправлено долгом инвалидации в PostgreSQL: он фиксируется в той же транзакции, что и отзыв, и пока не погашен, кэшу не доверяют. Подробности — в разделе «Роль Redis». Добавлены тесты
test_session_cache.py,revocation_partition.pyи фаза partition вdependency_failure.py; сравнение до/после — вevidence/revocation_partition.txt. Попутно найдена и исправлена регрессия самого исправления: при недоступной БД ответ занимал 2 × 3 с, теперь 3 с. - Вход принимал 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 или нет) → 400invalid_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 с). Теперь:
- вместе с
revoked_atв той же транзакции фиксируется строка вsession_cache_invalidations(миграция002); она удаляется только после успешной записи «надгробия»; - пока такие строки есть, положительным попаданиям кэша не доверяют: каждый токен проверяется в PostgreSQL, отозванный получает 401. Реплика, выполнившая logout, переключается сразу, до ответа 204;
- не чаще раза в секунду API сверяется с этой таблицей. Он дописывает недостающие «надгробия» в Redis и гасит долг. Строки старше
SESSION_CACHE_TTL_SECONDS + 5удаляются без записи: положительная запись к этому моменту уже истекла; - долг хранится в 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 случайных бит.