Files
mtusi2026lab2/REPORT.md

66 KiB
Raw Permalink Blame History

Отчёт — лабораторная 2. PostgreSQL, сессии и Redis

  • Автор: Ремез Олег Романович, БПИ2304.
  • Целевая оценка: 5, трек 2 «План запроса и восстановление». Завершённая исходная контрольная точка уровня 4 — commit 834876c; исследовательский этап описан отдельно ниже.
  • Дата итоговой проверки: 28.10.2026.
  • Итоговая обязательная регрессия: 43 Go-теста PASS, 0 FAIL, 0 SKIP, сборка, vet, публичные проверки, 174 JSON/UTF-8 случая, пагинация, рестарты и отказы — PASS из чистого clone. Исследование трека 2 на 100k и backup/restore — PASS. Дополнительный HTTP-профиль нагрузки сохранён отдельно со статусом FAIL: 768 измеренных запросов успешны, один из 128 прогревочных login получил 503 при 10 клиентах; этот результат не скрывается.
  • Исходная версия уровня 4 определена SHA-256 manifest снимка. При подготовке трека 2 исходники приложения и миграции не менялись; обновлялись собственные тестовые инструменты и отчёт. Последующие результаты имеют отдельные артефакты и не приписываются исходному прогону.
  • Ветка публикации: solution/BPI2304-remez. Контрольная точка уровня 4 — 834876c; материалы уровня 5 включены в последующие коммиты этой ветки. Результаты ниже относятся к локальным проверкам; успешный удалённый CI не подтверждён.
  • Использование ИИ: обсуждение архитектуры и ошибок, ревью и отдельные согласованные изменения, подготовка собственных тестов и диагностики, анализ измерений, оформление отчёта и Git. Публичный контракт и проверки преподавателя не ослаблялись.

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

Среда и версии

Нужны Git, Docker с Compose 2.24.4+, Python 3.9+, make и доступ к registries при первой установке. Для собственных Go-тестов на host нужны Go 1.27.1 и C toolchain для -race; сборка API и мигратора выполняется также внутри Docker. Команды ниже выполняются из корня этого репозитория на macOS/Linux.

Компонент Проверенная версия / конфигурация
Host macOS 27.0.1, arm64; Apple M2, 8 логических CPU, 8 GiB RAM
Docker / Compose 28.4.0 / 2.39.4-desktop.1
Go / JSON Go 1.27.1; стандартная библиотека encoding/json/v2
Builder / runtime golang:1.27.1-alpine / alpine:3.22; runtime под непривилегированным app
PostgreSQL 18.6, образ postgres:18
Redis 7.4.11, образ redis:7.4-alpine; AOF, appendfsync everysec
Библиотеки pgx/v5 5.11.0, go-redis/v9 9.23.0, Goose/v3 3.26.0, google/uuid 1.6.0, x/crypto 0.57.0

Точные ID/digest образов, ОС и параметры устройства находятся в environment.json. Зависимости Go зафиксированы в go.mod и go.sum. В Compose указаны ветки PostgreSQL/Redis, поэтому получение обновлённого тега может изменить фактическую версию. Для повторения именно проверенных arm64 образов хранилищ можно использовать отдельный override:

cat > /tmp/lab2-grade4-images.yaml <<'YAML'
services:
  postgres:
    image: postgres@sha256:5a5a84b19854a9ffaa54082c166ff4ec27473a361e496e5ea167f298f2da9722
  redis:
    image: redis@sha256:858f009f9709ce576febc734aa78b8f6d624b82571f9ddb6bda4377c833b3499
YAML
export COMPOSE_FILE="$PWD/compose.yaml:/tmp/lab2-grade4-images.yaml"

Для другой архитектуры необходимо выбрать совместимые образы и отдельно зафиксировать их digest; приведённые измерения на неё автоматически не переносятся. Builder/runtime в Dockerfile закреплены тегами версий, а не immutable digest.

Локальные настройки и secrets

Для нового учебного стенда создаются .env и два согласованных secret-файла. Следующий блок предназначен только для чистого clone: он откажется перезаписывать существующие настройки и не выводит сгенерированный пароль.

python3 - <<'PY'
from pathlib import Path
import os
import secrets

if Path('.env').exists() or Path('secrets').exists():
    raise SystemExit('Existing .env or secrets: keep the current configuration.')
os.umask(0o077)
Path('secrets').mkdir(mode=0o700)
password = secrets.token_hex(24)
values = {
    'postgres_password': password,
    'database_url': f'postgres://messenger:{password}@postgres:5432/messenger?sslmode=disable',
}
for name, value in values.items():
    path = Path('secrets') / name
    path.write_text(value + '\n')
    path.chmod(0o644)
Path('.env').write_bytes(Path('.env.example').read_bytes())
Path('.env').chmod(0o600)
PY

Каталог secrets имеет режим 0700. Файлы внутри него имеют 0644, чтобы непривилегированный контейнерный процесс мог читать read-only mount; на host доступ ограничивает каталог. .env, secrets, volumes и локальные результаты тестов исключены из Git. Это локальные Compose secrets, а не централизованный менеджер секретов.

