Files
2026-11-04 20:08:04 +03:00

27 KiB
Raw Permalink Blame History

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

PostgreSQL, сессии и Redis/Valkey

  • Автор: Перевалова В.А.
  • Группа: БПИ2302
  • Целевая оценка: 5
  • Исследовательский трек: 1 — согласованность кэша
  • Репозиторий: mtusi2026lab2
  • Ветка: solution/lab2-implementation
  • Commit: b727fa922a
  • Использованные технологии: Python 3.11, FastAPI, SQLAlchemy 2, Alembic, PostgreSQL 16.6, Redis 7.4.2, Docker Compose.

1. Назначение и архитектура

Лабораторная переносит состояние мессенджера из памяти одного процесса в PostgreSQL и добавляет серверные сессии. Redis используется как ускоряющий слой: хранит краткоживущие записи сессий и кэш страниц истории сообщений.

Клиент
  │ HTTP / JSON
  ▼
FastAPI (контейнер api, порт 8080)
  ├── SQLAlchemy + Alembic ──► PostgreSQL 16.6
  │                              └── named volume lab2_postgres_data
  └── Redis client ──────────► Redis 7.4.2
                                 └── named volume lab2_redis_data

Источник истины — PostgreSQL. Redis не является единственным местом хранения пользователей, сообщений или сессий. Если Redis недоступен, операции чтения истории выполняются напрямую из PostgreSQL, а аутентификация проверяет запись сессии в PostgreSQL. Кэш Redis ускоряет повторные чтения, но его потеря не должна приводить к потере подтверждённых данных.

1.1. Основные сущности

Сущность Назначение и ограничения
User (users) Пользователь, уникальный username, отображаемое имя и хэш пароля
Chat (chats) Чат с UUID и названием
ChatMember (chat_members) Связь пользователя с чатом; составной первичный ключ (chat_id, user_id) не допускает повторного членства
Message (messages) Сообщение, внешний ключ на чат и отправителя, текст и время создания
Session (sessions) Хэш непрозрачного токена, пользователь и время истечения; уникальный индекс по token_hash

Пароль не хранится в открытом виде: используется Argon2id. Клиент получает случайный Bearer-токен; в PostgreSQL сохраняется SHA-256-хэш токена. Поэтому утечка таблицы сессий не раскрывает сами токены.

1.2. Транзакции и индексы

  • Регистрация выполняет проверку имени и обработку конфликта уникальности на уровне БД.
  • Создание чата и добавление участников выполняются одной транзакцией.
  • Создание сообщения завершается COMMIT до ответа клиенту.
  • История запрашивается keyset-пагинацией по паре (created_at, id), а не загрузкой всей истории с последующим смещением.
  • Индекс ix_messages_chat_created_id (chat_id, created_at, id) соответствует фильтру по чату и сортировке истории.
  • SQLAlchemy использует параметризованные выражения ORM; пул соединений ограничен pool_size=5, max_overflow=10, pool_timeout=30, включён pool_pre_ping.

2. Аутентификация и сессии

  1. Регистрация: POST /api/v1/users, пароль обязателен.
  2. Вход: POST /api/v1/auth/sessions с HTTP Basic. Сервер проверяет Argon2id-хэш, создаёт случайный токен и сохраняет его хэш и expires_at в PostgreSQL.
  3. Защищённые методы используют Authorization: Bearer <token>.
  4. При каждом запросе сервер проверяет сессию в PostgreSQL. Redis-копия с TTL используется как кэш, но не заменяет проверку срока действия и отзыва в БД.
  5. Выход: DELETE /api/v1/auth/sessions/current; запись удаляется из PostgreSQL и Redis.
  6. X-User-Id не используется для установления личности клиента.

Redis недоступен — приложение продолжает проверять сессию по PostgreSQL. PostgreSQL недоступен — защищённый запрос не должен считаться аутентифицированным.

3. Кэш истории и исследовательский трек 1

3.1. Гипотеза

Кэширование страниц истории сообщений в Redis позволяет повторно использовать ранее полученные данные и уменьшать количество обращений к PostgreSQL. Версионирование кэша обеспечивает актуальность истории после добавления новых сообщений. Распределённая блокировка SET NX EX предназначена для ограничения одновременного заполнения одного и того же кэш-ключа.

