Files
mtusi2026lab2/REPORT.md
T
2026-10-13 15:27:39 +03:00

36 KiB
Raw Blame History

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

  • Автор, группа: Хуцаева Айса, БПИ2302
  • Целевая оценка; выбранный трек 5, если нужен: 5, трек 2

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

Общая архитектура

Приложение реализовано как монолитный backend на Spring Boot. Архитектура включает:

  1. Клиент, отправляющий HTTP-запросы.
  2. Spring Boot, принимающий запросы и реализующий бизнес-логику.
  3. PostgreSQL, хранящий постоянные данные.
  4. Redis, хранящий пользовательские сессии.
  5. Docker Compose, обеспечивающий запуск инфраструктурных компонентов.

Модель данных

В PostgreSQL используются основные таблицы:

Таблица Назначение
users Учётные записи пользователей
chats Чаты
chat_members Связь пользователей и чатов
messages Сообщения

Основные связи:

  • Один пользователь может участвовать в нескольких чатах.
  • Один чат может содержать нескольких участников.
  • Один чат содержит множество сообщений.
  • Каждое сообщение принадлежит определённому чату и имеет отправителя.

На уровне базы данных предусмотрены ограничения целостности.

В частности, составной внешний ключ:

FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members(chat_id, user_id)

обеспечивает, что отправитель сообщения является участником соответствующего чата. Также используется проверка содержимого текста сообщения: оно не должно быть пустым, состоять только из пробелов или превышать установленную допустимую длину. Это позволяет предотвращать некорректные записи независимо от того, через какой программный компонент выполняется обращение к базе.

Источник истины

Основным источником истины для постоянных данных является PostgreSQL.

В нём хранятся пользователи, чаты, участники и сообщения.

Redis не используется как основное хранилище сообщений. Его назначение — хранение состояния пользовательских сессий.

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

Хранение сессий

Redis используется для хранения пользовательских сессий с ограниченным временем жизни. В ходе проверки контролировались:

  • наличие ключа сессии в Redis;
  • положительное значение TTL;
  • сохранение сессии после перезапуска Redis;
  • возможность использовать ранее выданный токен после восстановления инфраструктуры. Проверка проводилась не только после обычного перезапуска, но и после принудительного пересоздания контейнера Redis. После восстановления ранее выданный токен продолжал работать, а защищённый запрос возвращал HTTP 200. Это подтверждает сохранение состояния сессии в проверенной конфигурации Redis.

Доказательства выполнения критериев

Критерий Команда или сценарий Наблюдаемый результат Доказательство
Сборка приложения .\mvnw.cmd clean package Требует фиксации результата чистой сборки pom.xml, Maven Wrapper
Публичный smoke Команда проекта, например make test, если цель существует Требует отдельного подтверждения README, конфигурация тестового запуска
Интеграционное тестирование .\mvnw.cmd test 12 тестов успешно пройдены Интеграционные тесты проекта
Проверка конкурентной регистрации Параллельные запросы регистрации Сценарий проверен интеграционным тестом Тест регистрации
Транзакционный rollback Искусственная ошибка в транзакционной операции Проверен откат изменений Интеграционный тест rollback
Ошибка PostgreSQL Моделирование исключения доступа к БД HTTP 503 InfrastructureFailureIntegrationTest
Ошибка Redis Моделирование отказа Redis Контролируемая обработка инфраструктурной ошибки InfrastructureFailureIntegrationTest
Сохранение сессий Перезапуск и пересоздание Redis Сессия сохранилась, защищённый запрос вернул 200 Логи Docker, Redis CLI, HTTP-проверка
Наличие TTL сессии Проверка TTL ключа Redis TTL положительный Redis CLI
Нагрузка более 100 000 сообщений Запуск benchmark_seed.sql 120 000 сообщений benchmark_seed.sql
Неравномерное распределение SELECT ... GROUP BY chat_id 60k / 30k / 15k / 10k / 5k SQL-вывод
Сравнение индексов EXPLAIN (ANALYZE, BUFFERS) Получены планы для двух вариантов benchmark_read_repeat.sql
Повторные измерения чтения 5 запусков каждого запроса Рассчитаны медианы benchmark_read_repeat.sql
Измерение стоимости записи Вставка 20 000 сообщений Получены времена для двух индексов benchmark_write.sql
Повторные измерения записи 5 запусков для каждого индекса Рассчитаны медианы benchmark_write_repeat.sql
Сравнение размера индексов pg_indexes_size() 928 КБ и 1944 КБ SQL-вывод
Создание backup pg_dump -Fc Получен архив 5,43 МБ messenger_benchmark.dump
Восстановление pg_restore Успешное восстановление в отдельный контейнер Команда и журнал восстановления
Новое хранилище Отдельный PostgreSQL и Docker volume Использован messenger_recovery_data docker run, docker volume
Проверка количества записей SQL COUNT(*) 120 000 сообщений в обеих БД SQL-вывод
Проверка целостности Контрольная сумма сообщений Контрольные суммы совпали SQL-вывод