Переменная Значение / смысл
APP_HOST, APP_PORT По умолчанию 0.0.0.0:8080 внутри контейнера; снаружи API опубликован на 127.0.0.1:8080
DATABASE_URL_FILE /run/secrets/database_url; приложение читает файл DSN
SESSION_STORE Обязательно redis; пустое значение отклоняет config, другой store отклоняет composition root в main
REDIS_ADDR Обязательно непустое; в Docker-сети redis:6379, это адрес, а не путь к файлу
SESSION_TTL_SECONDS Положительное число секунд, по умолчанию 3600; для отдельного expiry-теста используется 2
APP_ENV Считывается с default lab, поведение приложения сейчас не переключает
CACHE_URL_FILE Остаточная переменная исходного примера; приложение её не читает, отдельного кэша нет

Файл secrets/postgres_password соответствует POSTGRES_PASSWORD_FILE у PostgreSQL. Изменение этого файла не меняет пароль в уже инициализированной БД: ротация требует согласованного изменения роли и DSN, а не удаления volume.

Сборка, миграции и готовность

export COMPOSE_PROJECT_NAME=lab2-remez
export BASE_URL=http://127.0.0.1:8080
docker compose config --quiet
docker compose up -d --wait --wait-timeout 90 postgres redis
docker compose up -d --build --wait --wait-timeout 120
docker compose ps --all
docker compose logs migrate
curl --fail --silent --show-error "$BASE_URL/health/ready"

Хранилища сначала доводятся до healthy, затем запускается весь стенд. PostgreSQL healthy → задача migrate с exit 0 → API. Состояние Exited (0) у мигратора штатное. При ошибке миграции API не должен запускаться. SQL встроен в бинарник, поэтому после изменения миграций образ мигратора необходимо пересобрать.

# Статус без изменения схемы:
docker compose run --rm --no-deps migrate -command=status
# После добавления новой миграции:
docker compose run --build --rm --no-deps migrate

Повторный up применяет только pending-версии и не заполняет таблицы повторно. Для миграций используется Goose advisory lock; несколько миграторов не применяют одну версию параллельно. Общий бюджет мигратора — 2 минуты, pool — 2 соединения, connect timeout — 5 с, DDL lock timeout — 10 с. Подробности — infra/MIGRATIONS.md.

Проверки и остановка

На поднятом демонстрационном стенде:

make check
make test BASE_URL="$BASE_URL"
make test-persistence BASE_URL="$BASE_URL" ACTION_SCRIPT=scripts/restart.sh

scripts/restart.sh перезапускает реальные api, postgres, redis указанного COMPOSE_PROJECT_NAME, проверяет изменение StartedAt, сохранение ID контейнеров и volumes, затем ожидает ready. Задача migrate не перезапускается. Hook не выполняет down -v и не подменяет перезапуск очисткой данных.

Полная автоматическая проверка поднимает собственный изолированный проект, использует синтетические secrets и свободные localhost-порты, а затем удаляет только собственные ресурсы:

./scripts/setup-tests.sh
.venv/bin/python student-tests/stack.py verify --measure-budgets \
  --output student-tests/output/grade4-repeat

Проверка текущего снимка через настоящий временный Git clone:

python3 student-tests/check_clone.py --measure-budgets \
  --output student-tests/output/grade4-clone-repeat

Каталог output для нового прогона должен быть новым. Итоговый прогон 28.10 использовал --pull never: базовые образы уже были загружены. Это не подтверждение скачивания всех образов с registry с нуля. Полная инструкция и требования к -race — student-tests/RUNNING.md.

Безопасная остановка, сохраняющая учебные данные:

docker compose down

Намеренное удаление данных только выбранного учебного проекта — отдельная операция:

docker compose down --volumes

Роли компонентов

Роль / service Данные и volume Сеть и готовность Credentials
API / api Собственного постоянного состояния нет 127.0.0.1:8080; /health/live, /health/ready DSN через secret-файл
PostgreSQL / postgres users, chats, chat_members, messages; postgres_data:/var/lib/postgresql Compose network; также 127.0.0.1:5432; pg_isready POSTGRES_PASSWORD_FILE
Redis / redis Сессии, AOF в redis_data:/data Только Compose network, 6379; redis-cli ping В изолированном локальном стенде без отдельной ACL/auth; наружу порт не опубликован
Мигратор / migrate Версионируемая схема и goose_db_version в PostgreSQL Без опубликованного порта; успешное завершение задачи Тот же DSN secret

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

Переход от лабораторной 1

Сохранены HTTP API, слои handler/service/repository, валидация JSON, ACL, cursor-пагинация, request ID, access logging и graceful shutdown. In-memory repositories заменены PostgreSQL. Добавлены password KDF, Basic login и серверная Bearer-сессия. X-User-Id больше не устанавливает личность пользователя.

Поток запроса: клиент → middleware (request ID, access log, Bearer auth) → handler → service → repository → PostgreSQL/Redis. Handler разбирает HTTP и формирует ответ; service проверяет бизнес-условия; repository отвечает за конкретное хранилище. cmd/api/main.go связывает реализации через интерфейсы. Login принимает Basic без JSON body; бизнес-маршруты используют Bearer.

PostgreSQL: источник истины бизнес-данных

Таблица Основные ограничения
users UUID PK, UNIQUE username, CHECK формата [a-z0-9_]{3,32}, ограничений display_name и непустого password_hash
chats UUID PK, непустой title длиной 1–100 code points
chat_members Составной PK (chat_id,user_id), FK на chats/users; повтор участника запрещён
messages UUID PK, составной FK (chat_id,sender_id) на membership, текст 1–4000 code points и не пустой

