Files
mtusi2026lab3/REPORT.md
T
2026-10-13 19:30:32 +03:00

31 KiB
Raw Blame History

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

  • Автор: Максим Шептунов, БВТ2301.
  • Целевая оценка: 5; трек 1, Цена масштабирования.
  • Skeleton: 0ab3a341aa7ba32363ce43061d4ff02b1f2964af.
  • Дата проверки: 12.10.2026.
  • Commit/PR: добавляется после публикации.
  • Стенд: Windows + WSL2 Ubuntu; Docker видит 16 логических CPU и 8 187 711 488 байт RAM (около 7,63 GiB).
  • Использование ИИ: помощь с реализацией, проверками и объяснением результатов.

Результаты получены на моём Docker-стенде. Вывод команд находится в evidence/local_*, исходные измерения — в JSON. Публичные tests, OpenAPI и README задания сохранены.

Запуск из чистого clone

Нужны Docker Engine с Compose v2, Python 3.10+ и свободный порт 8080. В Windows — WSL Ubuntu с Docker Desktop и включённой WSL Integration.

python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements-dev.txt -r requirements-experiment.txt
chmod +x scripts/*.sh
make setup
make start
make ready
make check
make validate
make test
make student-checks
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
bash scripts/restore-api.sh
make test-availability
make test-dependencies
make test-expiry
make experiment
make test

API-зависимости устанавливаются в Docker из requirements.txt. setup.sh создаёт .env и .secrets вне Git. Вывод проверок сохранялся через 2>&1 | tee evidence/local_ИМЯ.txt. make stop сохраняет volumes. Намеренное удаление учебных данных: docker compose down -v, только если данные больше не нужны.

Образы: Python 3.12.10 slim-bookworm, PostgreSQL 16.9 bookworm, Redis 7.4.3 bookworm, HAProxy 3.0.11 bookworm. Библиотеки закреплены по версиям.

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

Клиент → HAProxy (127.0.0.1:8080) → две API → общий PostgreSQL. У API нет опубликованных портов или container_name. Балансировка roundrobin. PostgreSQL хранит пользователей, чаты, сообщения, сессии и результаты повторов. Redis — только кеш неизменяемых публичных профилей с TTL 60 s; без него API работает через БД. Read-after-write обеспечивается общей основной БД. Из lab2 перенесены PostgreSQL, миграция основной схемы, общие сессии, Argon2id, Redis-кеш и keyset-пагинация. В lab3 добавлены HAProxy, несколько API, идентификатор процесса, таблица идемпотентности и отдельный запуск миграций. Учтены права на Docker secret и ограничение DNS-задержек при отказе Redis. API не хранит состояние сообщений или сессий только в памяти одной реплики.

Пароли — Argon2id. SHA-256 Bearer проверяется в PostgreSQL при каждом запросе; один токен действует на всех API. Токены не логируются. X-Instance-Id состоит из hostname и случайной части, стабилен при жизни процесса, есть и у ошибок API.

Область Idempotency-Key: пользователь + POST + чат + ключ. Метод не хранится колонкой: таблица предназначена только для POST messages. Допустимый ASCII-ключ проверяется по контракту. SHA-256 тела берётся от нормализованного JSON текста, поэтому форматирование JSON не меняет результат.

Одна транзакция берёт общий PostgreSQL advisory lock, проверяет старый результат, вставляет сообщение и результат повтора. Другая реплика ждёт ту же блокировку и возвращает прежний Message с 201. Другой текст при действующем ключе — 409. Ошибка откатывает обе вставки, 5xx не запоминается. Результат действует 24 часа. Истёкший ключ можно использовать заново. Авторизация и участие проверяются перед выдачей сохранённого результата. Случайная коллизия lock-хеша только сериализует независимые запросы: в таблице полные ключи сравниваются отдельно.

Сервис migrate выполняется до API; миграции повторно безопасны и защищены lock. Rolling проверяет совместимые версии lab3 при уже применённой схеме: временно запускается третья API, ожидается её готовность, затем останавливается старая; это повторяется для второй. LB не перезапускается. Переход lab2 → lab3 без паузы не заявляется: старый API не понимает обязательный ключ.

/health/live проверяет процесс, /health/ready — PostgreSQL. Redis не влияет на readiness. HAProxy: interval 1 s, check timeout 1 s, fall 2, fastinter 0.5 s, rise 1; Docker DNS hold valid 1 s. Ориентир обнаружения — несколько секунд; граница ≤10 s подтверждается fault-тестом. LB connect timeout 0.5 s, server 5 s, прозрачные retries отключены. SQL timeout 3 s, lock/pool timeout 2 s. SIGTERM передаётся Uvicorn через exec; graceful timeout 8 s, Docker grace 10 s. Клиент после неопределённого POST повторяет тот же ключ и тело.

Обычные лимиты: API по 1 CPU/256 MiB; PG 1 CPU/512 MiB; Redis и LB по 0.5 CPU/128 MiB. Фактические лимиты и ID контейнеров сохраняются через inspect. Настройки .env: APP_PORT, SESSION_TTL_SECONDS, API_CPU, API_MEMORY, DB_POOL_MAX. DATABASE_URL_FILE используется. Остальные подсказки неизменённого .env.example: API_REPLICAS заменено Compose scale; CACHE_URL задан в compose, SESSION_STORE фиксирован как PostgreSQL, IDEMPOTENCY_TTL_SECONDS фиксирован контрактом в 24 h; APP_HOST задаётся в образе. Эти подсказки не управляют данным решением.

Среда и воспроизводимость

Docker Engine сервера 26.1.1, Docker CLI 28.0.1, Compose 2.27.0-desktop.2, Python хоста 3.10.12. Ядро WSL2: 5.15.146.1-microsoft-standard-WSL2. Полный вывод — evidence/local_environment.txt. Объём RAM относится к Docker, а не к всей физической памяти ноутбука. Модель CPU отдельно в замерах не записана.

make start выполняет build и ждёт готовности. make ready проверяет обе API через LB. Сервис миграций имеет Exited(0), что является нормальным завершением. Во время испытаний не удалялись volumes. Рестарт выполнялся реальным hook, остановка конкретной API сопоставлялась с ID Docker-контейнера.

Доказательства критериев

Критерий Команда/сценарий Полученный результат Файлы в evidence
Структура и контракт make check; make validate PASS; эти проверки не тестируют запущенный API local_check.txt, local_validate.txt
Публичный HTTP API make test PASS до отказов, после них и после исследования local_smoke.txt, local_smoke_after_failures.txt, local_final_smoke.txt
Две настоящие API, общий токен make ready; make student-checks; snapshot Два ID контейнеров/процессов; токен использован на обеих API без login containers_before.json, local_ready.txt, idempotency.json
Сохранение функциональности lab2 make student-checks PASS: доступ, logout, курсоры, гонка username; 100 уникальных сообщений от 10 клиентов local_student_checks.txt
Миграции и атомарность database.py через Makefile PASS: повтор миграций, rollback чата/участников и сообщения/результата, истечение ключа local_student_checks.txt
Общая идемпотентность make student-checks 32 конкурентных запроса через 2 API дали одну запись; 409/400/401/404 проверены idempotency.json, local_student_checks.txt
Перезапуск API, PG, Redis и LB make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS: подтверждённое сообщение и старый Bearer сохранены local_persistence.txt, containers_before.json, containers_after_restart.json
Публичный failover ≤10 s make test-failover ACTION_SCRIPT=scripts/stop-one.sh 2 API до отказа; восстановление записи 1,698 s; 114 успешных записей, 3 ошибки local_failover.txt
Каждая API отдельно make test-availability Верхние оценки восстановления 2,998 и 3,997 s; все подтверждения сохранены failures.json, local_availability.txt, last_stop.json
CPU/RAM и закрытые API-порты stack.py snapshot Лимиты применены; API-порты не опубликованы; публичен только LB containers_before.json, containers_final.json
Rolling под нагрузкой make test-availability Старые API заменены; LB не заменён; 2074 сообщения сохранены rolling.json, rolling_containers.json
Отказ Redis и PG make test-dependencies PASS: Redis fallback; без PG ответы 503; после возврата старые сессии и данные действуют dependencies.json, local_dependencies.txt
Истечение сессии make test-expiry PASS при TTL=2 s; обычная конфигурация возвращена local_expiry.txt
Трек 1: масштабирование make experiment 54 запуска, 112519 успешных измеренных запросов, 0 ошибок; 1/2/4 API, fixed/growth track1_raw.json, track1_summary.json, scaling_rps.png, scaling_p95_ms.png
Подтверждённое изменение Парное сравнение DB_POOL_MAX 8 и 1 При 4 API по 0,5 CPU пул 1 быстрее во всех трёх парах; median RPS +74,0%, p95 −35,6% Последние 6 запусков track1_raw.json; раздел ниже

Отказы, рестарт и rolling

Публичный failover выбирает API по ответу POST. После завершения hook тот же Bearer продолжает работать через другую API, чтение подтверждений проверяется. Результат: 114 успешных записей, 3 неудачные попытки, первая успешная запись после завершённого stop — через 1,698 s от старта hook. Потери подтверждённых сообщений и дубли от повторов не обнаружены.

Дополнительный fault-тест использует 4 concurrent clients и смешанный профиль. При timeout/503 POST повторяется с прежними ключом и телом. Затем сверяется полная история с подтверждениями. Первая остановленная API возвращается перед остановкой второй. Идентификаторы и Running=false находятся также внутри action_events.result каждого элемента failures.json.

Воздействие Успешные запросы / ошибки RPS p50 / p95 / p99, ms Восстановление и данные
API 1, контейнер 12b697ef94f3 1202 / 35; 2,83% ошибок 75,081 40,809 / 115,945 / 184,804 Верхняя оценка 2,998 s; 729 подтверждённых сообщений сохранены
API 2, контейнер 67a7ac749a94 1004 / 39; 3,74% ошибок 62,689 41,276 / 193,142 / 303,374 Верхняя оценка 3,997 s; 614 подтверждённых сообщений сохранены
Rolling, 35,089 s 3433 / 69; 1,97% ошибок 97,836 19,713 / 133,456 / 234,083 2074 подтверждённых сообщения сохранены

Время восстановления собственных fault-тестов — консервативная оценка по секундным корзинам успешных запросов после stop. Это не точное время завершения TCP-соединения. Публичный тест отдельно измеряет успешный POST. Краткие 503 зафиксированы: нулевой простой не заявляется.

При rolling старые контейнеры 12b697ef94f3 и 67a7ac749a94 заменены на 9f0a21ee9eb4 и 5b7bd8390bb9. ID балансировщика до/после одинаков: 887f07a19c48. В каждой фазе остаётся работающая API, новую запускаем и проверяем до удаления старой. Миграции при каждой замене не выполняются: схема уже применена отдельным сервисом. Сценарий проверяет механизм замены совместимых API lab3, а не несовместимое обновление схемы или новую бизнес-функцию.

После отключения Redis шесть GET профиля и один POST сообщения успешно завершились за 7,113 s суммарно. Это длительность серии, не latency одного запроса. После отключения PostgreSQL readiness и защищённый запрос через LB вернули 503. После возврата PG прежние токен и сообщение проверены без нового входа. Перезапуск полного стенда также сохранил данные и действующую сессию.

Трек 1: цена масштабирования

Гипотезы и методика

Проверяю, даёт ли большее число API прирост при том же суммарном бюджете, а затем при добавлении CPU/RAM. Отдельная исходная гипотеза: увеличение пула с 1 до 8 соединений уменьшит очередь и повысит пропускную способность. Эта гипотеза проверена, а не принята заранее.

Серия API CPU на API RAM на API Общий бюджет API
fixed 1 2 1024 MiB 2 CPU / 1024 MiB
fixed 2 1 512 MiB 2 CPU / 1024 MiB
fixed 4 0,5 256 MiB 2 CPU / 1024 MiB
growth 1 1 256 MiB 1 CPU / 256 MiB
growth 2 1 256 MiB 2 CPU / 512 MiB
growth 4 1 256 MiB 4 CPU / 1024 MiB

PG остаётся 1 CPU/512 MiB, Redis и LB — по 0,5 CPU/128 MiB. Фактические лимиты каждого запуска записаны в raw из Docker inspect. Во всех 54 запусках наблюдаемое число X-Instance-Id соответствует числу API.

Профиль closed-loop: клиент ждёт ответ перед следующим запросом; 60% POST с текстом 128 символов, 20% чтение первых 50 сообщений, 20% собственный профиль. Concurrency: 1/4/16/32. Перед каждым случаем создаётся новый чат с 10000 сообщений, потом 3 s прогрева и 15 s измерения. Последние запросы заканчиваются позже: фактические интервалы 15,001–16,239 s. В каждой из двух серий 24 случая: 3 числа API × 4 concurrency × 2 повтора. Затем 6 парных опытов пула. Итого 54 случая; начальная засеянная история суммарно 540000 сообщений, сверх неё создавались сообщения прогрева и нагрузки.

RPS считается по успешным запросам и фактическому измеренному интервалу. p50/p95/p99 относятся только к успешным запросам. Ошибки учитываются отдельно. В таблице приведены медианы показателей повторов, а не pooled percentile всех запросов. В масштабировании было по два повтора, в опыте пула — по три. Нагрузочный клиент не делает transparent retry в исследовательской серии. Для fault-сценариев retry, наоборот, явно включён.

Монитор собирает CPU/RAM контейнеров, состояния/ожидания PG и get_stats пула API. Между сборами пауза 3 s, но docker stats/exec тоже занимают время. В опытах пула по два снимка на запуск: первый заканчивается примерно на 8–10 s, второй — после 17 s, частично за измеренным окном. CPU-диагностика ниже использует снимки внутри окна; поздние снимки не считаются загрузкой всей серии. Накопительные requests_queued/requests_wait_ms включают прогрев и проверки готовности; их нельзя считать чистой средней задержкой одного измеренного HTTP-запроса.

Измеренные результаты

Все 112519 измеренных запросов успешны; failed_attempts=0 в каждом запуске.

Серия API Clients RPS p50 ms p95 ms p99 ms Ошибки
fixed 1 1 145.511 7.158 8.774 9.997 0%
fixed 1 4 164.724 25.214 34.649 45.324 0%
fixed 1 16 133.147 128.583 171.690 202.012 0%
fixed 1 32 130.375 264.331 345.976 383.635 0%
fixed 2 1 131.016 7.498 9.557 31.917 0%
fixed 2 4 200.523 15.407 71.814 95.170 0%
fixed 2 16 114.050 97.128 401.072 591.932 0%
fixed 2 32 122.042 213.054 694.255 861.278 0%
fixed 4 1 72.672 8.273 64.723 77.507 0%
fixed 4 4 129.416 10.895 127.184 235.002 0%
fixed 4 16 82.490 16.673 866.833 1542.302 0%
fixed 4 32 76.677 131.091 1650.318 2029.143 0%
growth 1 1 122.103 7.552 10.720 46.281 0%
growth 1 4 115.231 27.557 88.178 98.727 0%
growth 1 16 86.630 176.629 377.891 480.830 0%
growth 1 32 89.212 340.793 674.803 898.039 0%
growth 2 1 129.289 7.566 9.698 32.124 0%
growth 2 4 239.492 12.857 57.887 87.562 0%
growth 2 16 154.389 79.523 292.688 445.308 0%
growth 2 32 142.447 164.731 650.997 773.957 0%
growth 4 1 127.805 7.809 10.032 20.178 0%
growth 4 4 262.183 12.334 47.691 67.927 0%
growth 4 16 210.021 14.433 295.197 470.346 0%
growth 4 32 200.486 21.111 614.256 833.542 0%

Успешные RPS при разных числе API и concurrency

p95 при разных числе API и concurrency

Насыщение и границы масштабирования

При fixed и 4 clients median RPS: 164,724 → 200,523 → 129,416 для 1/2/4 API. Разделение того же бюджета на четыре API ухудшило результат: каждая получает только 0,5 CPU, а переключение между процессами/соединениями добавляет работу. Для двух API разброс заметен: повторы 245,752 и 155,293 RPS. Поэтому преимуществу двух API в этой серии нельзя приписывать высокую статистическую точность.

При growth и 4 clients median RPS: 115,231 → 239,492 → 262,183. Переход с 1 на 2 API дал около +108%, с 2 на 4 — только +9,5%. Добавление ресурсов помогает, но линейного ускорения после двух API нет.

В fixed для двух API увеличение clients с 4 до 16 снизило RPS с 200,523 до 114,050, а p95 вырос с 71,814 до 401,072 ms. При 32 clients p95 достиг 694,255 ms. Насыщение в данной сетке находится между 4 и 16 clients; точнее его определить без дополнительных точек нельзя. При pool=8 максимальная наблюдаемая очередь на API для этого случая: 1 при 4 clients, 7 при 16, 22 при 32. Это наблюдаемая точка давления на пул, а не вывод только по одному графику RPS.

В парных опытах с четырьмя API по 0,5 CPU отдельные API достигают примерно 50% Docker CPU, то есть своего лимита в половину ядра (максимум внутри окна при pool=8 — 52,53% кратковременного снимка). PG при pool=8 показывает 19,12–24,77% CPU из доступного лимита 100%, LB — 7,67–8,13% из лимита 50%. CPU-насыщение PG и LB этими снимками не подтверждается. БД часто находится в ClientRead, в том числе idle in transaction: она ждёт действий API-клиента, а не постоянно исполняет SQL. Есть и отдельные ожидания WALSync, поэтому влияние дисковой задержки не исключено.

Из этого следует рабочее объяснение: при малом CPU-бюджете API большая параллельность создаёт конкуренцию за CPU и удерживает больше соединений/транзакций. Очередь пула есть, но увеличение его размера не снимает ограничение обработки API. CPU-снимки редкие; это объяснение механизма, а не профилирование каждого запроса. Сам эффект изменения пула проверен отдельно ниже.

Подтверждённый выбор размера пула

Сравнивались 4 API по 0,5 CPU/256 MiB, 32 clients; все остальные ресурсы одинаковы. Порядок: pool 1/8, затем 8/1, затем 1/8. Каждый запуск с новым чатом, тем же seed, прогревом и профилем. Названия pool_before/pool_after в raw сохранены: они обозначают исходную гипотезу 1 → 8, а не заранее лучший вариант.

Пара RPS pool=8 RPS pool=1 p95 pool=8, ms p95 pool=1, ms Ошибки
1 78.992 137.435 1372.051 961.728 0% / 0%
2 77.599 147.111 1611.915 807.740 0% / 0%
3 84.820 126.450 1493.381 1008.669 0% / 0%
Медиана 78.992 137.435 1493.381 961.728 0% / 0%

Исходная гипотеза об увеличении пула опровергнута: 1 → 8 снизило median RPS на 42,5%. Подтверждено обратное изменение, уменьшение пула с 8 до 1: median RPS +74,0%, median p95 −35,6%; p50 110,893 → 95,751 ms, p99 2209,060 → 1404,250 ms. В каждой паре RPS лучше и p95 ниже: прирост RPS по парам +74,0%, +89,6%, +49,1%. Ошибок не добавилось.

При pool=1 максимальная наблюдаемая очередь всё равно достигает 31 запроса на API. Значит, меньший пул не устраняет ожидание: он ограничивает полезную параллельность, и для этого CPU-бюджета итоговая пропускная способность выше. У PostgreSQL меньше клиентских соединений: примерно 4 вместо 31–32 в первых снимках парного сравнения. Единственным изменяемым параметром был размер пула. Результат не означает, что один коннект оптимален для любого профиля и hardware.

Обычная конфигурация двух API сохраняет pool=8. Исследованное улучшение относится к четырём API с 0,5 CPU на каждую. Воспроизвести именно эту настройку можно так:

python3 - <<'CONFIG'
from scripts.stack import scale
scale(4, 0.5, '256m', 1)
CONFIG

Для возврата обычного стенда:

python3 - <<'CONFIG'
from scripts.stack import scale
scale(2, 1, '256m', 8)
CONFIG

Исходный журнал local_experiment.txt содержит NEEDS_REVIEW: первоначальный анализ оценивал только гипотезу увеличения пула. Исходные числа не изменялись. Анализ обеих сторон сравнения отражён в обновлённом summary и в этом отчёте. Повторная агрегация имеющихся данных не запускает новую нагрузку:

python3 scripts/experiment.py --summarize-only

Ограничения и следующие шаги

Стенд выдержал остановку любой одной API, но остаются SPOF: один host, один PostgreSQL и один LB. Их отказ не заявляется как безостановочный. Rolling дал краткие ошибки 503, хотя все подтверждённые сообщения сохранены. Совместимость миграций для произвольных будущих версий не проверялась.

Docker CPU — ограничение, не резервирование. Клиент и диагностические docker exec используют тот же ноутбук. Короткие серии и два повтора масштабирования дают заметный разброс. Пулы сравнивались три раза, но доверительные интервалы и полноценное CPU-профилирование не строились. Более длинные опыты без диагностики помогут оценить её overhead; лимит пула следует подбирать заново при другом CPU.

База между запусками не очищалась: создавались новые чаты, а общий объём данных рос. На старте прогрева в каждом чате 10000 сообщений; к началу измерения добавлены сообщения прогрева, их число зависит от пропускной способности. Полные схемы/volumes не восстанавливались из одного snapshot перед каждой парой. Последовательность AB/BA частично уменьшает влияние порядка, но не устраняет его.

В PostgreSQL нет автоматической очистки истёкших sessions/message_requests: они не действуют, но занимают место. Redis хранит только кеш; durability сообщений обеспечивается PG, а не AOF Redis. Без TLS приложение предназначено для локального учебного стенда. При неопределённом результате POST повтор безопасен только с прежними ключом и телом, в пределах срока ключа и с действующей авторизацией.

Источники: README, COURSE и OpenAPI lab3; собственное решение lab2; Compose services, HAProxy health checks, HAProxy DNS, PostgreSQL advisory locks.