Для публичной проверки рекомендуется сохранять текстовый вывод команд в файлы доказательств. Фактически полученные результаты экспериментов приведены далее.


Экспериментальная часть — Track 2

Цель исследования

Исследование направлено на определение влияния структуры индекса PostgreSQL на скорость получения истории сообщений и стоимость операций записи. Дополнительно проверяется возможность восстановления данных из резервной копии в независимое PostgreSQL-хранилище.

Гипотеза

Предполагается, что составной индекс:

(chat_id, created_at, id)

обеспечивает более эффективное получение истории сообщений, чем индекс:

(chat_id)

поскольку позволяет PostgreSQL читать сообщения в порядке сортировки без дополнительной операции Sort. При этом составной индекс должен занимать больше места и увеличивать стоимость вставки сообщений.

Условия проведения эксперимента

Исследование выполнялось с использованием PostgreSQL 16 в Docker. Для исключения влияния экспериментов на рабочую базу была создана отдельная база:

messenger_benchmark

В ней была воспроизведена схема основного приложения и сгенерирован тестовый набор сообщений.

Параметры исследования:

Параметр Значение
СУБД PostgreSQL 16
Количество сообщений 120 000
Количество чатов 5
Тип идентификаторов UUID
Исследуемый запрос История сообщений
Размер страницы 50 сообщений
Глубокая страница OFFSET 30 000
Повторы измерений чтения 5 для каждого варианта запроса
Повторы измерений записи 5 для каждого варианта индекса
Объём одной вставки 20 000 сообщений
Инструмент анализа EXPLAIN ANALYZE, BUFFERS

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

Подготовка тестовых данных

Для генерации данных использовался SQL-скрипт:

benchmark_seed.sql

Были созданы пять чатов с неравномерным количеством сообщений.

Чат Количество сообщений
Benchmark Chat 101 60 000
Benchmark Chat 102 30 000
Benchmark Chat 103 15 000
Benchmark Chat 104 10 000
Benchmark Chat 105 5 000
Всего 120 000

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

После генерации данных выполнялась команда:

ANALYZE messages;

Она обновляет статистику PostgreSQL, используемую планировщиком запросов.

Исследуемые варианты индексации

Вариант A — простой индекс

CREATE INDEX idx_messages_chat_only
ON messages(chat_id);

Индекс позволяет находить сообщения определённого чата, однако не обеспечивает их сортировку по времени создания.

Вариант B — составной индекс

CREATE INDEX idx_messages_history
ON messages(chat_id, created_at, id);

Индекс позволяет одновременно фильтровать сообщения по чату и читать их в порядке временных меток и идентификаторов. В обоих вариантах сохраняется первичный индекс по id.

Запрос первой страницы

Исследовался следующий запрос:

SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id =
    '00000000-0000-4000-8000-000000000101'
ORDER BY created_at DESC, id DESC
LIMIT 50;

Запрос получает последние 50 сообщений самого большого чата. Для анализа использовалась команда:

EXPLAIN (ANALYZE, BUFFERS)
SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id =
    '00000000-0000-4000-8000-000000000101'
ORDER BY created_at DESC, id DESC
LIMIT 50;

При простом индексе PostgreSQL использовал Index Scan, после чего выполнял дополнительную сортировку. При составном индексе использовался:

Index Scan Backward using idx_messages_history

Дополнительная сортировка не требовалась.

Запрос глубокой страницы

Для проверки работы пагинации исследовался запрос:

SELECT id, chat_id, sender_id, text, created_at
FROM messages
WHERE chat_id =
    '00000000-0000-4000-8000-000000000101'