Времена назначаются PostgreSQL через now(), идентификаторы — gen_random_uuid(). Уникальность username гарантирует БД, поэтому конкурентная регистрация не опирается на небезопасную схему «сначала проверили отсутствие, затем вставили». SQL параметризован и генерируется sqlc из db/queries.

Создание чата и всех участников выполняется в одной транзакции. Ошибка участника откатывает весь чат. Общий дочерний контекст 1 с покрывает получение соединения, BEGIN, INSERT чата, все INSERT участников и COMMIT. На rollback выделяется отдельный контекст WithTimeout(WithoutCancel(ctx), 1 с): отменённый рабочий контекст не должен мешать освобождению транзакции. Поэтому очистка может добавить до секунды сверх рабочего бюджета.

Остальные операции PostgreSQL имеют дочерний контекст 1 с на весь вызов repository, включая ожидание pool и SQL. Более ранний deadline вызывающего кода сохраняется. Это инженерная настройка проекта, а не числовое требование задания и не общий timeout HTTP с вычислением KDF. Pool приложения ограничен default pgxpool max(4, runtime.NumCPU()), если DSN не переопределяет pool_max_conns; безлимитный пул не используется.

Миграции: 00001 создаёт схему, 00002 добавляет defaults времени, 00003 удаляет PostgreSQL sessions после переноса в Redis. Down 00003 восстанавливает структуру sessions версии 2, ограничения и индекс, но не удалённые строки. Старые SQL-запросы и реализация PostgreSQL sessions удалены; после sqlc generate в актуальном generated-коде их нет.

Аутентификация и Redis как единственное хранилище сессий

Пароли хешируются библиотечным Argon2id: 64 MiB памяти, 3 итерации, parallelism 2, случайная соль 16 байт и hash 32 байта. Параметры и соль сохраняются в кодированной строке; проверка использует constant-time сравнение. Username и UTF-8 пароль длиной 12–128 code points проверяются до lookup; неправильные credentials дают одинаковый 401 с Basic challenge.

После успешного входа crypto/rand создаёт 32 случайных байта токена (256 бит), клиент получает base64url. В Redis используется ключ session:<hex(SHA-256(token))>, значение содержит user ID, created_at и исходный expires_at. Исходный токен в хранилище не записывается. SET устанавливает TTL; GET не продлевает срок. Service дополнительно проверяет expires_at. Redis — источник истины этих сессий: PostgreSQL fallback и доверие к клиентскому ID отсутствуют.

Logout закрепляет одно Redis-соединение, выполняет DEL, затем WAITAOF 1 0 2000. Успешный 204 возвращается только при подтверждённом локальном fsync ([1,0]); неподтверждённый счётчик означает 503, ошибка формы ответа — внутреннюю ошибку. После удаления нельзя обещать, что 503 означает «ничего не произошло»: ключ мог уже исчезнуть до ошибки подтверждения.

Redis запускается с appendonly yes, appendfsync everysec, именованным volume. Действующие сессии и подтверждённый отзыв выдержали проверяемый полный перезапуск. Создание сессии не вызывает WAITAOF, поэтому политика everysec не гарантирует сохранение каждой только что выданной сессии при внезапном сбое питания. Подтверждение локального fsync при отзыве не является репликацией, backup или защитой от потери диска/volume.

Настройки клиента: pool 10, ожидание pool 2 с, dial/read 3 с, write 2 с, ContextTimeoutEnabled=true. Таймаут WAITAOF — 2 с; сетевой read budget больше него. Эти значения не означают общий предел любого HTTP-запроса: операции и автоматические сетевые повторы могут суммироваться.

Категории ошибок, диагностика и health

Repository переводит ошибки драйвера в свои категории; service — в категории приложения, HTTP helper — в контрактные статусы. Неизвестная/истёкшая/отозванная сессия — 401, отсутствие или чужой объект — 404, конфликт username — 409, недоступность зависимости — 503, неожиданная ошибка — 500. JSON encode/decode и некорректный формат ответа Redis не маскируются под отказ сети.

Подробная причина 5xx логируется один раз в WriteServiceError: error, request_id, status, code. В публичном JSON остаются безопасное сообщение и request ID. Access log отдельно содержит method/path/status/duration; токены и тексты сообщений не нужны для диагностики.

/health/live не зависит от хранилищ. /health/ready проверяет PostgreSQL и Redis в общем контексте 2 с и возвращает 503, если обязательная зависимость недоступна. UUID участников нормализуются перед проверкой дубликатов и присутствия создателя: различный регистр hex не создаёт другого пользователя.

Индекс истории и EXPLAIN

Индекс idx_messages_chat_created_id (chat_id, created_at, id) соответствует фильтру чата, диапазону cursor и порядку выдачи. Форма реального запроса sqlc:

SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id = $1
  AND ($2::timestamptz IS NULL
       OR (created_at, id) > ($2::timestamptz, $3::uuid))
ORDER BY created_at ASC, id ASC
LIMIT $4;

Читается limit + 1 строк для определения наличия следующей страницы; OFFSET при чтении истории не используется. UUID разрешает одинаковые created_at в порядке пагинации. Cursor проверяется и привязывается к ресурсу/пользователю. Между разными страницами не обещается единый snapshot.

