36 KiB
Отчёт — лабораторная 2
- Автор, группа: Хуцаева Айса, БПИ2302
- Целевая оценка; выбранный трек 5, если нужен: 5, трек 2
Архитектура и принятые решения
Общая архитектура
Приложение реализовано как монолитный backend на Spring Boot. Архитектура включает:
- Клиент, отправляющий HTTP-запросы.
- Spring Boot, принимающий запросы и реализующий бизнес-логику.
- PostgreSQL, хранящий постоянные данные.
- Redis, хранящий пользовательские сессии.
- 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 из резервной копии в новое независимое хранилище. Необходимо было:
- Создать резервную копию.
- Восстановить базу.
- Измерить время восстановления.
- Проверить количество записей.
- Проверить содержимое сообщений.
- Убедиться, что восстановление возможно в отдельном 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-запросов и восстановления данных. Основная гипотеза исследования подтверждена: составная индексация существенно улучшает чтение истории сообщений, но увеличивает стоимость записи и хранения.