3.2. Реализация

  • Ключ страницы истории учитывает идентификатор чата, версию истории, размер страницы и курсор.
  • При добавлении сообщения версия кэша чата увеличивается.
  • Для защиты от одновременного заполнения кэша используется Redis-блокировка SET NX EX.
  • При недоступности Redis чтение истории может выполняться непосредственно из PostgreSQL.
  • PostgreSQL остаётся основным источником достоверных данных.
  • Время хранения кэшированных страниц ограничивается TTL.

3.3. Методика исследования

Исследование выполнялось на локальном стенде Docker Compose.

Были проведены следующие проверки:

  1. Первое чтение истории тестового чата.
  2. 30 последовательных повторных чтений.
  3. Добавление нового сообщения и проверка его немедленной доступности через API (read-after-write).
  4. Перезапуск Redis командой docker compose restart redis.
  5. Повторение чтения истории после перезапуска Redis.

Дополнительно была выполнена проверка плана SQL-запроса истории на базе, содержащей 10 009 сообщений.

3.4. Результаты исследования кэширования

Показатель До перезапуска Redis После перезапуска Redis
Первое чтение, мс 15,612 52,287
Количество повторных чтений 30 30
Среднее время повторного чтения, мс 27,055 26,478
Медиана повторного чтения, мс 32,556 29,496
Минимальное время повторного чтения, мс 9,369 13,785
Максимальное время повторного чтения, мс 47,914 46,404
Read-after-write PASS PASS

После перезапуска Redis приложение продолжило обслуживать запросы. Новое сообщение успешно обнаруживалось после записи и последующего чтения истории.

Полученные значения показывают, что повторные запросы выполнялись с сопоставимым временем. При этом результаты первого чтения различались между запусками, поэтому на основании двух серий нельзя утверждать о стабильном ускорении всех повторных запросов.

3.5. Проверка индекса истории

Для проверки использовался запрос с EXPLAIN (ANALYZE, BUFFERS) на таблице messages, содержащей 10 009 записей.

Полученный план выполнения основного запроса истории:

  • Используемый индекс: ix_messages_chat_created_id.
  • Тип доступа: Index Scan.
  • Количество возвращённых строк: 51.
  • Время выполнения основного запроса: 1,580 мс.
  • Использовано 140 shared buffer hits для всего плана запроса.

В плане также присутствовал Seq Scan при поиске чата с наибольшим количеством сообщений. Это отдельная агрегирующая операция, а основной запрос получения истории использовал индекс ix_messages_chat_created_id.

3.6. Дополнительный нагрузочный тест

Для проверки записи сообщений выполнен нагрузочный тест продолжительностью около 10 секунд с конкурентностью 4.

Показатель Результат
Успешные запросы 674
Ошибочные запросы 0
Доля ошибок 0 %
Пропускная способность 64,002 запроса/с
p50 62 мс
p95 94 мс
p99 110 мс
Фактическая продолжительность 10,531 с

Нагрузочный тест использовал закрытый цикл запросов (closed-loop), поэтому результат характеризует только данный локальный профиль нагрузки и не является оценкой предельной производительности системы.

3.7. Выводы и ограничения

Проверки подтвердили использование индекса для получения истории сообщений, сохранение актуальности данных после записи и работоспособность приложения после перезапуска Redis. Дополнительно выполнен отдельный конкурентный эксперимент, проверяющий поведение кэша при одновременном чтении одной и той же страницы истории.

В эксперименте участвовали 12 параллельных запросов при холодном кэше и 12 параллельных запросов при прогретом кэше. На время эксперимента в PostgreSQL включалось логирование всех SQL-запросов (log_min_duration_statement = 0); после завершения исходная настройка восстанавливалась. В журнале подсчитывались только запросы SELECT, содержащие FROM messages.

Показатель Холодный кэш Прогретый кэш
Количество параллельных запросов 12 12
Время выполнения группы, мс 172 110
SQL SELECT ... FROM messages 0 0
Результат PASS PASS

В холодной группе конкурентные запросы не привели к выполнению запросов чтения таблицы messages в PostgreSQL: заполнение страницы было согласовано механизмом Redis-блокировки. В прогретой группе обращения к PostgreSQL за сообщениями также отсутствовали, поскольку данные были получены из кэша. Результат подтверждает работу реализованной защиты от cache stampede для проверенного сценария и профиля нагрузки.

Измерения времени группы запросов характеризуют только локальный стенд и конкретный запуск. Они не являются универсальной оценкой производительности или гарантией такого же результата при другой нагрузке и конфигурации.