В EXPLAIN (ANALYZE, BUFFERS) использованы 10 000 сообщений, пять чатов с распределением 70/20/6/3/1%. Первая и глубокая страницы используют Index Scan по указанному индексу, по 51 фактически прочитанной строке, без сканирования всей истории и отдельной сортировки:

Страница Execution Time, мс Shared hit blocks Строк в Index Scan
Первая 0,015 3 51
Глубокая 0,016 5 51

Это конкретные планы на прогретом учебном наборе, а не универсальная оценка latency. Полные JSON-планы; SQL источника.

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

Итоговый прогон из временного clone от 28.10.2026 завершился PASS. Snapshot включал 139 исходных файлов, включая ещё не добавленные тогда в Git, но исключал .env, secrets, volumes, бинарники и output. После тестов дерево clone осталось чистым. Проверка опубликованного remote commit этим не подменяется.

Команда итогового прогона:

python3 student-tests/check_clone.py --measure-budgets \
  --output student-tests/output/grade4-recheck-20261028 --pull never

Все строки ниже относятся к этому прогону; собственные acceptance-сценарии запускаются внутри stack.py verify, без повторного определения альтернативных тестов.

Критерий README Команда / сценарий Наблюдаемый результат Доказательство
Контракт, сборка, статические проверки make check validate, go build ./..., go vet ./... в verify PASS; защищённые материалы не изменены summary
Публичный smoke, минимум предыдущей лабы make test PASS, переход Basic/Bearer соблюдён smoke
PostgreSQL, PK/FK/unique, миграции с нуля и повторный запуск Go migration/schema tests в verify Чистая БД до v3, повторный и конкурентный up, rollback SQL-ошибки, 3→2→1→3 — PASS Go -race
Атомарное создание чата Ошибка участника и отмена перед COMMIT Частичного чата нет; соединения освобождены Go -race
KDF, Basic только login, Bearer/ACL, X-User-Id не доверяется auth-normal, business PASS; неверные credentials — 401; UUID-дубликат — 400 auth, business
Сохранность бизнес-данных и активных сессий после полного рестарта make test-persistence ACTION_SCRIPT=scripts/restart.sh, auth-persistence API/PostgreSQL/Redis действительно перезапущены; сообщения, исходный expiry и отзыв сохранены persistence, lifecycle
Secrets/volumes вне Git, воспроизводимый запуск clean clone, bootstrap и cleanup Private-файлов нет; исходники собраны заново; тестовые ресурсы удалены clone, проверка
Redis с TTL, описанными expiry/invalidation и persistence short TTL, hash/PTTL, restart, logout GET не продлевает TTL, одна сессия не отзывает другую, отозванная не оживает Go -race, auth-persistence
Параметризованный SQL, ограниченные pools и таймауты sqlc; blocked SQL / exhausted pool tests Приложение само завершает SQL-ожидание около 1 с; короткий deadline сохраняется SQL, Go -race
Гонка регистрации и rollback Конкурентная регистрация одного username; ошибка транзакции Один победитель; данные не перезаписаны; частичной операции нет Go -race
Обоснованный индекс и EXPLAIN ≥10k, эффективная пагинация sql-plan-10000, business-cursors, read-after-write Index Scan первой/глубокой страницы; корректные cursor и порядок планы, business
Автоматические expiry, logout, неверный пароль TTL=2, auth-expiry/auth-normal, Go sessions PASS; истёкшая/неизвестная/отозванная сессия — 401 expiry, auth
Реальный отказ Redis/БД, ограниченная ошибка и восстановление postgres-outage, redis-outage 503 вместо ложного 401/500, ready=503/live=200, после старта обслуживание восстановлено PostgreSQL, Redis
Согласованная диагностика сверх обязательной рубрики TestErrorDiagnosticsRecordedOnceAndPublicResponseIsSafe Одна подробная запись, безопасный JSON, без токена и !BADKEY Go -race
Трек 2: ≥100k и неравномерные чаты research.py, research/seed 100k, распределение 70/20/6/3/1% dataset, индексы
Трек 2: ≥2 индекса/запроса и цена записи 4 серии AB/BA, чтение/INSERT+COMMIT, размер/WAL 8 trials; 2880 чтений, 160 транзакций по 200 вставок; результаты и ограничения ниже сравнение
Трек 2: backup → новое хранилище → сверка pg_dump/pg_restore, snapshots, 15 сообщений, restart цели Counts/digests совпали, отдельные containers/volumes, повторная проверка после restart PASS восстановление
Трек 2: время восстановления и границы потерь Измерение backup/restore и описание snapshot/RPO Restore 1,198 с; post-snapshot записи и Redis не входят; полный RTO/HA не заявлены исследовательский отчёт

Полная сводка исходной контрольной точки — отчёт повторной проверки. Сведения в нём о незаполненном авторском отчёте и untracked-файлах описывают момент тестирования, до подготовки настоящего документа и коммита. Трек 2 выполнен позднее и описан в отдельном разделе ниже; результаты разных прогонов не объединяются в фиктивный единый PASS.

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

