54 KiB
Отчёт — лабораторная 3
- Автор, группа: Станислав Травкин, БВТ2304
- Целевая оценка: 5
- Текущий этап: реализованы и исследованы критерии оценок 3, 4 и 5; выполняется финальная проверка
- Выбранный трек оценки 5: цена масштабирования
- Commit/PR: будет указан после публикации
- Использованные источники: документация Docker Compose, FastAPI, SQLAlchemy, Alembic, PostgreSQL, Redis, Nginx; материалы лабораторной работы
- Помощь ИИ: ChatGPT использовался для обсуждения архитектуры, разработки, отладки и подготовки документации
Запуск из чистого clone
Для запуска необходимы Docker Engine с поддержкой Docker Compose, Git и Python 3.9 или новее.
Приложение работает в контейнерах. Локальная установка PostgreSQL и Redis не требуется.
Используемые образы:
- Python 3.13.15-slim
- PostgreSQL 17.6
- Redis 8.2.2
- Nginx 1.29-alpine
Из корневого каталога проекта выполнить:
./scripts/bootstrap.sh
docker compose config --quiet
docker compose up -d --build
docker compose ps -a
Скрипт bootstrap.sh создаёт локальные файлы секретов, если они отсутствуют, и проверяет конфигурацию Compose. Значения существующих секретов не перезаписываются.
Используются файлы:
secrets/postgres_password— пароль PostgreSQLsecrets/database_url— строка подключения к PostgreSQLsecrets/cache_url— строка подключения к Redis
Секреты исключены из Git.
Миграции Alembic выполняются отдельным сервисом migrate перед запуском API. Успешное завершение контейнера миграций отображается как Exited (0).
После запуска обе API-реплики должны иметь статус healthy, PostgreSQL и Redis — healthy, Nginx — Up.
Единая точка входа:
http://localhost:8080
Основные проверки:
make check
make validate
make test
make test-persistence ACTION_SCRIPT=./scripts/restart.sh
make test-failover ACTION_SCRIPT=./scripts/stop-one.sh
python3 tests/test_concurrent_idempotency.py
python3 tests/test_failover_concurrent_idempotency.py
Для локальных Python-проверок требуется установить зависимости из requirements-dev.txt, если они ещё не установлены.
После failover-тестов восстановить реплики:
docker compose start api-1 api-2
Безопасная остановка стенда с сохранением данных:
docker compose down
Повторный запуск:
docker compose up -d --build
Для намеренного удаления учебных данных и постоянных Docker volumes используется:
docker compose down -v
Последняя команда удаляет данные PostgreSQL и Redis и не применяется при обычном перезапуске.
Архитектура и решения
Используется Docker Compose со следующими компонентами:
Client
|
v
Nginx :8080
|
+---- API-1 :8080
|
+---- API-2 :8080
|
+---- PostgreSQL
|
+---- Redis
Nginx является единой публичной точкой входа. API-реплики не публикуют порты на хосте и доступны через внутреннюю сеть Compose.
Обе реплики используют одну PostgreSQL и один Redis.
PostgreSQL хранит постоянные данные приложения и информацию, необходимую для общей идемпотентности отправки сообщений. Redis хранит пользовательские сессии с TTL 3600 секунд.
В API не используются локальные пользовательские сессии, поэтому запросы одного пользователя могут обслуживаться разными репликами без повторной авторизации.
Каждая реплика возвращает заголовок X-Instance-Id, позволяющий определить обработавший запрос экземпляр.
Для отправки сообщений используется обязательный Idempotency-Key. Повторная отправка с тем же ключом не должна создавать второе сообщение. Согласованность между репликами обеспечивается общим PostgreSQL, транзакциями и механизмом advisory locks.
Миграции выполняются отдельным контейнером, что исключает одновременный запуск Alembic несколькими API-репликами.
В Nginx настроены два backend-сервера, динамическое разрешение DNS-имён контейнеров через Docker DNS, таймауты подключения и обработки запросов, а также повторная попытка при отдельных ошибках upstream.
Из лабораторной 2 перенесены основная реализация API, PostgreSQL, миграции, авторизация и работа с сообщениями. В лабораторной 3 добавлены балансировка, две API-реплики, идентификация экземпляров и общая идемпотентность.
Файл .env.example является шаблоном задания. Фактическая конфигурация контейнеров задаётся в compose.yaml; подключения к PostgreSQL и Redis передаются через файлы секретов.
Проверки работоспособности и готовности
В приложении реализованы два endpoint:
GET /health/live— проверяет работоспособность процесса API.GET /health/ready— проверяет доступность PostgreSQL и Redis.
При недоступности необходимой зависимости /health/ready возвращает HTTP 503.
Для API также настроен Docker HEALTHCHECK, обращающийся к /health/ready.
Это позволяет различать работающий процесс и экземпляр, готовый обслуживать запросы.
Таймауты и завершение работы
Для подключения к PostgreSQL и Redis заданы ограничения времени ожидания. В Nginx настроены таймауты подключения, чтения и отправки запросов.
Для API установлен stop_grace_period: 15s.
При получении SIGTERM сервер Uvicorn завершает приложение штатно. В обработчике lifespan закрываются клиент Redis и пул соединений SQLAlchemy.
При ручной остановке api-1 в логах наблюдались сообщения об успешном завершении приложения и серверного процесса.
Ограничения ресурсов
Для каждой API-реплики заданы ограничения:
- CPU: 1
- RAM: 512 MiB
Проверка через docker inspect подтвердила:
NanoCpus = 1000000000Memory = 536870912StopTimeout = 15
Ограничения применяются к каждой реплике отдельно. При изменении количества реплик суммарный ресурсный бюджет также изменяется, если не корректировать лимиты.
Для исследования цены масштабирования на оценку 5 потребуется зафиксировать общий бюджет CPU/RAM для сравниваемых конфигураций.
Секреты и сетевой доступ
API запускается от непривилегированного пользователя appuser с UID 10001. PostgreSQL использует пользователя postgres с UID 999.
API, PostgreSQL и Redis не публикуют порты на хосте. Внешний порт 8080 опубликован только у Nginx.
Секреты хранятся в локальном каталоге secrets/, исключённом из Git.
Скрипт bootstrap.sh устанавливает права:
700для каталогаsecrets/644для файлов секретов
Каталог недоступен другим обычным пользователям хоста. При этом файлы с правами 644 после монтирования в контейнер доступны для чтения согласно правам файловой системы.
Это ограничение выбранной схемы Docker Compose с файловыми bind mounts. Для более строгой изоляции секретов необходим другой способ их предоставления контейнерам.
Доказательства критериев
| Критерий | Команда или сценарий | Наблюдаемый результат | Доказательство |
|---|---|---|---|
| Публичный smoke | make test |
PASS | evidence/smoke.txt |
| Структура проекта | make check |
PASS | Вывод проверки |
| OpenAPI | make validate |
PASS | Вывод проверки |
| Две API-реплики | docker compose ps -a |
Обе реплики healthy | evidence/compose-status.txt |
| Общая сессия | make test-failover |
Сессия сохраняется после отказа реплики | evidence/failover.txt |
| Отказ реплики на оценку 3 | make test-failover ACTION_SCRIPT=./scripts/stop-one.sh |
55 успешных записей, 4 неудачные попытки, восстановление за 1,327 с | evidence/failover.txt |
| Сохранность данных | make test-persistence ACTION_SCRIPT=./scripts/restart.sh |
PASS | evidence/persistence.txt |
| Конкурентная идемпотентность | python3 tests/test_concurrent_idempotency.py |
20 запросов, 1 уникальный ID, 1 сообщение в истории | evidence/idempotency.txt |
| Базовая нагрузка | tests/load.py, 30 с, 8 клиентов |
199,148 RPS, 0 ошибок | evidence/load-baseline.json |
Остановка api-1 под нагрузкой |
tests/load.py, 45 с, 8 клиентов |
130,833 RPS, 0 ошибок | evidence/load-failover-api1.json |
Остановка api-2 под нагрузкой |
tests/load.py, 45 с, 8 клиентов |
133,351 RPS, 0 ошибок | evidence/load-failover-api2.json |
Failover api-1 |
make test-failover |
PASS, восстановление за 1,311 с | evidence/failover-grade4-api1.txt |
Failover api-2 |
make test-failover |
PASS, восстановление за 1,339 с | evidence/failover-grade4-second.txt |
| Идемпотентность при отказе | python3 tests/test_failover_concurrent_idempotency.py |
20 запросов, 1 сообщение, PASS | evidence/failover-concurrent-idempotency.txt |
| Rolling replacement | Поочерёдное пересоздание API под нагрузкой | 16927 успешных запросов, 1 ошибка | evidence/load-rolling.json |
| Ограничения CPU/RAM | docker inspect |
1 CPU и 512 MiB на реплику | Результат проверки |
| Закрытые внутренние порты | docker compose ps |
На хост опубликован только порт Nginx | Результат проверки |
| Корректное завершение | docker compose stop api-1 |
Штатное завершение Uvicorn | Логи контейнера |
Эксперименты и отказы
Оценка 3 — отказ API-реплики
Команда:
make test-failover ACTION_SCRIPT=./scripts/stop-one.sh
Полученные результаты:
- Наблюдаемых реплик до отказа: 2
- Успешных записей: 55
- Неудачных попыток: 4
- Время до первого успешного восстановления: 1,327 с
- Подтверждённые данные: сохранены
- Существующая сессия: сохранена
Дополнительно вручную проверена остановка каждой реплики с восстановлением предыдущей. В обоих случаях оставшаяся реплика продолжала обслуживать запросы через Nginx.
Оценка 3 — сохранность данных
Команда:
make test-persistence ACTION_SCRIPT=./scripts/restart.sh
Результат: PASS.
После перезапуска PostgreSQL, Redis и API подтверждённые данные и существующая сессия остались доступными.
Оценка 3 — конкурентная идемпотентность
Команда:
python3 tests/test_concurrent_idempotency.py
Результаты:
- Параллельных запросов: 20
- Уникальных идентификаторов сообщений: 1
- Наблюдаемые реплики:
api-1,api-2 - Совпадающих сообщений в истории: 1
- Итог: PASS
Таким образом, конкурентные запросы с одинаковым ключом не создали дублирующих сообщений.
Оценка 4 — базовая нагрузка
Команда:
python3 tests/load.py --duration 30 --concurrency 8 --output evidence/load-baseline.json
Результаты:
| Показатель | Значение |
|---|---|
| Продолжительность | 30,038 с |
| Успешные запросы | 5982 |
| Ошибки | 0 |
| Пропускная способность | 199,148 RPS |
| p50 | 33,537 мс |
| p95 | 86,622 мс |
| p99 | 201,671 мс |
Полученные значения используются как базовый ориентир для сравнения с экспериментами при остановке реплик.
Оценка 4 — последовательная остановка реплик под нагрузкой
Для проверки устойчивости выполнялись отдельные нагрузочные испытания с последовательной остановкой api-1 и api-2.
В каждом эксперименте нагрузка создавалась восемью параллельными клиентами. Примерно через 10 секунд после начала испытания останавливалась одна из реплик.
После завершения испытания реплика восстанавливалась перед следующим экспериментом.
| Сценарий | Продолжительность | Успешные запросы | Ошибки | RPS | p50 | p95 | p99 |
|---|---|---|---|---|---|---|---|
| Без отказа | 30,038 с | 5982 | 0 | 199,148 | 33,537 мс | 86,622 мс | 201,671 мс |
Остановка api-1 |
45,073 с | 5897 | 0 | 130,833 | 54,133 мс | 112,499 мс | 216,195 мс |
Остановка api-2 |
45,084 с | 6012 | 0 | 133,351 | 52,247 мс | 115,109 мс | 208,774 мс |
Доказательства:
evidence/load-baseline.jsonevidence/load-failover-api1.jsonevidence/load-failover-api2.json
В обоих сценариях остановки приложение продолжило обслуживать запросы через оставшуюся реплику.
Ошибок в этих двух нагрузочных прогонах не зафиксировано. Пропускная способность была ниже базовой, а задержки увеличились.
При интерпретации результатов необходимо учитывать различную длительность базового и отказных испытаний, а также возможные колебания производительности тестового окружения.
Оценка 4 — проверка восстановления после отказа
Отдельно выполнен сценарий проверки отказоустойчивости с остановкой каждой реплики.
Команда:
make test-failover ACTION_SCRIPT=./scripts/stop-one.sh
Для проверки api-2 использовалась настройка TARGET_INSTANCE_ID.
Результаты:
| Остановленная реплика | Наблюдаемых реплик до отказа | Успешные записи | Неудачные попытки | Первое восстановление | Итог |
|---|---|---|---|---|---|
api-1 |
2 | 65 | 3 | 1,311 с | PASS |
api-2 |
2 | 81 | 2 | 1,339 с | PASS |
Доказательства:
evidence/failover-grade4-api1.txtevidence/failover-grade4-second.txt
Оба испытания завершились успешно.
Время восстановления характеризует момент первого успешного запроса, наблюдаемый тестовым клиентом. Оно не является отдельным измерением времени обнаружения отказа балансировщиком.
Наличие нескольких неудачных попыток показывает, что переключение не было абсолютно бесшовным.
Оценка 4 — конкурентная идемпотентность при отказе
Команда:
python3 tests/test_failover_concurrent_idempotency.py
Тест создаёт 20 конкурентных запросов с одинаковым Idempotency-Key и инициирует остановку api-1.
После завершения конкурентных запросов выполняется повторная отправка с тем же ключом и проверяется история сообщений.
Результаты:
- Конкурентных запросов: 20
- Успешных запросов: 20
- Неудачных запросов: 0
- Наблюдаемые реплики:
api-1,api-2 - Уникальных ID успешных ответов: 1
- Сообщений с проверяемым текстом в истории: 1
- Повторная отправка вернула тот же ID
- Итог: PASS
Доказательство:
evidence/failover-concurrent-idempotency.txt
Эксперимент подтвердил, что при конкурентных запросах и инициированной остановке одной реплики не появились дублирующие сообщения.
Ограничение эксперимента: все 20 запросов завершились успешно. Сам факт одновременного запуска запросов и остановки контейнера не доказывает, что конкретный запрос был прерван непосредственно во время записи в PostgreSQL.
Оценка 4 — rolling replacement
Для проверки обновления без полной остановки сервиса выполнялось последовательное пересоздание API-реплик под постоянной нагрузкой.
Нагрузочный тест:
python3 tests/load.py --duration 90 --concurrency 8 --output evidence/load-rolling.json
Во время его выполнения поочерёдно запускались команды:
docker compose up -d --no-deps --force-recreate api-1
docker compose up -d --no-deps --force-recreate api-2
Между пересозданиями проверялись готовность API и ответы через Nginx. При проверке наблюдались ответы от обеих реплик.
Nginx, PostgreSQL и Redis во время пересоздания API не перезапускались.
Результаты:
| Показатель | Значение |
|---|---|
| Продолжительность | 90,037 с |
| Успешные запросы | 16927 |
| Ошибки | 1 |
| Доля ошибок | Около 0,0059 % |
| Пропускная способность | 188,0 RPS |
| p50 | 33,878 мс |
| p95 | 99,116 мс |
| p99 | 199,301 мс |
Доказательство:
evidence/load-rolling.json
Во время последовательного пересоздания реплик сервис в целом оставался доступным, однако зарегистрирована одна ошибка.
Поэтому результат нельзя характеризовать как обновление с гарантированным отсутствием ошибок. Эксперимент подтверждает возможность поочерёдного обновления при сохранении обслуживания большинства запросов.
Оценка 4 — проверка ограничений и завершения
Проверка Docker показала, что на каждую API-реплику действуют ограничения 1 CPU и 512 MiB RAM.
При ручной остановке api-1 контейнер завершился с кодом 0. В логах Uvicorn наблюдалось штатное завершение приложения.
После восстановления реплика снова получила статус healthy.
Проверка опубликованных портов подтвердила, что на хосте доступен только Nginx на порту 8080.
API-реплики, PostgreSQL и Redis доступны через внутреннюю сеть Docker Compose.
Проверка изолированного окружения
На этапе оценки 3 дополнительно проводились проверки с отдельным именем проекта Docker Compose и чистыми Docker volumes.
Функциональные проверки, сохранность данных, отказоустойчивость и конкурентная идемпотентность в таком окружении завершились успешно.
Это подтверждает воспроизводимость запуска на новом наборе volumes в использованной локальной среде.
Полностью независимый запуск на другом компьютере из нового клона репозитория отдельно не подтверждён.
Ограничения
PostgreSQL, Redis и Nginx представлены одиночными экземплярами и остаются едиными точками отказа.
При недоступности PostgreSQL или Redis API может потерять готовность к обслуживанию запросов. Репликация и автоматическое переключение этих компонентов не реализованы.
Nginx способен перенаправлять запросы на доступную API-реплику, но отдельные запросы во время отказа или обновления всё равно могут завершиться ошибкой.
Нагрузочный генератор tests/load.py создаёт фиксированное число конкурентных клиентов и измеряет успешную пропускную способность и задержки. Он не обеспечивает точное поддержание заданного входящего RPS.
Поэтому полученные значения характеризуют пропускную способность в выбранном режиме нагрузки, а не максимальную производительность системы при произвольном входящем потоке.
В нагрузочных результатах отсутствует детальная посекундная разбивка ошибок и задержек. Время восстановления измеряется отдельно тестом отказоустойчивости.
Секреты хранятся вне Git, но файловая схема Docker Compose с правами 644 не обеспечивает строгой изоляции содержимого от всех процессов, имеющих доступ к смонтированным файлам.
Испытания проведены в одном локальном окружении. Результаты зависят от характеристик компьютера, Docker, нагрузки и состояния базы данных.
Итоги оценки 4
Выполнены следующие проверки:
- Две API-реплики за балансировщиком Nginx.
- Общие PostgreSQL и Redis.
- Общая авторизация и идемпотентность между репликами.
- Проверки
/health/liveи/health/ready. - Таймауты подключения и обработки запросов.
- Корректное завершение приложения при SIGTERM.
- Ограничения CPU и RAM.
- Отсутствие прямой публикации внутренних сервисов.
- Однократное выполнение миграций отдельным контейнером.
- Остановка каждой API-реплики под нагрузкой.
- Проверка времени восстановления после отказа.
- Конкурентная идемпотентность при инициированном отказе.
- Поочерёдное пересоздание реплик под нагрузкой.
- Хранение секретов вне Git.
Базовая пропускная способность в проведённом испытании составила 199,148 успешного запроса в секунду.
При остановке одной реплики оставшаяся продолжала обслуживать запросы. В отдельных failover-проверках первое успешное восстановление наблюдалось через 1,311 и 1,339 секунды.
При rolling replacement зарегистрирована одна ошибка на 16928 попыток.
Таким образом, реализована и экспериментально проверена устойчивость к отказу одной API-реплики. Полная безошибочность переключения и отсутствие единых точек отказа для всей инфраструктуры не заявляются.
Оценка 5 — исследование цены масштабирования
Цель эксперимента
Исследовать влияние количества API-реплик на пропускную способность и задержки приложения при фиксированном суммарном бюджете CPU и RAM.
Сравниваются конфигурации с 1, 2 и 4 API-репликами. PostgreSQL, Redis и Nginx остаются общими компонентами системы.
Методика
Для всех конфигураций установлен одинаковый суммарный лимит ресурсов API: 2 CPU и 1024 MiB RAM.
| API-реплик | CPU на реплику | RAM на реплику | Общий CPU | Общая RAM |
|---|---|---|---|---|
| 1 | 2 | 1024 MiB | 2 | 1024 MiB |
| 2 | 1 | 512 MiB | 2 | 1024 MiB |
| 4 | 0,5 | 256 MiB | 2 | 1024 MiB |
Конфигурации запускаются с использованием compose.yaml и compose.scale.yaml. Для каждого количества реплик подготовлена отдельная конфигурация Nginx.
Нагрузочные испытания выполняются скриптом tests/load.py. Генератор использует закрытую модель нагрузки с фиксированным количеством конкурентных клиентов, отправляющих POST-запросы на создание сообщений. Автоматические повторные попытки отсутствуют.
Первоначально для каждой конфигурации проведены тесты продолжительностью 60 секунд с 8, 16, 32 и 64 конкурентными клиентами.
Для сравнения воспроизводимости дополнительно выполнены повторные прогоны при 16 клиентах. В итоговом сравнении используются три измерения для каждой конфигурации.
Измеряются успешные запросы в секунду (RPS), задержки p50, p95, p99 и количество ошибок.
Исходные результаты сохранены в evidence/scale/. Скрипт scripts/analyze_scale.py вычисляет агрегированные показатели и формирует графики.
Результаты при 16 клиентах
| API-реплик | RPS, прогон 1 | RPS, прогон 2 | RPS, прогон 3 | Средний RPS | Стандартное отклонение RPS |
|---|---|---|---|---|---|
| 1 | 145,953 | 142,549 | 142,668 | 143,723 | 1,932 |
| 2 | 224,292 | 210,316 | 228,380 | 220,996 | 9,472 |
| 4 | 106,885 | 97,026 | 108,340 | 104,084 | 6,155 |
Средние значения перцентилей отдельных прогонов:
| API-реплик | Средний p95 | Средний p99 | Ошибок за три прогона |
|---|---|---|---|
| 1 | 135,946 мс | 158,606 мс | 0 |
| 2 | 129,875 мс | 371,534 мс | 0 |
| 4 | 572,950 мс | 1152,931 мс | 0 |
При одинаковом суммарном бюджете ресурсов конфигурация с двумя репликами показала наибольшую пропускную способность — 220,996 RPS.
По сравнению с одной репликой прирост составил около 53,8%. При переходе с двух реплик на четыре пропускная способность, напротив, снизилась примерно на 52,9%.
При этом минимальное среднее значение p99 наблюдалось у одной реплики. Следовательно, выбор конфигурации зависит не только от максимального RPS, но и от требований к задержкам.
Графики
Пропускная способность при 16 конкурентных клиентах:
Задержки p95 и p99:
На первом графике столбики погрешности обозначают выборочное стандартное отклонение RPS трёх прогонов.
На втором графике приведены средние значения перцентилей отдельных прогонов. Они не являются перцентилями объединённой выборки всех запросов.
Диагностика ограничений CPU
Для конфигурации с четырьмя репликами дополнительно исследовано использование CPU.
Проверка параметров cgroup показала, что каждой реплике установлена квота 50000 микросекунд процессорного времени на период 100000 микросекунд, что соответствует 0,5 CPU.
Во время отдельного нагрузочного испытания зафиксировано ограничение процессорного времени (CPU throttling). Доля периодов с throttling составила приблизительно:
| Реплика | Доля периодов с throttling |
|---|---|
| api-1 | 55,0% |
| api-2 | 35,8% |
| api-3 | 41,4% |
| api-4 | 37,8% |
Во время нагрузки наблюдалось использование CPU около установленного лимита, тогда как потребление памяти составляло примерно 70 MiB на реплику при лимите 256 MiB.
Это согласуется с предположением о существенном влиянии процессорных ограничений на результаты четырёх реплик.
Дополнительный диагностический эксперимент
Для проверки влияния CPU-квоты проведён отдельный эксперимент с четырьмя репликами и 16 конкурентными клиентами.
CPU-квота каждой реплики временно увеличена с 0,5 до 1 CPU. Лимит памяти не изменялся.
При суммарном лимите 4 CPU получены следующие результаты:
- Успешная пропускная способность: 353,146 RPS.
- p50: 31,047 мс.
- p95: 125,895 мс.
- p99: 300,611 мс.
- Ошибок: 0.
Это приблизительно на 239,3% выше средней пропускной способности четырёх реплик при суммарном лимите 2 CPU.
Однако данный эксперимент использовал вдвое больший CPU-бюджет, поэтому его нельзя считать прямым сравнением эффективности масштабирования при одинаковых ресурсах.
После эксперимента ограничения четырёх реплик были возвращены к 0,5 CPU.
Результат свидетельствует о чувствительности производительности к доступному процессорному времени, но сам по себе не доказывает, что всё снижение производительности четырёх реплик вызвано исключительно CPU throttling.
Ограничения исследования
Испытания выполнялись в одном локальном окружении. На результаты могли влиять фоновая нагрузка компьютера, планировщик CPU, состояние PostgreSQL и Redis, прогрев системы и накопление данных в базе.
Для каждой конфигурации при 16 клиентах проведено три прогона. Это позволяет оценить повторяемость результатов, но недостаточно для строгих статистических выводов.
Генератор использует закрытую модель нагрузки, поэтому результаты зависят от задержек ответов и производительности самого клиента. Возможны coordinated omission и дополнительная нагрузка со стороны генератора.
PostgreSQL, Redis и Nginx не масштабировались вместе с API. Поэтому эксперимент характеризует масштабирование API при фиксированной общей инфраструктуре.
Зафиксированы признаки CPU throttling, однако влияние других факторов на снижение производительности четырёх реплик полностью не исключено.
Экспериментальная оптимизация CPU-периода
В качестве дополнительной оптимизации проверено изменение периода CPU-квоты для четырёх API-реплик при неизменном суммарном бюджете ресурсов.
В исходной конфигурации каждая реплика имела период 100000 мкс и квоту 50000 мкс. В экспериментальной конфигурации период увеличен до 200000 мкс, а квота — до 100000 мкс. В обоих случаях лимит каждой реплики составлял 0,5 CPU, суммарный бюджет — 2 CPU и 1024 MiB RAM.
Для экспериментальной конфигурации проведено три нагрузочных теста продолжительностью 60 секунд с 16 конкурентными клиентами.
| Прогон | RPS | p95 | p99 | Ошибок |
|---|---|---|---|---|
| 1 | 86,649 | 888,403 мс | 1559,440 мс | 1 |
| 2 | 85,505 | 925,831 мс | 1351,136 мс | 0 |
| 3 | 85,683 | 890,303 мс | 1366,728 мс | 0 |
| Среднее | 85,946 | 901,512 мс | 1425,768 мс | — |
Сравнение со стандартным периодом 100 мс:
| Метрика | Период 100 мс | Период 200 мс | Изменение |
|---|---|---|---|
| Средний RPS | 104,084 | 85,946 | −17,4% |
| Средний p95 | 572,950 мс | 901,512 мс | +57,3% |
| Средний p99 | 1152,931 мс | 1425,768 мс | +23,7% |
| Ошибок за три прогона | 0 | 1 | — |
Увеличение CPU-периода не привело к улучшению производительности. Средняя пропускная способность снизилась на 17,4%, а задержки p95 и p99 увеличились.
Следовательно, предложенная оптимизация оказалась неэффективной в исследованных условиях. При этом результаты не позволяют утверждать, что увеличение CPU-периода всегда ухудшает производительность: вывод относится к данному приложению, окружению и выбранной нагрузке.
После эксперимента восстановлена стандартная конфигурация с двумя API-репликами.
Результаты сохранены в evidence/scale/replicas-4-c16-period200.json, evidence/scale/replicas-4-c16-period200-repeat.json и evidence/scale/replicas-4-c16-period200-repeat2.json.
Итоговые выводы
В работе исследована цена горизонтального масштабирования API при фиксированном суммарном бюджете 2 CPU и 1024 MiB RAM.
При 16 конкурентных клиентах конфигурация с двумя репликами обеспечила максимальную среднюю пропускную способность среди проверенных вариантов — 220,996 RPS. Это приблизительно на 53,8% больше, чем у одной реплики, и на 112,3% больше, чем у четырёх.
При этом одна реплика показала наименьшую среднюю задержку p99 — 158,606 мс. Следовательно, оптимальный выбор зависит от требований к пропускной способности и задержкам.
Диагностика четырёх реплик выявила CPU throttling. Дополнительный эксперимент с увеличенным CPU-бюджетом подтвердил чувствительность приложения к доступному процессорному времени, но не позволил однозначно установить единственную причину снижения производительности.
Попытка оптимизации путём увеличения периода CPU-квоты со 100 до 200 мс при сохранении общего бюджета оказалась неэффективной: RPS снизился на 17,4%.
По результатам исследования для данной нагрузки выбрана конфигурация с двумя API-репликами по 1 CPU и 512 MiB RAM. Она обеспечивает наибольшую пропускную способность среди проверенных вариантов без увеличения суммарного бюджета ресурсов.
Таким образом, горизонтальное масштабирование необходимо оценивать экспериментально: увеличение числа реплик само по себе не гарантирует повышения производительности.(.venv) casablanca@CASABLANCA:~/mtuci/high_load_apps/mtusi2026lab3$
Команды для демонстрации
Все команды выполняются из корневого каталога проекта. Команды с docker compose down останавливают стенд, но без -v сохраняют постоянные данные PostgreSQL. Для демонстрации достаточно начать с обычной конфигурации двух реплик. Запуск тестов создаёт учебные записи в базе; повторные измерения на изменившемся состоянии базы могут отличаться от приведённых в отчёте.
1. Подготовка и запуск
./scripts/bootstrap.sh
docker compose config --quiet
docker compose up -d --build
docker compose ps -a
При первом запуске локальных Python-тестов установить зависимости в виртуальное окружение:
python3 -m venv .venv
source .venv/bin/activate
python -m pip install -r requirements-dev.txt
Если .venv уже существует и зависимости установлены, повторять создание окружения не нужно. Для проверки миграций и журналов:
docker compose ps -a
docker compose logs --tail=50 migrate
docker compose logs --tail=30 api-1 api-2 nginx
Сервис migrate должен завершиться с кодом 0; две реплики API, PostgreSQL и Redis должны быть healthy.
2. Проверка API, балансировки и изоляции
curl -i http://localhost:8080/health/live
curl -i http://localhost:8080/health/ready
for i in $(seq 1 12); do curl -s -D - -o /dev/null http://localhost:8080/health/live | grep -i '^x-instance-id:'; done
docker compose ps
docker compose port nginx 8080
В заголовке X-Instance-Id при повторных запросах ожидаются ответы от api-1 и api-2. Порты API, PostgreSQL и Redis на хост не публикуются; точка входа — Nginx на localhost:8080.
Проверка ресурсных ограничений и запуска API от непривилегированного пользователя:
for i in 1 2; do docker inspect mtusi2026lab3-api-$i-1 --format '{{.Name}} NanoCpus={{.HostConfig.NanoCpus}} Memory={{.HostConfig.Memory}} StopTimeout={{.HostConfig.StopTimeout}}'; done
docker compose exec -T api-1 id
docker stats --no-stream
3. Функциональные тесты и отказоустойчивость
make check
make validate
make test
make test-persistence ACTION_SCRIPT=./scripts/restart.sh
make test-failover ACTION_SCRIPT=./scripts/stop-one.sh
python3 tests/test_concurrent_idempotency.py
python3 tests/test_failover_concurrent_idempotency.py
docker compose start api-1 api-2
docker compose ps
Тесты проверяют контракт, сохранность данных, работу сессии при отказе и отсутствие дублирования сообщения при конкурентной отправке с одинаковым Idempotency-Key. После сценариев отказа необходимо восстановить обе реплики.
Для ручного показа остановки одной реплики и восстановления:
docker compose stop api-1
curl -i http://localhost:8080/health/ready
docker compose ps
docker compose start api-1
docker compose ps
4. Нагрузка и последовательное обновление на оценку 4
Базовый нагрузочный тест:
python3 tests/load.py --duration 30 --concurrency 8 --output evidence/load-demo.json
Для демонстрации rolling replacement запустить нагрузку в первом терминале:
python3 tests/load.py --duration 90 --concurrency 8 --output evidence/load-rolling-demo.json
Пока идёт тест, во втором терминале поочерёдно выполнить:
docker compose up -d --no-deps --force-recreate api-1
docker compose ps
docker compose up -d --no-deps --force-recreate api-2
docker compose ps
После теста посмотреть JSON-файл с RPS, задержками и ошибками. Пересоздание под нагрузкой не гарантирует нулевое число ошибок: в исходном эксперименте была зафиксирована одна ошибка.
5. Воспроизведение сравнения 1, 2 и 4 реплик на оценку 5
Используются compose.yaml, compose.scale.yaml и конфигурации Nginx в infra/scale/. Для каждого варианта общий лимит API одинаков: 2 CPU и 1024 MiB RAM. Переход между вариантами выполняется с остановкой предыдущего стенда. Команды не используют down -v, поэтому накопленные данные сохраняются.
Одна реплика — 2 CPU и 1024 MiB:
docker compose -f compose.yaml -f compose.scale.yaml down
API_REPLICAS=1 API_CPUS=2.0 API_MEMORY=1024m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 nginx
docker compose -f compose.yaml -f compose.scale.yaml ps
python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/demo-1-c16.json
Две реплики — по 1 CPU и 512 MiB:
docker compose -f compose.yaml -f compose.scale.yaml down
API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 api-2 nginx
docker compose -f compose.yaml -f compose.scale.yaml ps
python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/demo-2-c16.json
Четыре реплики — по 0,5 CPU и 256 MiB:
docker compose -f compose.yaml -f compose.scale.yaml down
API_REPLICAS=4 API_CPUS=0.5 API_MEMORY=256m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 api-2 api-3 api-4 nginx
docker compose -f compose.yaml -f compose.scale.yaml ps
python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/demo-4-c16.json
Для демонстрации ограничений четырёх реплик:
for i in 1 2 3 4; do docker inspect mtusi2026lab3-api-$i-1 --format '{{.Name}} NanoCpus={{.HostConfig.NanoCpus}} Memory={{.HostConfig.Memory}}'; done
docker stats --no-stream
Исторические результаты всех прогонов находятся в evidence/scale/; графики уже сохранены в evidence/scale/charts/. Для повторного формирования графиков:
python3 scripts/analyze_scale.py
Для воспроизведения всех исходных серий вместо --concurrency 16 последовательно использовать 8, 16, 32 и 64 клиента; для статистического сравнения провести по три прогона при 16 клиентах, сохраняя каждый результат в отдельный JSON-файл.
6. Проверка изменения CPU-периода
Этот эксперимент проводится на четырёх репликах. Он показал отрицательный результат, поэтому не является рекомендуемой рабочей конфигурацией. Дополнительный файл compose.cpu-period.yaml заменяет способ задания лимита CPU: cpu_period: 200000 и cpu_quota: 100000 вместо cpus: 0.5. Перед запуском убедиться, что файл присутствует в проекте.
docker compose -f compose.yaml -f compose.scale.yaml down
API_REPLICAS=4 API_CPUS=0.5 API_MEMORY=256m docker compose -f compose.yaml -f compose.scale.yaml -f compose.cpu-period.yaml config --quiet
API_REPLICAS=4 API_CPUS=0.5 API_MEMORY=256m docker compose -f compose.yaml -f compose.scale.yaml -f compose.cpu-period.yaml up -d --build postgres redis migrate api-1 api-2 api-3 api-4 nginx
for i in 1 2 3 4; do docker inspect mtusi2026lab3-api-$i-1 --format '{{.Name}} NanoCpus={{.HostConfig.NanoCpus}} CpuPeriod={{.HostConfig.CpuPeriod}} CpuQuota={{.HostConfig.CpuQuota}}'; done
python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/demo-4-c16-period200.json
При корректной конфигурации каждая реплика имеет NanoCpus=0, CpuPeriod=200000, CpuQuota=100000, то есть 0,5 CPU. Для повторения методики выполнить три прогона с разными именами выходных файлов.
7. Возврат к основной конфигурации после демонстрации
docker compose -f compose.yaml -f compose.scale.yaml -f compose.cpu-period.yaml down
API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 api-2 nginx
docker compose -f compose.yaml -f compose.scale.yaml ps
curl -i http://localhost:8080/health/ready
Для обычной остановки без удаления данных:
docker compose down
docker compose down -v применять только при намеренном удалении учебной базы и volumes. При защите удобно показать сначала работающие две реплики, затем X-Instance-Id, проверки make, failover и результаты масштабирования; полные 60-секундные серии можно воспроизвести по приведённым командам при необходимости.