4. Инфраструктура и запуск

Требования

  • Docker Desktop с Docker Compose plugin.
  • Python 3.11 для запуска тестовых скриптов на Windows.
  • PowerShell.
  • Свободные локальные порты 8080, 5433 и 6379.

Первый запуск (PowerShell из корня репозитория)

Copy-Item .env.example .env
docker compose config --quiet
docker compose up -d --build
docker compose ps
Invoke-RestMethod http://127.0.0.1:8080/health/ready

Миграция alembic upgrade head запускается командой контейнера API при старте. Swagger UI: http://127.0.0.1:8080/docs.

Проверки

python scripts/check_contract.py
python scripts/validate_openapi.py
python tests/smoke.py --base-url http://127.0.0.1:8080
python tests/persistence_windows.py --base-url http://127.0.0.1:8080
python tests/grade5_checks.py --base-url http://127.0.0.1:8080 --only all

tests/persistence_windows.py — Windows-совместимый сценарий: создаёт синтетических пользователей, чат, сообщение и сессию; перезапускает API, PostgreSQL и Redis через scripts/restart.ps1; затем проверяет прежним токеном доступ к API и наличие прежнего сообщения.

Безопасный перезапуск и остановка

docker compose restart
docker compose down

docker compose down не удаляет именованные volumes. Не используйте docker compose down -v, docker volume rm или docker system prune --volumes, если нужно сохранить результаты лабораторной.

5. Сопоставление критериев лабораторной работы

Критерий Реализация и подтверждение Статус
Хранение пользователей, чатов, участников, сообщений и сессий в PostgreSQL SQLAlchemy-модели в app/db/models.py Реализовано
Первичные и внешние ключи, уникальные ограничения Модели SQLAlchemy и начальная миграция Alembic Реализовано
Миграции базы данных migrations/versions/21ad89656327_create_initial_database_schema.py; миграция автоматически применяется при запуске API Проверено запуском приложения
Аутентификация HTTP Basic и Bearer app/services/auth_service.py, app/api/auth.py, app/api/deps.py Реализовано; API smoke-тест пройден
Хэширование паролей Argon2id в app/services/user_service.py Реализовано
Создание, истечение срока действия и отзыв сессий PostgreSQL как источник истины, Redis как дополнительный слой с TTL Реализовано
Использование Redis для сессий и кэширования истории AuthService и MessageService Реализовано
Обработка недоступности Redis При остановке Redis чтение истории и Bearer-аутентификация продолжили работать через PostgreSQL; grade5_checks.py --only redis Проверено: PASS
Ограничение пула соединений PostgreSQL app/db/session.py: pool_size=5, max_overflow=10, pool_timeout=30, pool_pre_ping=True Реализовано
Keyset-пагинация истории сообщений Репозиторий сообщений, сортировка и курсор по (created_at, id) Реализовано
Индекс истории сообщений ix_messages_chat_created_id; подтверждён через EXPLAIN (ANALYZE, BUFFERS) на 10 009 сообщениях Проверено: Index Scan
Docker Compose и постоянное хранение данных compose.yaml, именованные volumes PostgreSQL и Redis Проверено
Готовность инфраструктуры docker compose ps: API, PostgreSQL и Redis имеют статус healthy PASS
Проверка контракта и структуры проекта python scripts/check_contract.py PASS
Проверка OpenAPI 3.1 и JSON Schema python scripts/validate_openapi.py PASS
Проверка публичного API python tests/smoke.py --base-url http://127.0.0.1:8080 PASS
Сохранение данных и действующей сессии после перезапуска python tests/persistence_windows.py --base-url http://127.0.0.1:8080 PASS
Нагрузочная проверка записи сообщений python tests/load.py: 674 успешных запроса, 0 ошибок, 64,002 запроса/с PASS
Проверка актуальности кэша после записи (read-after-write) python tests/cache_research.py, выполнено до и после перезапуска Redis PASS
Восстановление работы кэша после перезапуска Redis Перезапуск Redis и повторное чтение истории PASS
Конкурентная регистрация одинакового username 12 одновременных запросов: 1 успешное создание, 11 конфликтов; в БД осталась ровно 1 запись; grade5_checks.py Проверено: PASS
Атомарность создания чата и откат транзакции Принудительно вызвана ошибка добавления участника; после rollback запись чата не осталась в БД; grade5_checks.py Проверено: PASS
Истечение короткой сессии по TTL При TTL 3 секунды истёкшая сессия была отклонена; grade5_checks.py Проверено: PASS
Поведение при недоступности PostgreSQL При остановке PostgreSQL /health/ready вернул 503, защищённый запрос завершился отказом; grade5_checks.py Проверено: PASS
Исследовательский трек 1: согласованность кэша Проверены read-after-write до и после перезапуска Redis, конкурентное заполнение страницы и отсутствие SQL-чтений messages в холодной и тёплой группах Проверено: PASS
Исследовательский трек 1: сравнение SQL-запросов и защита от cache stampede 12 холодных и 12 тёплых параллельных запросов; 0 SELECT ... FROM messages в каждой группе; evidence/grade5-checks.txt и evidence/cache-stampede.json Проверено: PASS