Гипотезы и настройка времени ожидания

  1. Ожидание pool/SQL должно прекращаться приложением, а не аварийным таймером теста. После введения repository-бюджета 1 с заблокированный запрос завершился за 1002,402 мс, занятый pool — 1003,149 мс, оба с 503, до safety-cancel 5 с. При deadline вызывающего кода 150 мс — 151,519 / 150,884 мс. Освобождение блокировки до бюджета позволяет завершить запрос и продолжить обслуживание. Тестовый порог 3 с не является выбранным общим HTTP timeout.
  2. Для AOF everysec ожидание fsync ровно 1 с может оказаться недостаточным. В отдельной серии 25.10 сравнили два бюджета на закреплённом соединении с шестью паузами перед записью: 1000 мс — 9/18 подтверждений, 3000 мс — 18/18; максимальная фактическая задержка 1184,043 мс. Ошибок команд и AOF write не было. Это согласуется с пограничным ожиданием фонового fsync, но не является трассировкой внутренних событий Redis. Исходный эксперимент.
  3. В приложении выбран промежуточный WAITAOF budget 2 с при read timeout 3 с. Итоговая диагностика настоящим клиентом при 1/5/10 клиентах дала 51/51 подтверждений, без ошибок и ожиданий pool; в конце все 10 соединений свободны. Raw диагностика. Это подтверждает проверенный профиль, а не достаточность бюджета при любой нагрузке.
Воздействие Что ожидаем Что наблюдали Восстановление / данные
Полный restart API + PostgreSQL + Redis с прежними volumes Сохранить подтверждённые сообщения, действующую сессию и исходный expiry Публичный и собственный persistence PASS; отозванная сессия не ожила Готовность восстановлена; проверенные объекты сохранены; отдельный RTO не измерялся
Остановка PostgreSQL ready=503, live=200, business-ошибка 503 PASS; Redis logout остаётся доступен независимо от SQL После старта PostgreSQL запросы снова успешны; отдельный RTO не измерялся
Остановка Redis Не доверять анонимному запросу и не подменять отказ на 401 ready=503, live=200; операции получают 503 После старта обслуживание восстановлено; долговечность отдельно проверена restart-сценарием
Заблокированный SQL / занятый pool Самостоятельный ограниченный выход, без утечки Около 1 с, 503; раннее освобождение даёт 200 После освобождения следующий запрос проходит
Отмена транзакции до COMMIT / ошибка участника Не оставить часть чата Чат и участники откатились Ресурсы освобождены; неопределённый COMMIT не входит в это утверждение
TTL=2, чтение до expiry, затем ожидание Не продлевать срок чтением После исходного expiry — 401 Повторный login создаёт новую независимую сессию
WAITAOF не подтвердил локальный fsync Не сообщать успешный logout 503; неверная форма ответа диагностируется отдельно Удаление уже могло произойти; нельзя обещать отсутствие эффекта

Методика нагрузки

Измерены восемь HTTP-операций при 1/5/10 клиентах, 2 повтора по 3 запроса на работника. Перед каждой операцией/уровнем concurrency — один прогревочный запрос на работника: всего 128 warmup + 768 измеренных запросов. Измеренные запросы успешны, ошибок и таймаутов — 0. Сумма длительностей измеренных фаз — 35,836 с; окно генератора с прогревом и подготовкой сессий для logout — 53,375 с; весь этап с начальной подготовкой данных — 56,88 с.

Генератор — Python urllib, closed loop, без retry; arrival rate не задаётся. Исходная HTTP-история — 1000 сообщений; глубокий cursor действительно получен после 800 сообщений. В ходе записи данные растут. SQL-план на 10k измеряется отдельным сценарием. API ограничен 2 CPU/1 GiB, PostgreSQL — 1 CPU/512 MiB, Redis — 0,5 CPU/256 MiB только в тестовом override; обычный Compose эти лимиты не задаёт.

Операция Клиенты n Успешные RPS p50, мс p95, мс p99, мс Ошибки
Регистрация 1 6 11,76 78,17 100,63 100,63 0
Вход 1 6 8,93 72,79 204,86 204,86 0
Текущий пользователь 1 6 138,96 4,66 17,02 17,02 0
Создание чата 1 6 153,22 3,17 14,78 14,78 0
Отправка сообщения 1 6 362,31 2,17 6,04 6,04 0
История, первая страница 1 6 241,82 3,47 5,70 5,70 0
История, глубокая страница 1 6 234,21 4,02 4,98 4,98 0
Logout 1 6 0,96 1030,07 1047,66 1047,66 0
Регистрация 5 30 12,76 340,48 579,10 657,66 0
Вход 5 30 12,41 371,83 570,24 598,27 0
Текущий пользователь 5 30 2113,62 2,07 2,78 3,04 0
Создание чата 5 30 782,32 3,90 18,88 19,74 0
Отправка сообщения 5 30 1160,64 3,25 6,81 7,04 0
История, первая страница 5 30 553,73 6,41 16,64 17,16 0
История, глубокая страница 5 30 714,49 6,36 8,76 8,99 0
Logout 5 30 4,90 1039,84 1046,38 1046,80 0
Регистрация 10 60 12,46 671,35 1231,57 1315,59 0
Вход 10 60 9,98 928,89 1468,43 1933,24 0
Текущий пользователь 10 60 514,50 7,14 78,24 78,86 0
Создание чата 10 60 1792,01 4,93 6,92 7,58 0
Отправка сообщения 10 60 2100,90 3,84 5,66 6,56 0
История, первая страница 10 60 642,79 10,75 22,62 26,41 0
История, глубокая страница 10 60 707,08 10,96 23,53 24,28 0
Logout 10 60 9,95 1026,21 1040,34 1041,02 0

