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

630 lines
36 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Отчёт — лабораторная 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 | Сообщения |
Основные связи:
- Один пользователь может участвовать в нескольких чатах.
- Один чат может содержать нескольких участников.
- Один чат содержит множество сообщений.
- Каждое сообщение принадлежит определённому чату и имеет отправителя.
На уровне базы данных предусмотрены ограничения целостности.
В частности, составной внешний ключ:
```sql
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-хранилище.
### Гипотеза
Предполагается, что составной индекс:
```sql
(chat_id, created_at, id)
```
обеспечивает более эффективное получение истории сообщений, чем индекс:
```sql
(chat_id)
```
поскольку позволяет PostgreSQL читать сообщения в порядке сортировки без дополнительной операции `Sort`.
При этом составной индекс должен занимать больше места и увеличивать стоимость вставки сообщений.
### Условия проведения эксперимента
Исследование выполнялось с использованием PostgreSQL 16 в Docker.
Для исключения влияния экспериментов на рабочую базу была создана отдельная база:
```text
messenger_benchmark
```
В ней была воспроизведена схема основного приложения и сгенерирован тестовый набор сообщений.
Параметры исследования:
| Параметр | Значение |
|---|---|
| СУБД | PostgreSQL 16 |
| Количество сообщений | 120 000 |
| Количество чатов | 5 |
| Тип идентификаторов | UUID |
| Исследуемый запрос | История сообщений |
| Размер страницы | 50 сообщений |
| Глубокая страница | OFFSET 30 000 |
| Повторы измерений чтения | 5 для каждого варианта запроса |
| Повторы измерений записи | 5 для каждого варианта индекса |
| Объём одной вставки | 20 000 сообщений |
| Инструмент анализа | EXPLAIN ANALYZE, BUFFERS |
Точные характеристики процессора, объём RAM, ограничения Docker и параметры дисковой подсистемы отдельно не фиксировались.
Поэтому результаты рассматриваются как измерения в конкретном локальном окружении.
### Подготовка тестовых данных
Для генерации данных использовался SQL-скрипт:
```text
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** |
Такое распределение позволяет моделировать ситуацию, при которой часть чатов содержит значительно больше сообщений, чем остальные.
После генерации данных выполнялась команда:
```sql
ANALYZE messages;
```
Она обновляет статистику PostgreSQL, используемую планировщиком запросов.
### Исследуемые варианты индексации
**Вариант A — простой индекс**
```sql
CREATE INDEX idx_messages_chat_only
ON messages(chat_id);
```
Индекс позволяет находить сообщения определённого чата, однако не обеспечивает их сортировку по времени создания.
**Вариант B — составной индекс**
```sql
CREATE INDEX idx_messages_history
ON messages(chat_id, created_at, id);
```
Индекс позволяет одновременно фильтровать сообщения по чату и читать их в порядке временных меток и идентификаторов.
В обоих вариантах сохраняется первичный индекс по `id`.
### Запрос первой страницы
Исследовался следующий запрос:
```sql
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 сообщений самого большого чата.
Для анализа использовалась команда:
```sql
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`, после чего выполнял дополнительную сортировку.
При составном индексе использовался:
```text
Index Scan Backward using idx_messages_history
```
Дополнительная сортировка не требовалась.
### Запрос глубокой страницы
Для проверки работы пагинации исследовался запрос:
```sql
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 выполнял сортировку большого количества строк.
В первоначальном измерении план содержал:
```text
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 раза |
Результаты показали значительное преимущество составного индекса.
Однако отдельные запуски могут зависеть от состояния кэша и фоновой активности системы. Поэтому были проведены повторные измерения.
### Повторные измерения чтения
Для автоматизации использовался скрипт:
```text
benchmark_read_repeat.sql
```
Каждый из четырёх вариантов запроса выполнялся пять раз.
Время выполнения извлекалось из:
```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 |
По медианным значениям:
**Первая страница:**
```text
11,617 / 0,075 ≈ 154,9
```
Составной индекс оказался быстрее приблизительно в **154,9 раза**.
**Глубокая страница:**
```text
20,133 / 5,481 ≈ 3,67
```
Составной индекс оказался быстрее приблизительно в **3,67 раза**.
Таким образом, гипотеза об ускорении чтения истории сообщений подтвердилась.
### Исследование стоимости записи
Ускорение чтения не является бесплатным: PostgreSQL должен поддерживать индекс при добавлении новых записей.
Для исследования использовались две экспериментальные таблицы:
```text
bench_simple
bench_composite
```
Они содержали одинаковые поля и первичные индексы.
Различие заключалось в дополнительном индексе:
```sql
-- Первый вариант
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%.
### Повторные измерения записи
Для уточнения результатов использовался скрипт:
```text
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** |
По медианам:
```text
(118,510 - 85,651) / 85,651 × 100% ≈ 38,4%
```
Составной индекс увеличил время вставки приблизительно на **38,4%**.
Наблюдался значительный разброс измерений. В третьем повторе составной индекс даже показал меньшее время, чем простой.
Это свидетельствует о влиянии условий выполнения и не позволяет считать полученное процентное замедление универсальной константой.
Тем не менее медианные результаты согласуются с гипотезой о дополнительных затратах на запись.
### Сравнение занимаемого пространства
Для оценки размеров индексов использовалась функция PostgreSQL:
```sql
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.
### Создание резервной копии
Для создания архива использовалась команда:
```powershell
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:
```powershell
docker volume create messenger_recovery_data
```
После этого запущен новый контейнер PostgreSQL 16:
```powershell
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 проверялась командой:
```powershell
docker exec messenger-recovery pg_isready `
-U messenger `
-d messenger_recovery
```
Получен ответ:
```text
accepting connections
```
### Восстановление в новое хранилище
Архив был скопирован в контейнер:
```powershell
docker cp .\messenger_benchmark.dump `
messenger-recovery:/tmp/backup.dump
```
После этого выполнено восстановление:
```powershell
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 |
Все количества совпали.
### Проверка целостности сообщений
Для проверки содержимого сообщений была рассчитана контрольная сумма на основе следующих полей:
```text
id
chat_id
sender_id
text
created_at
```
Использовалось выражение:
```sql
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;
```
Контрольная сумма исходной базы:
```text
6bd9c28bb070f93e19a2ab45ea34bbbf
```
Контрольная сумма восстановленной базы:
```text
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-запросов и восстановления данных. Основная гипотеза исследования подтверждена: составная индексация существенно улучшает чтение истории сообщений, но увеличивает стоимость записи и хранения.**