ORDER BY created_at DESC, id DESC
LIMIT 50 OFFSET 30000;

При использовании простого индекса PostgreSQL выполнял сортировку большого количества строк. В первоначальном измерении план содержал:

Sort Method: external merge
Disk: 6232kB

Это означает, что операция сортировки использовала временное дисковое пространство. Составной индекс позволил отказаться от отдельной сортировки, но PostgreSQL по-прежнему должен был пройти 30 050 записей для получения глубокой страницы.

Первоначальные результаты чтения

Запрос Простой индекс Составной индекс Ускорение
Последние 50 сообщений 12,948 мс 0,067 мс 193,3 раза
OFFSET 30 000 21,575 мс 4,532 мс 4,76 раза

Результаты показали значительное преимущество составного индекса. Однако отдельные запуски могут зависеть от состояния кэша и фоновой активности системы. Поэтому были проведены повторные измерения.

Повторные измерения чтения

Для автоматизации использовался скрипт:

benchmark_read_repeat.sql

Каждый из четырёх вариантов запроса выполнялся пять раз. Время выполнения извлекалось из:

EXPLAIN (ANALYZE, BUFFERS, FORMAT JSON)

После измерений рассчитывалась медиана.

Результаты:

Вариант Запрос Медиана, мс Минимум, мс Максимум, мс
Простой индекс Первая страница 11,617 10,808 25,586
Составной индекс Первая страница 0,075 0,029 0,590
Простой индекс OFFSET 30 000 20,133 18,452 20,669
Составной индекс OFFSET 30 000 5,481 4,253 14,644

По медианным значениям: Первая страница:

11,617 / 0,075 ≈ 154,9

Составной индекс оказался быстрее приблизительно в 154,9 раза.

Глубокая страница:

20,133 / 5,481 ≈ 3,67

Составной индекс оказался быстрее приблизительно в 3,67 раза. Таким образом, гипотеза об ускорении чтения истории сообщений подтвердилась.

Исследование стоимости записи

Ускорение чтения не является бесплатным: PostgreSQL должен поддерживать индекс при добавлении новых записей. Для исследования использовались две экспериментальные таблицы:

bench_simple
bench_composite

Они содержали одинаковые поля и первичные индексы. Различие заключалось в дополнительном индексе:

-- Первый вариант
CREATE INDEX bench_simple_chat_idx
ON bench_simple(chat_id);

-- Второй вариант
CREATE INDEX bench_composite_history_idx
ON bench_composite(chat_id, created_at, id);

В каждую таблицу вставлялись одинаковые 20 000 сообщений. Первоначальный результат:

Вариант Время вставки
Простой индекс 53,923 мс
Составной индекс 72,590 мс

Составной индекс увеличил время вставки приблизительно на 34,6%.

Повторные измерения записи

Для уточнения результатов использовался скрипт:

benchmark_write_repeat.sql

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

Результаты:

Повтор Простой индекс, мс Составной индекс, мс
1 86,599 153,388
2 89,914 96,068
3 85,651 56,530
4 65,345 118,510
5 54,091 138,235
Медиана 85,651 118,510

По медианам:

(118,510 - 85,651) / 85,651 × 100% ≈ 38,4%

Составной индекс увеличил время вставки приблизительно на 38,4%. Наблюдался значительный разброс измерений. В третьем повторе составной индекс даже показал меньшее время, чем простой. Это свидетельствует о влиянии условий выполнения и не позволяет считать полученное процентное замедление универсальной константой. Тем не менее медианные результаты согласуются с гипотезой о дополнительных затратах на запись.

Сравнение занимаемого пространства

Для оценки размеров индексов использовалась функция PostgreSQL:

pg_indexes_size()

Результаты:

Показатель Простой индекс Составной индекс
Количество сообщений 20 000 20 000
Размер таблицы 2288 КБ 2288 КБ
Размер всех индексов 928 КБ 1944 КБ

Размер всех индексов при составной индексации оказался примерно в 2,09 раза больше. Указанные значения включают первичный индекс и дополнительный исследуемый индекс. Размер самой таблицы в первоначальном эксперименте не изменился.

Общий результат исследования индексов

Характеристика Простой индекс Составной индекс
Первая страница, медиана 11,617 мс 0,075 мс
Глубокая страница, медиана 20,133 мс 5,481 мс
Вставка 20 000 сообщений, медиана 85,651 мс 118,510 мс
Размер всех индексов 928 КБ 1944 КБ
Дополнительная сортировка Да Нет