Ресурсы измерялись раз в секунду по cgroup v2 и /proc/1/status, 53 отсчёта:

Компонент Средний CPU, ядер CPU от лимита, % Наблюдаемый пик RSS PID 1, MiB Пик cgroup memory, MiB OOM kill
API 1,012 50,62 998,83 1023,65 0
PostgreSQL 0,023 2,34 29,90 49,56 0
Redis 0,017 3,34 13,78 11,10 0

RSS PID 1 не равен суммарной памяти всех процессов PostgreSQL; cgroup включает другие процессы/кэш. Показатели получены разными интерфейсами и не обязаны совпадать. Пики — максимумы отсчётов, не непрерывное измерение. Полная таблица, raw timings и ресурсы.

Вывод: обычные бизнес-операции и история в данном профиле не демонстрируют полного сканирования данных, logout ожидает fsync около секунды. Регистрация/вход заметно дороже чтения; API почти достиг лимита памяти. Argon2id требует 64 MiB на вычисление, но раздельного профилирования KDF/GC/SQL не проводилось, поэтому причинный вклад не объявляется измеренным.

Выборки 6/30/60 малы для устойчивого p99; p99.9 и production SLO не выводятся. Closed loop скрывает часть задержек при перегрузке (coordinated omission), клиент и сервис используют один host, HTTP elapsed включает клиентскую проверку/планирование. Показатели не являются максимальной пропускной способностью или отдельной latency PostgreSQL/Redis и не определяют автоматически timeout.

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

  • Один Docker host и один экземпляр каждого хранилища: нет репликации, HA и защиты от потери всего host. В треке 2 проверено логическое восстановление PostgreSQL в новый volume; Redis backup, PITR и автоматический failover не реализованы.
  • AOF everysec и локальный WAITAOF имеют описанные выше границы. TTL обеспечивает expiry, но сам по себе не сохраняет данные.
  • Таймаут записи/COMMIT не доказывает отсутствия эффекта операции. Идемпотентность и восстановление неопределённого исхода требуют отдельной разработки; контракт последующих лабораторных здесь не заявляется выполненным.
  • Число параллельных KDF отдельно не ограничено, API подошёл к 1 GiB в тестовом профиле. Устойчивость при большей нагрузке не доказана; изменение KDF и admission control не выполнялись ради формального прохождения тестов.
  • Нет единого HTTP budget и отдельного timeout чтения body. Репозиторные бюджеты и graceful shutdown 10 с решают другие задачи.
  • Сессии обязательны: при недоступном Redis нельзя продолжать бизнес-запрос как анонимный. PostgreSQL и Redis не заменяют друг друга.
  • Роль messenger создаётся через POSTGRES_USER и имеет расширенные права; разделение ролей мигратора/API и Redis ACL остаётся задачей усиления инфраструктуры. HTTP без TLS допустим только для локального изолированного стенда с синтетическими данными.
  • Чистый clone проверен на macOS/Docker Desktop arm64. Отдельный Linux runner, скачивание всех образов с нуля и удалённый Gitea Actions не проверены. Для изменения порта API потребуется согласовать Docker healthcheck и публикацию порта.
  • .gitea/workflows/application.yml описывает запуск собственных проверок на изолированном runner lab2-isolated-docker. Наличие runner и успешный серверный запуск не подтверждены. Оформление PR остаётся отдельным шагом после локальной проверки.
  • При отдельной сверке контракта отмечены незапрещённый схемой U+0000 в текстовых полях и отсутствие 415 в operation responses OpenAPI при наличии этого статуса в нормативном тексте. В рамках исследовательского этапа политика этих границ не менялась; наличие схемы и зелёных тестов не выдаётся за исчерпывающее покрытие всех строк Unicode.

Исследовательский трек 2 выполнен по методике ниже. Дальнейшие улучшения должны сохранять обязательный контракт; опубликованная версия и удалённый CI требуют отдельной проверки после push.

Трек 2: план запроса и восстановление — исследование на 5

Исследование PASS, 28.10.2026: 100 000 сообщений, восемь trials, 2880 измеренных чтений и 160 транзакций по 200 вставок, восстановление в отдельный PostgreSQL и повторная сверка после его рестарта. Полный исследовательский отчёт, summary и cleanup. Предыдущая HTTP-матрица относится к исходному уровню 4 и не заменяет SQL-эксперимент на 100k.

Гипотеза: индекс (chat_id,created_at,id) уменьшает стоимость чтения ограниченной страницы по сравнению с (chat_id), поскольку соответствует фильтру, keyset-диапазону и ORDER BY. Обратная сторона — размер индекса, WAL и обслуживание при вставке. Победитель и величина эффекта заранее не задаются.