Общий вывод по критериям

Основные функциональные компоненты лабораторной работы реализованы и запущены в Docker Compose. Проверены публичный API, OpenAPI-контракт, сохранение данных PostgreSQL и действующей Bearer-сессии после перезапуска сервисов, использование индекса истории на 10 009 сообщениях, нагрузочная запись сообщений и актуальность данных после записи.

Дополнительно успешно выполнены негативные и конкурентные сценарии: конкурентная регистрация, откат транзакции создания чата, истечение короткой сессии, отказ Redis, отказ PostgreSQL и конкурентные холодные/тёплые чтения кэша. Все шесть сценариев комплексного набора tests/grade5_checks.py --only all завершились с результатом PASS. В эксперименте cache stampede зафиксировано 0 SQL-запросов SELECT ... FROM messages как для 12 параллельных холодных запросов, так и для 12 параллельных запросов к прогретому кэшу.

Таким образом, функциональность, отказоустойчивое поведение в проверенных сценариях и выбранный исследовательский трек подтверждены воспроизводимыми тестами. Результаты относятся к локальному стенду Docker Compose и не являются гарантией производительности в промышленной среде.

6. Доказательства

В каталоге evidence/ сохранены результаты экспериментов:

  • load-10s.json — результаты нагрузочного теста записи сообщений.
  • cache-research.json — результаты исследования чтения истории до и после перезапуска Redis.
  • cache-stampede.json — результаты отдельного эксперимента конкурентного чтения кэша.
  • grade5-checks.txt — полный вывод комплексного набора из шести проверок.
  • check-contract.txt — результат проверки структуры и контракта.
  • openapi-validation.txt — результат проверки OpenAPI 3.1 и JSON Schema.
  • smoke.txt — результат проверки публичного API.
  • persistence-windows.txt — результат проверки сохранения данных и сессии после перезапуска.

Дополнительно выполнены проверки:

  • python scripts/check_contract.py — PASS.
  • python scripts/validate_openapi.py — PASS.
  • python tests/smoke.py --base-url http://127.0.0.1:8080 — PASS.
  • python tests/persistence_windows.py --base-url http://127.0.0.1:8080 — PASS.
  • docker compose ps — все три контейнера healthy.
  • docker compose exec redis redis-cli ping — PONG.
  • EXPLAIN (ANALYZE, BUFFERS) — основной запрос истории использует индекс.
  • docker-compose-ps.txt — состояние контейнеров Docker Compose.
  • grade5-checks.txt — полный протокол: все шесть проверок завершились с результатом PASS.

Комплексная проверка запускается командой:

python tests/grade5_checks.py --base-url http://127.0.0.1:8080 --only all

Результат полного запуска сохранён в evidence/grade5-checks.txt.

7. Ограничения

  • Redis — ускоряющий слой, PostgreSQL — долговременный источник истины.
  • Локальный Compose стенд не обеспечивает отказоустойчивость при потере самого Docker host.
  • Проверка восстановления после рестарта не равнозначна резервному копированию; отдельная процедура backup/restore не входит в выбранный трек.
  • Результаты нагрузочного и кэш-экспериментов относятся к локальному стенду, конкретной конфигурации и профилю запросов; их нельзя напрямую переносить на промышленную нагрузку.
  • Время холодной и тёплой групп в эксперименте cache stampede не является универсальным показателем ускорения. Основным подтверждённым результатом этого эксперимента является отсутствие SQL-чтений таблицы messages в обеих группах.
  • Локальный стенд не проверяет отказоустойчивость при потере Docker host и не заменяет резервное копирование и восстановление из backup.