Вывод: для мессенджера предпочтительным является составной индекс (chat_id, created_at, id). Он значительно ускоряет основной сценарий — чтение истории сообщений в хронологическом порядке. При этом его использование увеличивает стоимость записи и требования к дисковому пространству. В условиях проведённого исследования выигрыш при чтении признан более существенным, чем дополнительные затраты на запись.


Резервное копирование и восстановление PostgreSQL

Цель эксперимента

Цель — проверить возможность восстановления данных PostgreSQL из резервной копии в новое независимое хранилище. Необходимо было:

  1. Создать резервную копию.
  2. Восстановить базу.
  3. Измерить время восстановления.
  4. Проверить количество записей.
  5. Проверить содержимое сообщений.
  6. Убедиться, что восстановление возможно в отдельном PostgreSQL-контейнере с собственным Docker volume.

Создание резервной копии

Для создания архива использовалась команда:

docker compose exec postgres pg_dump `
    -U messenger `
    -d messenger_benchmark `
    -Fc `
    -f /tmp/messenger_benchmark.dump

Формат -Fc означает использование специального архивного формата PostgreSQL, поддерживаемого pg_restore. После создания архив был скопирован на локальную машину. Размер полученного файла составил приблизительно 5,43 МБ.

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

Первоначально резервная копия была восстановлена в отдельную базу messenger_restored внутри существующего PostgreSQL-контейнера. Измеренное время:

1,673 секунды.

После восстановления было получено 120 000 сообщений. Распределение по пяти чатам совпало с исходной базой. Также были проверены отдельные сообщения с порядковыми номерами 1, 30 000 и 60 000 в самом большом чате. Все контрольные сообщения присутствовали с ожидаемыми временными метками. Однако такое восстановление не проверяет независимость от исходного контейнера и его постоянного хранилища. Поэтому был проведён дополнительный эксперимент.

Создание независимого хранилища

Создан отдельный Docker volume:

docker volume create messenger_recovery_data

После этого запущен новый контейнер PostgreSQL 16:

docker run -d `
    --name messenger-recovery `
    -e POSTGRES_USER=messenger `
    -e POSTGRES_PASSWORD=<ЛОКАЛЬНЫЙ_ПАРОЛЬ> `
    -e POSTGRES_DB=messenger_recovery `
    -v messenger_recovery_data:/var/lib/postgresql/data `
    postgres:16-alpine

Пароль приведён как заполнитель и не является секретом из конфигурации. Новый контейнер использовал отдельное постоянное хранилище, не связанное с volume исходной базы. Готовность PostgreSQL проверялась командой:

docker exec messenger-recovery pg_isready `
    -U messenger `
    -d messenger_recovery

Получен ответ:

accepting connections

Восстановление в новое хранилище

Архив был скопирован в контейнер:

docker cp .\messenger_benchmark.dump `
    messenger-recovery:/tmp/backup.dump

После этого выполнено восстановление:

docker exec messenger-recovery pg_restore `
    -U messenger `
    -d messenger_recovery `
    --no-owner `
    --no-privileges `
    --exit-on-error `
    /tmp/backup.dump

Для измерения времени использовался Measure-Command PowerShell. Полученный результат: 1024,5693 мс, или приблизительно 1,025 секунды. Измерение включает запуск команды Docker CLI и работу pg_restore.

Проверка количества записей

После восстановления сравнивалось количество записей в основных таблицах.

Таблица Исходная база Восстановленная база
users 1 1
chats 5 5
chat_members 5 5
messages 120 000 120 000

Все количества совпали.

Проверка целостности сообщений

Для проверки содержимого сообщений была рассчитана контрольная сумма на основе следующих полей:

id
chat_id
sender_id
text
created_at

Использовалось выражение:

SELECT md5(
    string_agg(
        md5(
            id::text || '|' ||
            chat_id::text || '|' ||
            sender_id::text || '|' ||
            text || '|' ||
            created_at::text
        ),
        '' ORDER BY id
    )
) AS messages_checksum
FROM messages;

Контрольная сумма исходной базы:

6bd9c28bb070f93e19a2ab45ea34bbbf

Контрольная сумма восстановленной базы:

6bd9c28bb070f93e19a2ab45ea34bbbf

Контрольные суммы полностью совпали. Таким образом, в пределах выбранных полей и метода проверки содержимое всех 120 000 сообщений соответствует исходной базе.

Границы потери данных

Использованный механизм pg_dump создаёт согласованный логический снимок базы данных. Если после создания резервной копии в приложение поступают новые сообщения, они не включаются в уже созданный архив. Следовательно, при восстановлении только из данного архива могут быть потеряны изменения, выполненные после момента снимка. Для рассматриваемого способа:

  • RPO зависит от времени между созданием последней резервной копии и отказом.
  • RTO включает подготовку инфраструктуры, восстановление данных, проверки и возвращение приложения в эксплуатацию.

Измеренные 1,025 секунды характеризуют только выполнение операции восстановления в тестовом окружении и не являются полным RTO системы. Для уменьшения возможной потери данных в будущем можно использовать архивирование WAL и Point-in-Time Recovery.

Вывод по восстановлению

Эксперимент подтвердил, что резервная копия PostgreSQL может быть восстановлена в независимый контейнер с новым постоянным хранилищем. После восстановления:

  • сохранено количество записей;
  • восстановлены связи между основными сущностями;
  • совпали контрольные суммы сообщений;
  • измерено время восстановления.

Таким образом, требование выбранного трека по восстановлению данных выполнено в пределах проведённого тестового сценария.


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

Помимо исследования PostgreSQL, в лабораторной работе проверялось поведение приложения при инфраструктурных сбоях.

Воздействие Ожидаемое поведение Наблюдаемый результат Восстановление / потеря данных
Моделирование ошибки PostgreSQL Контролируемый ответ сервера HTTP 503 в интеграционном тесте Реальное время восстановления не измерялось
Моделирование ошибки Redis Контролируемая обработка ошибки зависимости Сценарий успешно проверен тестом Реальное время восстановления не измерялось
Перезапуск Redis Сохранение пользовательской сессии Сессия осталась доступной Потеря проверенной сессии не обнаружена
Принудительное пересоздание Redis Сохранение состояния при использовании постоянного хранилища Токен продолжил работать, HTTP 200 Потеря проверенной сессии не обнаружена
Ошибка внутри транзакции PostgreSQL Откат изменений Интеграционный тест пройден Некорректное частичное сохранение не выявлено
Восстановление PostgreSQL из backup Восстановление исходных записей 120 000 сообщений восстановлены 1,025 с на операцию pg_restore; контрольные суммы совпали

Следует различать моделирование ошибок через тестовые зависимости и реальное отключение инфраструктуры. Интеграционные тесты с искусственными исключениями проверяют поведение программного кода, но не позволяют сделать вывод о фактическом времени восстановления PostgreSQL или Redis после аварии.


Итоговый вывод

В ходе лабораторной работы № 2 была разработана и исследована серверная часть мессенджера на Java и Spring Boot с использованием PostgreSQL и Redis. Реализована работа с пользователями, чатами и сообщениями, организовано хранение пользовательских сессий, предусмотрены ограничения целостности данных и централизованная обработка ошибок. Успешно пройдены 12 интеграционных тестов, включая сценарии конкурентной регистрации, транзакционного отката и моделирования отказов инфраструктурных зависимостей. Для выполнения требований оценки «5» по треку 2 была создана экспериментальная база с 120 000 сообщениями, распределёнными между пятью чатами. Проведено сравнение двух вариантов индексации PostgreSQL. Установлено, что составной индекс (chat_id, created_at, id) ускоряет получение первой страницы истории сообщений приблизительно в 154,9 раза, а глубокой страницы — в 3,67 раза по медианам повторных измерений. При этом медианная стоимость вставки 20 000 сообщений увеличилась на 38,4%, а общий размер индексов — примерно в 2,09 раза. Дополнительно была создана резервная копия PostgreSQL и выполнено восстановление в отдельный контейнер с новым Docker volume. Время операции восстановления составило приблизительно 1,025 секунды. Количество записей и контрольные суммы всех 120 000 сообщений совпали. Таким образом, лабораторная работа продемонстрировала практическое применение транзакций, интеграционного тестирования, анализа планов SQL-запросов и восстановления данных. Основная гипотеза исследования подтверждена: составная индексация существенно улучшает чтение истории сообщений, но увеличивает стоимость записи и хранения.