Методика сравнения:

  • Изолированный PostgreSQL: 1 CPU, 512 MiB RAM, без дополнительного swap. Образ разрешается в immutable локальный image ID и записывается в environment.json. Исходный Compose и рабочие volumes не используются.
  • 100 000 сообщений по 256 ASCII-байт; распределение по пяти чатам 70/20/6/3/1%. Одни и те же логические строки используются во всех вариантах, SHA-256 полного набора проверяется после каждой серии вставок и очистки.
  • Вариант A — B-tree (chat_id), B — B-tree (chat_id,created_at,id). Четыре серии с порядком A/B, B/A, A/B, B/A; восемь отдельных trials. На время сравнения существует только один исследуемый вторичный индекс истории, неизменный PK сообщений остаётся в обоих вариантах.
  • Для чатов 70k, 6k и 1k читаются первая страница и страница после 80% истории. OFFSET применяется только при выборе исходного cursor, вне измеряемого запроса. Чтение использует тот же generated sqlc GetMessagesByChatID и преобразование результатов, размер страницы — 51 строка, 5 прогревочных и 60 измеренных запросов на случай/trial, один последовательный клиент. Для каждого случая сохраняется EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON). В offline-эксперименте обеим конфигурациям выделен одинаковый бюджет запроса 10 с, чтобы не обрывать медленный baseline; рабочий repository-бюджет приложения остаётся 1 с. HTTP и KDF сюда не входят.
  • Перед trial выполняются VACUUM FULL, создание индекса и ANALYZE вне времени чтения/записи; autovacuum отключён только для временной исследовательской таблицы. Это устраняет накопление dead tuples между вариантами, но не моделирует холодный диск. Prepared-поведение pgx не отключается.
  • Цена записи: 20 транзакций по 200 сообщений с COMMIT на trial, без удаления между этими 20 транзакциями. После измерения добавленные 4000 строк удаляются, проверяется исходный digest. Сохраняются сырые времена и разность WAL LSN до/после каждой транзакции; WAL — счётчик всего отдельного PostgreSQL instance, а не точный счётчик одного индекса.
  • Размеры индекса/таблицы записываются до измеренных вставок, время построения индекса — отдельно. CPU и память снимаются существующим cgroup sampler; его расходы и административные операции входят в окно ресурсоизмерения. Малые SQL-серии не объявляются исследованием максимальной HTTP-пропускной способности.

Восстановление: отдельная сохраняемая fixture на 100k создаётся через embedded-миграции, затем pg_dump -Fc --no-owner --no-acl экспортирует её схему. pg_restore --exit-on-error восстанавливает архив в пустой второй PostgreSQL с другим именованным volume. Сверяются количества и SHA-256 упорядоченного полного содержимого users/chats/chat_members/messages и 15 выбранных сообщений (первое/среднее/последнее каждого чата). Источник повторно сверяется на неизменность; восстановленная цель дополнительно перезапускается с сохранённым volume и проверяется снова. Archive и credentials остаются только во временном каталоге и удаляются; они не входят в Git.

Повторение обоих этапов одной командой из корня репозитория:

.venv/bin/python student-tests/lab2/research.py \
  --output evidence/grade5-sql-NEW --rows 100000 \
  --repetitions 60 --series 4 --write-batches 20

Нужны запущенный Docker, локальный postgres:18, Go из go.mod и окружение Python из setup-tests.sh. Выходной каталог должен быть новым. Используются только два созданных данным запуском контейнера и два volumes с уникальным префиксом lab2-research-*; cleanup выполняется и при ошибке. Восстановление не содержит Redis-сессии и не включает записи после snapshot backup. Это перенос логической резервной копии в новое хранилище, а не PITR, репликация или доказательство HA.

Результаты сравнения

По каждому случаю и варианту объединены 240 наблюдений из четырёх trials. Все измеренные чтения успешны. Это связанные повторные наблюдения warm SQL workload, не независимая большая выборка для production SLO.

Чат / страница A p50 / p95 / p99, мс B p50 / p95 / p99, мс A/B p50
70k, первая 8,327 / 12,838 / 18,942 0,488 / 2,015 / 3,771 17,06
70k, глубокая 8,844 / 13,124 / 17,739 6,831 / 12,144 / 28,253 1,29
6k, первая 1,357 / 1,722 / 4,184 0,395 / 1,216 / 4,171 3,44
6k, глубокая 1,219 / 2,207 / 5,095 0,885 / 1,639 / 4,168 1,38
1k, первая 0,803 / 1,623 / 2,564 0,394 / 0,851 / 1,215 2,04
1k, глубокая 0,787 / 2,220 / 4,234 0,550 / 1,188 / 4,850 1,43

EXPLAIN B использует Index Scan и диапазон cursor, возвращая 51 строку без отдельной сортировки. A для большого чата выбирает Seq Scan с сортировкой, для малого — Bitmap Scan и сортировку. Отдельный EXPLAIN не является трассировкой каждого prepared execution; его время нельзя отождествлять с полной измеренной latency. Default prepared-поведение pgx сохранено. Все планы и raw timings, CSV с RPS и разбросом trials.

Цена индекса A B
Размер до вставок, байт 720 896 5 914 624
Медиана build, мс 37,134 107,887
INSERT 200 + COMMIT p50, мс 3,378 2,918
INSERT 200 + COMMIT p95, мс 7,838 5,661
INSERT 200 + COMMIT p99, мс 10,859 30,227
Медиана WAL на транзакцию, байт 104 520 117 144

Индекс B больше в 8,20 раза, build медианно дольше в 2,91 раза; медиана WAL выше на 12,08%. Стабильного штрафа INSERT latency серия не доказывает: p50 B ниже, p99 выше. WAL включает таблицу/PK/full-page images/checkpoints, а UUID вставок случайны. Выигрыш чтения тоже не универсален: p99 глубоких страниц 70k/1k у B хуже A. Решение — сохранить B ради существенно лучшей медианы и соответствующего запросу доступа, с указанной ценой и ограничениями, без заявления «любой запрос ускорен».

Средний CPU источника за окно sampler 23,648 с — 0,773 ядра, 77,34% лимита; максимум cgroup memory 511,74 MiB, OOM kill 0. PID 1 RSS 29,67 MiB не является суммой PostgreSQL backends. Ресурсы включают административные операции и sampler, по A/B не разделены.

Результат восстановления

Backup fixture создана реальными миграциями отдельно от benchmark: 1 user, 5 chats, 5 memberships, 100k messages с короткими текстами seed-генератора (13–18 ASCII bytes). На время backup/restore источник не получает посторонних записей.

Операция / проверка Результат
pg_dump -Fc, длительность / размер архива 0,536 с / 2 987 310 байт
pg_restore --exit-on-error в пустой второй instance 1,198 с, PASS
Четыре counts и full ordered SHA-256 Совпали
15 выбранных сообщений: first/middle/last каждого чата Совпали по ID и content fingerprint
Источник после restore Не изменён
Restart цели с сохранением нового volume + ready + snapshot 0,907 с, PASS
Удаление собственных контейнеров/volumes и временного архива PASS, cleanup errors 0

Результат backup/restore, source snapshot, restored snapshot, контейнеры и volumes до restore, после restart.

Эти времена не равны production RTO: provisioning, передача удалённого backup и переключение клиентов не включены. Восстанавливается snapshot backup, записи после него отсутствуют; RPO зависит от момента и частоты копий. Нет гарантий для Redis, потери host или PITR. Ранее неудачные попытки не переписаны: их summary сохранены рядом, а итоговый каталог содержит новый полный успешный прогон. Хеши исследовательских источников.

Итоговая регрессия и отдельное наблюдение нагрузки

После обновления собственных тестов и инструмента исследования выполнена новая проверка из настоящего временного Git clone:

GOCACHE=/tmp/highload-grade5-regression-cache .venv/bin/python \
  student-tests/check_clone.py \
  --output evidence/grade5-sql-2026-10-28-verified/acceptance-complete \
  --pull never

Это фактический путь итогового прогона; для повтора выбирают новый output. Snapshot содержит 137 исходных файлов, без secrets/.env/volumes/бинарников, bootstrap и чистота clone после тестов PASS. Весь актуальный функциональный набор уровней 3/4 пройден: 43 Go-теста, без FAIL/SKIP, Go -race — 127,742 с. Дополнительно PASS 174 JSON/UTF-8 случая; список 7 чатов полностью пройден страницами по 2, три чужих cursor отклонены; 100 сообщений от 10 участников проверены при concurrency 4. Публичные smoke/persistence, собственная сохранность сессий/отзыва, expiry, реальные outages PostgreSQL/Redis, SQL-план 10k и cleanup — PASS.

Clone summary, все этапы, Go events, business, manifest, итоговая сверка.

Исправления собственных запускателей: race-сборка выделена в отдельный этап (300 с), исполнение Go-набора имеет guard 600 с, каждый вложенный Python acceptance под race — собственные 300 с вместо общего на оба сценария. Guard clone — 1200 с. При timeout сохраняется частичный sanitized log. Это суммарные бюджеты инструментов, не изменение SQL 1 с, Redis/WAITAOF, HTTP timeout 15 с или assertions. Первые прерванные попытки сохранены с FAIL и не приписаны успешному прогону. Время последнего Go-набора не доказывает, что только изменение обёртки объясняет различия между попытками: загрузка host тоже менялась.

Отдельная матрица --measure-budgets выполнена ранее в этом же этапе. Итог FAIL, хотя все 768 измеренных запросов успешны: при прогреве C=10 один login получил 503 за 1041,195 мс. Наблюдаемый cgroup memory API достиг ровно 1 GiB, OOM kill не было. Это совпадение с давлением памяти, а не доказанное профилированием объяснение каждого deadline. Ни неудачный прогрев, ни статус FAIL не исключались ради зелёного результата. Raw, таблица, статусы полного прогона с этой матрицей.

Следовательно, обязательная функциональная регрессия и выбранный SQL/restore-трек подтверждены, а безошибочная работа auth при любом профиле C=10/1 GiB не заявляется. Численного проходного RPS контракт не задаёт; найденная граница остаётся ограничением, без ослабления теста, увеличения ресурсов или изменения KDF. Актуализация старых тестов выполнена отдельной работой и сохранена: отчёт очистки.

Использованные источники и инструменты

  • Нормативные требования: README, контракт API, инфраструктура, процесс сдачи, публичные проверки из tests/. Формат отчёта сохранён по шаблону лабораторной; подача измерений и воспроизводимости согласована с собственным отчётом ЛР1.
  • Go context, отмена операций БД, pgxpool: контексты, ограничение pool и транзакции.
  • PostgreSQL transactions, EXPLAIN: атомарность и планы запросов.
  • Redis persistence, WAITAOF: AOF и подтверждение локального fsync.
  • RFC 7617, Argon2id в Go, sqlc, Goose: аутентификация, KDF, генерация параметризованных запросов и миграции.
  • Codex/ChatGPT использовались как помощники в обучении, ревью, диагностике и оформлении. Итоговые результаты приведены по сохранённым артефактам, а не по предположению о прохождении тестов.