diff --git a/REPORT.md b/REPORT.md index 7d9e7489..432a67ce 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,8 +1,9 @@ +```` # Отчёт — лабораторная 3 - Автор, группа: Станислав Травкин, БВТ2304 - Целевая оценка: 5 -- Текущий этап: реализованы и исследованы критерии оценок 3, 4 и 5; выполняется финальная проверка +- Текущий этап: реализованы и исследованы критерии оценок 3, 4 и 5; - Выбранный трек оценки 5: цена масштабирования - Commit/PR: будет указан после публикации - Использованные источники: документация Docker Compose, FastAPI, SQLAlchemy, Alembic, PostgreSQL, Redis, Nginx; материалы лабораторной работы @@ -58,6 +59,7 @@ 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 +python3 tests/test_review_regressions.py ``` Для локальных Python-проверок требуется установить зависимости из `requirements-dev.txt`, если они ещё не установлены. @@ -152,20 +154,18 @@ PostgreSQL хранит постоянные данные приложения ### Ограничения ресурсов -Для каждой API-реплики заданы ограничения: +В основной конфигурации для каждой API-реплики установлены 1 CPU и 512 MiB RAM. После замечания преподавателя ограничения добавлены также ко всем инфраструктурным сервисам. Фактические значения проверены командой `docker inspect` (поле `HostConfig`): -- CPU: 1 -- RAM: 512 MiB +| Сервис | CPU | RAM | `NanoCpus` | `Memory`, байт | +|---|---:|---:|---:|---:| +| PostgreSQL | 1 | 768 MiB | 1000000000 | 805306368 | +| Redis | 0,5 | 256 MiB | 500000000 | 268435456 | +| Migrate | 1 | 512 MiB | 1000000000 | 536870912 | +| API-1 | 1 | 512 MiB | 1000000000 | 536870912 | +| API-2 | 1 | 512 MiB | 1000000000 | 536870912 | +| Nginx | 0,5 | 256 MiB | 500000000 | 268435456 | -Проверка через `docker inspect` подтвердила: - -- `NanoCpus = 1000000000` -- `Memory = 536870912` -- `StopTimeout = 15` - -Ограничения применяются к каждой реплике отдельно. При изменении количества реплик суммарный ресурсный бюджет также изменяется, если не корректировать лимиты. - -Для исследования цены масштабирования на оценку 5 потребуется зафиксировать общий бюджет CPU/RAM для сравниваемых конфигураций. +Сервис `migrate` завершился с кодом 0; заданные ограничения подтверждены и для его завершившегося контейнера. Для API также задан `stop_grace_period: 15s`. При масштабировании API общий бюджет изменяется, если лимиты каждой реплики сохраняются. Поэтому проведены две серии: с фиксированным суммарным бюджетом и с растущим бюджетом. ### Секреты и сетевой доступ @@ -203,7 +203,10 @@ API, PostgreSQL и Redis не публикуют порты на хосте. В | 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 на реплику | Результат проверки | +| Ограничения CPU/RAM | `docker inspect` для шести сервисов | Все значения `NanoCpus` и `Memory` ненулевые; таблица выше | Вывод проверки 22.10.2026 | +| Регрессии по замечаниям | `python3 tests/test_review_regressions.py` | PASS: UTF-8 Basic Auth, двоеточие в пароле, курсор чатов, последняя страница, некорректный курсор | Вывод проверки 22.10.2026 | +| Растущий бюджет 1/2/4 | `./scripts/run_growing_scale.sh` | 289,590 / 425,950 / 601,701 RPS, по три прогона, ошибок 0 | `evidence/scale/growing/` | +| Оптимизация «до/после» | `./scripts/run_optimization.sh` | 4 → 2 реплики при 2 CPU / 1024 MiB; RPS +6,2%, p95 −29,3%, p99 −42,1%, ошибок 0 | `evidence/scale/optimization/` | | Закрытые внутренние порты | `docker compose ps` | На хост опубликован только порт Nginx | Результат проверки | | Корректное завершение | `docker compose stop api-1` | Штатное завершение Uvicorn | Логи контейнера | @@ -627,11 +630,75 @@ PostgreSQL, Redis и Nginx не масштабировались вместе с Результаты сохранены в `evidence/scale/replicas-4-c16-period200.json`, `evidence/scale/replicas-4-c16-period200-repeat.json` и `evidence/scale/replicas-4-c16-period200-repeat2.json`. +### Вторая серия: растущий суммарный бюджет CPU и RAM + +Для отделения влияния числа реплик от влияния выделенных ресурсов проведена дополнительная серия. В отличие от основной серии с фиксированным бюджетом, каждая API-реплика получает 1 CPU и 512 MiB RAM. PostgreSQL, Redis и Nginx остаются общими компонентами, их лимиты не увеличиваются. Использован скрипт `./scripts/run_growing_scale.sh`. + +| API-реплик | CPU на реплику | RAM на реплику | Общий CPU API | Общая RAM API | +|---|---:|---:|---:|---:| +| 1 | 1 | 512 MiB | 1 | 512 MiB | +| 2 | 1 | 512 MiB | 2 | 1024 MiB | +| 4 | 1 | 512 MiB | 4 | 2048 MiB | + +Для каждого варианта: 16 конкурентных клиентов, 15 секунд прогрева, затем три измерения по 60 секунд; запросы `POST` на создание сообщений, закрытая модель нагрузки, без автоматических повторных попыток. Между вариантами Compose-стенд пересоздавался без `down -v`. Все API-реплики становились `healthy`. Итоговые средние и стандартные отклонения вычислены по трём прогонам. + +| API-реплик | Средний RPS | Стандартное отклонение RPS | Средний p95 | Средний p99 | Ошибок за три прогона | +|---|---:|---:|---:|---:|---:| +| 1 | 289,590 | 3,160 | 72,661 мс | 106,882 мс | 0 | +| 2 | 425,950 | 4,614 | 63,237 мс | 93,203 мс | 0 | +| 4 | 601,701 | 4,421 | 41,706 мс | 79,650 мс | 0 | + +При переходе от 1 к 2 репликам средний RPS увеличился на 47,1%; от 2 к 4 — на 41,3%; от 1 к 4 — на 107,8%. Средний p95 при переходе от 1 к 4 репликам уменьшился на 42,6%. Это подтверждает положительный эффект добавления API-ресурсов в данной серии, но не доказывает линейного масштабирования: при четырёхкратном CPU-бюджете RPS вырос примерно в 2,08 раза. + +В первой серии общий бюджет API составлял 2 CPU и 1024 MiB для всех вариантов, поэтому там сравнивалась **цена распределения фиксированных ресурсов**. В этой серии бюджет API увеличивался пропорционально числу реплик, поэтому она показывает **эффект добавления ресурсов**. Числа RPS между сериями нельзя использовать как строгое сравнение «до/после» изменения приложения: менялись ресурсные лимиты и состояние экспериментального окружения. + +Доказательства: JSON-файлы измерений в `evidence/scale/growing/`, вывод `./scripts/run_growing_scale.sh` и агрегирование `python3 scripts/summarize_growing_scale.py`. Исходные JSON-файлы должны быть включены в коммит вместе с отчётом. + +### Контрольный эксперимент «до/после»: оптимизация числа реплик + +После неудачного эксперимента с изменением CPU-периода выполнен отдельный контрольный эксперимент по выбору числа API-реплик. Проверялась гипотеза, что при фиксированном суммарном бюджете уменьшение числа реплик с четырёх до двух повысит пропускную способность и снизит задержки. Это **оптимизация конфигурации развёртывания**, а не изменение кода приложения. + +В обеих конфигурациях суммарный бюджет API равен 2 CPU и 1024 MiB RAM. Код приложения, генератор нагрузки, число клиентов и лимиты инфраструктурных сервисов не менялись. При переключении пересоздавались контейнеры, но Docker volumes не удалялись; менялись число API-реплик, распределение их квот и список upstream-серверов Nginx. + +| Условие | До оптимизации | После оптимизации | +|---|---:|---:| +| API-реплики | 4 | 2 | +| CPU на реплику | 0,5 | 1 | +| RAM на реплику | 256 MiB | 512 MiB | +| Суммарный бюджет API | 2 CPU / 1024 MiB | 2 CPU / 1024 MiB | +| Конкурентные клиенты | 16 | 16 | +| Прогрев | 15 с | 15 с | +| Основные измерения | 3 × 60 с | 3 × 60 с | + +Использована закрытая модель нагрузки `POST`-запросами на создание сообщений без автоматических повторных попыток. Для каждой конфигурации выполнены прогрев и три отдельных измерения. + +| Метрика | До: 4 реплики | После: 2 реплики | Изменение | +|---|---:|---:|---:| +| RPS, прогон 1 | 403,177 | 417,559 | — | +| RPS, прогон 2 | 392,746 | 416,933 | — | +| RPS, прогон 3 | 386,841 | 421,396 | — | +| Средний RPS | 394,255 | 418,629 | +6,2% | +| Средний p95 | 91,445 мс | 64,615 мс | −29,3% | +| Средний p99 | 165,019 мс | 95,539 мс | −42,1% | +| Ошибок за три прогона | 0 | 0 | — | + +**Подтверждённое улучшение:** при переходе от четырёх к двум репликам средний RPS вырос на 6,2%, средний p95 уменьшился на 29,3%, а средний p99 — на 42,1%. Во всех шести основных прогонах ошибок не зафиксировано. При этом каждый из трёх прогонов конфигурации «после» показал больший RPS, чем любой из трёх прогонов «до». + +Результат согласуется с гипотезой о преимуществах двух реплик при ограниченном бюджете, но конкретный вклад CPU throttling, планировщика и других накладных расходов в этом контрольном эксперименте отдельно не измерялся. Результаты отличаются по абсолютному RPS от ранней серии с фиксированным бюджетом; сравнивать их напрямую как единый эксперимент некорректно из-за возможных изменений состояния стенда и базы данных. Вывод «до/после» основан только на шести прогонах новой контрольной серии. + +Исходные JSON-файлы: `evidence/scale/optimization/before-run1.json` — `before-run3.json` и `after-run1.json` — `after-run3.json`; файлы прогрева хранятся в том же каталоге. Скрипт `scripts/run_optimization.sh` воспроизводит эксперимент и восстанавливает обычную конфигурацию с двумя репликами. Испытание проведено в одном локальном окружении при 16 клиентах; результат не следует обобщать на все нагрузки и оборудование. + +### Сопоставление с предыдущими экспериментами + +В исходной серии с фиксированным бюджетом конфигурация с двумя репликами также оказалась быстрее четырёх (220,996 против 104,084 RPS). Однако это отдельная серия с иными абсолютными результатами; её нельзя объединять с новым контрольным экспериментом при расчёте процента улучшения. + +Во второй серии с растущим бюджетом четыре реплики достигли 601,701 RPS при 4 CPU и 2048 MiB RAM суммарно. Поэтому преимущество двух реплик относится к **фиксированному бюджету**, а не к любым условиям масштабирования. Эксперимент с изменением CPU-периода остался отрицательным (−17,4% RPS) и не рассматривается как успешная оптимизация. + ### Итоговые выводы -В работе исследована цена горизонтального масштабирования API при фиксированном суммарном бюджете 2 CPU и 1024 MiB RAM. +В работе исследована цена горизонтального масштабирования API в двух режимах: при фиксированном суммарном бюджете 2 CPU и 1024 MiB RAM и при увеличении бюджета от 1 CPU / 512 MiB до 4 CPU / 2048 MiB. -При 16 конкурентных клиентах конфигурация с двумя репликами обеспечила максимальную среднюю пропускную способность среди проверенных вариантов — 220,996 RPS. Это приблизительно на 53,8% больше, чем у одной реплики, и на 112,3% больше, чем у четырёх. +В исходной серии с фиксированным бюджетом при 16 конкурентных клиентах конфигурация с двумя репликами обеспечила максимальную среднюю пропускную способность — 220,996 RPS. Это приблизительно на 53,8% больше, чем у одной реплики, и на 112,3% больше, чем у четырёх. При этом одна реплика показала наименьшую среднюю задержку p99 — 158,606 мс. Следовательно, оптимальный выбор зависит от требований к пропускной способности и задержкам. @@ -639,9 +706,9 @@ PostgreSQL, Redis и Nginx не масштабировались вместе с Попытка оптимизации путём увеличения периода CPU-квоты со 100 до 200 мс при сохранении общего бюджета оказалась неэффективной: RPS снизился на 17,4%. -По результатам исследования для данной нагрузки выбрана конфигурация с двумя API-репликами по 1 CPU и 512 MiB RAM. Она обеспечивает наибольшую пропускную способность среди проверенных вариантов без увеличения суммарного бюджета ресурсов. +По результатам исследования для данной нагрузки выбрана конфигурация с двумя API-репликами по 1 CPU и 512 MiB RAM. В отдельном контрольном эксперименте «до/после» при том же суммарном бюджете она обеспечила 418,629 RPS против 394,255 RPS у четырёх реплик (+6,2%) и снизила средние p95 и p99 на 29,3% и 42,1% соответственно. Это подтверждённое конфигурационное улучшение без увеличения общего бюджета API. -Таким образом, горизонтальное масштабирование необходимо оценивать экспериментально: увеличение числа реплик само по себе не гарантирует повышения производительности. +Во второй серии с растущим бюджетом средний RPS вырос с 289,590 (1 реплика) до 601,701 (4 реплики), без ошибок за девять измерений. Таким образом, горизонтальное масштабирование необходимо оценивать экспериментально: увеличение числа реплик само по себе не гарантирует повышения производительности, а выделение дополнительных ресурсов способно изменить результат. ## Команды для демонстрации @@ -806,7 +873,36 @@ python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/dem При корректной конфигурации каждая реплика имеет `NanoCpus=0`, `CpuPeriod=200000`, `CpuQuota=100000`, то есть 0,5 CPU. Для повторения методики выполнить три прогона с разными именами выходных файлов. -### 7. Возврат к основной конфигурации после демонстрации +### 7. Воспроизведение серии с растущим бюджетом + +```bash +./scripts/run_growing_scale.sh +python3 scripts/summarize_growing_scale.py +``` + +Скрипт последовательно запускает 1, 2 и 4 API-реплики с лимитами 1 CPU и 512 MiB на реплику, выполняет прогрев и три измерения по 60 секунд. Результаты сохраняются в `evidence/scale/growing/`. После завершения восстанавливается основная конфигурация двух реплик. Команда пересоздаёт контейнеры, поэтому её следует выполнять на учебном стенде. + +### 8. Воспроизведение контрольной оптимизации «до/после» + +```bash +./scripts/run_optimization.sh +``` + +Скрипт сравнивает четыре реплики по 0,5 CPU / 256 MiB и две реплики по 1 CPU / 512 MiB при одинаковом общем бюджете 2 CPU / 1024 MiB. Для каждой конфигурации выполняются 15 секунд прогрева и три измерения по 60 секунд с 16 клиентами. Результаты сохраняются в `evidence/scale/optimization/`. После эксперимента восстанавливаются две API-реплики. Скрипт пересоздаёт контейнеры без удаления volumes и предназначен для учебного стенда. + +### 9. Регрессионные тесты по замечаниям + +```bash +python3 tests/test_review_regressions.py +for service in postgres redis migrate api-1 api-2 nginx; do + echo "=== $service ===" + docker inspect "$(docker compose ps -aq "$service")" --format 'CPU: {{.HostConfig.NanoCpus}}, RAM: {{.HostConfig.Memory}} bytes' +done +``` + +Регрессионный тест проверяет UTF-8 Basic Auth с двоеточием в пароле, переход между страницами списка чатов, отсутствие курсора на последней странице и отклонение некорректного курсора. Команда `docker inspect` подтверждает ограничения всех сервисов. + +### 10. Возврат к основной конфигурации после демонстрации ```bash docker compose -f compose.yaml -f compose.scale.yaml -f compose.cpu-period.yaml down @@ -822,3 +918,5 @@ docker compose down ``` `docker compose down -v` применять только при намеренном удалении учебной базы и volumes. При защите удобно показать сначала работающие две реплики, затем `X-Instance-Id`, проверки `make`, failover и результаты масштабирования; полные 60-секундные серии можно воспроизвести по приведённым командам при необходимости. + +```` \ No newline at end of file diff --git a/compose.yaml b/compose.yaml index a91b71ee..23d7d67e 100644 --- a/compose.yaml +++ b/compose.yaml @@ -39,6 +39,8 @@ services: timeout: 3s retries: 10 restart: unless-stopped + cpus: 1.0 + mem_limit: 768m redis: image: redis:8.2.2 @@ -56,6 +58,8 @@ services: timeout: 3s retries: 10 restart: unless-stopped + cpus: 0.5 + mem_limit: 256m migrate: build: @@ -68,6 +72,8 @@ services: postgres: condition: service_healthy restart: "no" + cpus: 1.0 + mem_limit: 512m api-1: <<: *api @@ -97,6 +103,8 @@ services: - api-1 - api-2 restart: unless-stopped + cpus: 0.5 + mem_limit: 256m secrets: postgres_password: @@ -108,4 +116,4 @@ secrets: volumes: postgres_data: - redis_data: \ No newline at end of file + redis_data: diff --git a/evidence/scale/growing/replicas-1-run1.json b/evidence/scale/growing/replicas-1-run1.json new file mode 100644 index 00000000..db117b39 --- /dev/null +++ b/evidence/scale/growing/replicas-1-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.038, + "concurrency": 16, + "successful_requests": 17175, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 286.068, + "successful_latency_ms": { + "p50": 52.594, + "p95": 81.865, + "p99": 108.938 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-1-run2.json b/evidence/scale/growing/replicas-1-run2.json new file mode 100644 index 00000000..8cb3635c --- /dev/null +++ b/evidence/scale/growing/replicas-1-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.042, + "concurrency": 16, + "successful_requests": 17543, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 292.177, + "successful_latency_ms": { + "p50": 52.781, + "p95": 69.305, + "p99": 105.621 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-1-run3.json b/evidence/scale/growing/replicas-1-run3.json new file mode 100644 index 00000000..0a07f3bf --- /dev/null +++ b/evidence/scale/growing/replicas-1-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.047, + "concurrency": 16, + "successful_requests": 17445, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 290.524, + "successful_latency_ms": { + "p50": 52.874, + "p95": 66.813, + "p99": 106.086 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-1-warmup.json b/evidence/scale/growing/replicas-1-warmup.json new file mode 100644 index 00000000..67beb9db --- /dev/null +++ b/evidence/scale/growing/replicas-1-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.039, + "concurrency": 16, + "successful_requests": 4643, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 308.737, + "successful_latency_ms": { + "p50": 49.524, + "p95": 68.017, + "p99": 99.238 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-2-run1.json b/evidence/scale/growing/replicas-2-run1.json new file mode 100644 index 00000000..40140d14 --- /dev/null +++ b/evidence/scale/growing/replicas-2-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.024, + "concurrency": 16, + "successful_requests": 25283, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 421.214, + "successful_latency_ms": { + "p50": 40.975, + "p95": 64.203, + "p99": 94.122 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-2-run2.json b/evidence/scale/growing/replicas-2-run2.json new file mode 100644 index 00000000..2503334d --- /dev/null +++ b/evidence/scale/growing/replicas-2-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.037, + "concurrency": 16, + "successful_requests": 25588, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 426.204, + "successful_latency_ms": { + "p50": 40.434, + "p95": 63.728, + "p99": 93.727 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-2-run3.json b/evidence/scale/growing/replicas-2-run3.json new file mode 100644 index 00000000..c433733c --- /dev/null +++ b/evidence/scale/growing/replicas-2-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.04, + "concurrency": 16, + "successful_requests": 25843, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 430.432, + "successful_latency_ms": { + "p50": 36.673, + "p95": 61.779, + "p99": 91.761 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-2-warmup.json b/evidence/scale/growing/replicas-2-warmup.json new file mode 100644 index 00000000..fab09d67 --- /dev/null +++ b/evidence/scale/growing/replicas-2-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.038, + "concurrency": 16, + "successful_requests": 7179, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 477.394, + "successful_latency_ms": { + "p50": 31.008, + "p95": 58.811, + "p99": 74.541 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-4-run1.json b/evidence/scale/growing/replicas-4-run1.json new file mode 100644 index 00000000..e5de2d50 --- /dev/null +++ b/evidence/scale/growing/replicas-4-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.025, + "concurrency": 16, + "successful_requests": 35821, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 596.766, + "successful_latency_ms": { + "p50": 24.158, + "p95": 43.446, + "p99": 84.503 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-4-run2.json b/evidence/scale/growing/replicas-4-run2.json new file mode 100644 index 00000000..39c80568 --- /dev/null +++ b/evidence/scale/growing/replicas-4-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.026, + "concurrency": 16, + "successful_requests": 36198, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 603.038, + "successful_latency_ms": { + "p50": 24.296, + "p95": 41.592, + "p99": 78.952 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-4-run3.json b/evidence/scale/growing/replicas-4-run3.json new file mode 100644 index 00000000..0e12e9d8 --- /dev/null +++ b/evidence/scale/growing/replicas-4-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.028, + "concurrency": 16, + "successful_requests": 36335, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 605.3, + "successful_latency_ms": { + "p50": 24.214, + "p95": 40.08, + "p99": 75.496 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-4-warmup.json b/evidence/scale/growing/replicas-4-warmup.json new file mode 100644 index 00000000..ac8fa495 --- /dev/null +++ b/evidence/scale/growing/replicas-4-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.026, + "concurrency": 16, + "successful_requests": 9974, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 663.761, + "successful_latency_ms": { + "p50": 21.623, + "p95": 38.696, + "p99": 85.055 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/after-run1.json b/evidence/scale/optimization/after-run1.json new file mode 100644 index 00000000..6fc76ffe --- /dev/null +++ b/evidence/scale/optimization/after-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.037, + "concurrency": 16, + "successful_requests": 25069, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 417.559, + "successful_latency_ms": { + "p50": 37.705, + "p95": 63.254, + "p99": 94.489 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/after-run2.json b/evidence/scale/optimization/after-run2.json new file mode 100644 index 00000000..d4c16537 --- /dev/null +++ b/evidence/scale/optimization/after-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.038, + "concurrency": 16, + "successful_requests": 25032, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 416.933, + "successful_latency_ms": { + "p50": 40.359, + "p95": 65.787, + "p99": 102.35 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/after-run3.json b/evidence/scale/optimization/after-run3.json new file mode 100644 index 00000000..4c3c322c --- /dev/null +++ b/evidence/scale/optimization/after-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.039, + "concurrency": 16, + "successful_requests": 25300, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 421.396, + "successful_latency_ms": { + "p50": 39.572, + "p95": 64.804, + "p99": 89.779 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/after-warmup.json b/evidence/scale/optimization/after-warmup.json new file mode 100644 index 00000000..a55d4f28 --- /dev/null +++ b/evidence/scale/optimization/after-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.034, + "concurrency": 16, + "successful_requests": 7049, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 468.855, + "successful_latency_ms": { + "p50": 33.257, + "p95": 55.415, + "p99": 74.659 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/before-run1.json b/evidence/scale/optimization/before-run1.json new file mode 100644 index 00000000..a3328af6 --- /dev/null +++ b/evidence/scale/optimization/before-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.098, + "concurrency": 16, + "successful_requests": 24230, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 403.177, + "successful_latency_ms": { + "p50": 20.095, + "p95": 90.688, + "p99": 177.425 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/before-run2.json b/evidence/scale/optimization/before-run2.json new file mode 100644 index 00000000..ca2e76b4 --- /dev/null +++ b/evidence/scale/optimization/before-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.024, + "concurrency": 16, + "successful_requests": 23574, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 392.746, + "successful_latency_ms": { + "p50": 21.246, + "p95": 90.636, + "p99": 155.902 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/before-run3.json b/evidence/scale/optimization/before-run3.json new file mode 100644 index 00000000..edcc5240 --- /dev/null +++ b/evidence/scale/optimization/before-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.097, + "concurrency": 16, + "successful_requests": 23248, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 386.841, + "successful_latency_ms": { + "p50": 22.844, + "p95": 93.01, + "p99": 161.73 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/before-warmup.json b/evidence/scale/optimization/before-warmup.json new file mode 100644 index 00000000..f76957f9 --- /dev/null +++ b/evidence/scale/optimization/before-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.075, + "concurrency": 16, + "successful_requests": 6116, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 405.708, + "successful_latency_ms": { + "p50": 19.709, + "p95": 88.349, + "p99": 172.728 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/scripts/run_growing_scale.sh b/scripts/run_growing_scale.sh new file mode 100755 index 00000000..3b60c287 --- /dev/null +++ b/scripts/run_growing_scale.sh @@ -0,0 +1,28 @@ +#!/usr/bin/env bash +set -euo pipefail +cd "$(dirname "$0")/.." +mkdir -p evidence/scale/growing +for replicas in 1 2 4; do + export API_REPLICAS="$replicas" + export API_CPUS=1.0 + export API_MEMORY=512m + docker compose -f compose.yaml -f compose.scale.yaml down + services=(postgres redis migrate nginx) + for ((i=1;i<=replicas;i++)); do services+=("api-$i"); done + docker compose -f compose.yaml -f compose.scale.yaml up -d --build "${services[@]}" + for ((attempt=1;attempt<=60;attempt++)); do + if curl --fail --silent http://localhost:8080/health/ready >/dev/null; then break; fi + sleep 2 + done + curl --fail --silent http://localhost:8080/health/ready >/dev/null + for ((i=1;i<=replicas;i++)); do + docker compose -f compose.yaml -f compose.scale.yaml ps "api-$i" + done + python3 tests/load.py --duration 15 --concurrency 16 --output "evidence/scale/growing/replicas-${replicas}-warmup.json" + for run in 1 2 3; do + python3 tests/load.py --duration 60 --concurrency 16 --output "evidence/scale/growing/replicas-${replicas}-run${run}.json" + done +done +API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m 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 +python3 scripts/summarize_growing_scale.py diff --git a/scripts/run_optimization.sh b/scripts/run_optimization.sh new file mode 100755 index 00000000..bde0b4f1 --- /dev/null +++ b/scripts/run_optimization.sh @@ -0,0 +1,65 @@ +#!/usr/bin/env bash +set -euo pipefail + +cd "$(dirname "$0")/.." +mkdir -p evidence/scale/optimization + +run_case() { + local name="$1" + local replicas="$2" + local cpus="$3" + local memory="$4" + + export API_REPLICAS="$replicas" + export API_CPUS="$cpus" + export API_MEMORY="$memory" + + echo "=== $name: $replicas replicas, $cpus CPU and $memory per replica ===" + + docker compose -f compose.yaml -f compose.scale.yaml down + + services=(postgres redis migrate nginx) + for ((i=1; i<=replicas; i++)); do + services+=("api-$i") + done + + docker compose -f compose.yaml -f compose.scale.yaml up -d --build "${services[@]}" + + ready=0 + for ((attempt=1; attempt<=60; attempt++)); do + if curl --fail --silent http://localhost:8080/health/ready >/dev/null; then + ready=1 + break + fi + sleep 2 + done + + if ((ready == 0)); then + echo "ERROR: API readiness timeout" >&2 + exit 1 + fi + + python3 tests/load.py \ + --duration 15 \ + --concurrency 16 \ + --output "evidence/scale/optimization/${name}-warmup.json" + + for run in 1 2 3; do + python3 tests/load.py \ + --duration 60 \ + --concurrency 16 \ + --output "evidence/scale/optimization/${name}-run${run}.json" + done +} + +run_case before 4 0.5 256m +run_case after 2 1.0 512m + +API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m \ + 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 + +echo "=== Optimization experiment completed ===" diff --git a/scripts/summarize_growing_scale.py b/scripts/summarize_growing_scale.py new file mode 100644 index 00000000..be7b0dd8 --- /dev/null +++ b/scripts/summarize_growing_scale.py @@ -0,0 +1,17 @@ +import json +import statistics +from pathlib import Path + +root = Path('evidence/scale/growing') +print('Growing budget: 1/2/4 replicas, each 1 CPU and 512 MiB, 16 clients, 60 seconds, 3 runs') +for replicas in (1, 2, 4): + files = [root / f'replicas-{replicas}-run{i}.json' for i in (1, 2, 3)] + if not all(p.exists() for p in files): + print(f'{replicas}: INCOMPLETE (measurements not yet run)') + continue + data = [json.loads(p.read_text()) for p in files] + values = [x['successful_rps'] for x in data] + errors = sum(x['failed_requests'] for x in data) + print(f'{replicas}: mean RPS={statistics.mean(values):.3f}, stdev={statistics.stdev(values):.3f}, ' + f'mean p95={statistics.mean(x["successful_latency_ms"]["p95"] for x in data):.3f} ms, ' + f'mean p99={statistics.mean(x["successful_latency_ms"]["p99"] for x in data):.3f} ms, errors={errors}') diff --git a/src/cursor.py b/src/cursor.py index 16702905..23dfb48b 100644 --- a/src/cursor.py +++ b/src/cursor.py @@ -57,4 +57,30 @@ def decode_cursor(cursor: str) -> tuple[UUID, datetime, UUID]: binascii.Error, json.JSONDecodeError, ) as exc: - raise ValueError("Invalid cursor") from exc \ No newline at end of file + raise ValueError("Invalid cursor") from exc + + +def encode_chat_cursor(user_id: UUID, created_at: datetime, chat_id: UUID) -> str: + data = { + "user_id": str(user_id), + "created_at": created_at.isoformat(), + "chat_id": str(chat_id), + } + raw = json.dumps(data, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii") + + +def decode_chat_cursor(cursor: str) -> tuple[UUID, datetime, UUID]: + try: + raw = base64.b64decode(cursor.encode("ascii"), altchars=b"-_", validate=True) + data = json.loads(raw.decode("utf-8")) + if not isinstance(data, dict) or set(data) != {"user_id", "created_at", "chat_id"}: + raise ValueError("Invalid cursor") + user_id = UUID(data["user_id"]) + created_at = datetime.fromisoformat(data["created_at"]) + chat_id = UUID(data["chat_id"]) + if created_at.tzinfo is None or created_at.utcoffset() is None: + raise ValueError("Invalid cursor") + return user_id, created_at, chat_id + except (ValueError, TypeError, KeyError, UnicodeError, binascii.Error, json.JSONDecodeError) as exc: + raise ValueError("Invalid cursor") from exc diff --git a/src/main.py b/src/main.py index 0560594a..0295542b 100644 --- a/src/main.py +++ b/src/main.py @@ -2,14 +2,14 @@ from datetime import datetime, timedelta, timezone from uuid import UUID, uuid4 import os import re +import base64 +import binascii from fastapi import Depends, FastAPI, Request, Header from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse from fastapi.security import ( HTTPAuthorizationCredentials, - HTTPBasic, - HTTPBasicCredentials, HTTPBearer, ) from sqlalchemy.exc import IntegrityError, SQLAlchemyError @@ -50,7 +50,6 @@ async def lifespan(app: FastAPI): app = FastAPI(lifespan=lifespan) INSTANCE_ID = os.getenv("INSTANCE_ID") or str(uuid4()) -basic_security = HTTPBasic(auto_error=False) bearer_security = HTTPBearer(auto_error=False) @@ -300,22 +299,32 @@ async def get_me( status_code=201, ) async def create_auth_session( - credentials: HTTPBasicCredentials | None = Depends(basic_security), + authorization: str | None = Header(default=None), session: AsyncSession = Depends(get_db_session), ): + credentials = None + if authorization is not None: + scheme, separator, encoded = authorization.partition(" ") + if separator and scheme.lower() == "basic": + try: + decoded = base64.b64decode(encoded.strip(), validate=True).decode("utf-8") + if ":" in decoded: + credentials = decoded.split(":", 1) + except (ValueError, UnicodeError, binascii.Error): + pass if credentials is None: raise APIError( status_code=401, code="unauthorized", message="Unauthorized", headers={ - "WWW-Authenticate": 'Basic realm="messenger"', + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"', }, ) user_credentials = await get_user_credentials_by_username( session, - credentials.username, + credentials[0], ) if user_credentials is None: @@ -324,20 +333,20 @@ async def create_auth_session( code="unauthorized", message="Unauthorized", headers={ - "WWW-Authenticate": 'Basic realm="messenger"', + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"', }, ) if not verify_password( user_credentials.password_hash, - credentials.password, + credentials[1], ): raise APIError( status_code=401, code="unauthorized", message="Unauthorized", headers={ - "WWW-Authenticate": 'Basic realm="messenger"', + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"', }, ) @@ -401,6 +410,7 @@ async def create_chat_endpoint( ) async def get_chats( limit: int = 50, + cursor: str | None = None, current_user: User = Depends(get_current_user), session: AsyncSession = Depends(get_db_session), ) -> ChatPage: @@ -415,6 +425,7 @@ async def get_chats( session=session, current_user_id=current_user.id, limit=limit, + cursor=cursor, ) @@ -514,4 +525,4 @@ async def get_messages_endpoint( current_user_id=current_user.id, limit=limit, cursor=cursor, - ) \ No newline at end of file + ) diff --git a/src/repositories.py b/src/repositories.py index f7b6c335..f0020c69 100644 --- a/src/repositories.py +++ b/src/repositories.py @@ -8,7 +8,7 @@ from sqlalchemy.ext.asyncio import AsyncSession from src.models import Chat, ChatPage, CreateChat, CreateUser, User, CreateMessage, Message, MessagePage from src.security import hash_password from src.errors import APIError -from src.cursor import decode_cursor, encode_cursor +from src.cursor import decode_cursor, encode_cursor, decode_chat_cursor, encode_chat_cursor async def create_user( @@ -269,33 +269,48 @@ async def list_chats( session: AsyncSession, current_user_id: UUID, limit: int, + cursor: str | None = None, ) -> ChatPage: - chats_result = await session.execute( + cursor_created_at = None + cursor_chat_id = None + if cursor is not None: + try: + cursor_user_id, cursor_created_at, cursor_chat_id = decode_chat_cursor(cursor) + except ValueError as exc: + raise APIError(status_code=400, code="invalid_request", message="Invalid cursor") from exc + if cursor_user_id != current_user_id: + raise APIError(status_code=400, code="invalid_request", message="Invalid cursor") + + result = await session.execute( text( """ - SELECT - c.id, - c.title, - c.created_at + SELECT c.id, c.title, c.created_at FROM chats AS c - JOIN chat_members AS cm - ON cm.chat_id = c.id + JOIN chat_members AS cm ON cm.chat_id = c.id WHERE cm.user_id = :current_user_id + AND ( + CAST(:cursor_created_at AS timestamptz) IS NULL + OR (c.created_at, c.id) > ( + CAST(:cursor_created_at AS timestamptz), + CAST(:cursor_chat_id AS uuid) + ) + ) ORDER BY c.created_at, c.id - LIMIT :limit + LIMIT :fetch_limit """ ), { "current_user_id": current_user_id, - "limit": limit, + "cursor_created_at": cursor_created_at, + "cursor_chat_id": cursor_chat_id, + "fetch_limit": limit + 1, }, ) - - chat_rows = chats_result.all() - + rows = result.all() + has_more = len(rows) > limit + page_rows = rows[:limit] items = [] - - for chat_row in chat_rows: + for chat_row in page_rows: members_result = await session.execute( text( """ @@ -305,29 +320,23 @@ async def list_chats( ORDER BY user_id """ ), - { - "chat_id": chat_row.id, - }, + {"chat_id": chat_row.id}, ) - - member_ids = [ - UUID(str(row.user_id)) - for row in members_result - ] - items.append( Chat( id=UUID(str(chat_row.id)), title=chat_row.title, - member_ids=member_ids, + member_ids=[UUID(str(row.user_id)) for row in members_result], created_at=chat_row.created_at, ) ) - - return ChatPage( - items=items, - next_cursor=None, - ) + next_cursor = None + if has_more: + last = page_rows[-1] + next_cursor = encode_chat_cursor( + current_user_id, last.created_at, UUID(str(last.id)) + ) + return ChatPage(items=items, next_cursor=next_cursor) async def create_message( @@ -643,4 +652,4 @@ async def get_messages( return MessagePage( items=items, next_cursor=next_cursor, - ) \ No newline at end of file + ) diff --git a/tests/test_review_regressions.py b/tests/test_review_regressions.py new file mode 100644 index 00000000..4ee97ada --- /dev/null +++ b/tests/test_review_regressions.py @@ -0,0 +1,52 @@ +import base64 +import json +import os +import time +import urllib.error +import urllib.parse +import urllib.request + +BASE_URL = os.environ.get('BASE_URL', 'http://localhost:8080') + + +def request(method, path, body=None, token=None, basic=None, expected=200): + headers = {} + if body is not None: + headers['Content-Type'] = 'application/json' + if token: + headers['Authorization'] = 'Bearer ' + token + if basic: + headers['Authorization'] = 'Basic ' + base64.b64encode(basic.encode('utf-8')).decode('ascii') + data = json.dumps(body, ensure_ascii=False).encode('utf-8') if body is not None else None + req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(req, timeout=15) as response: + status = response.status + result = response.read() + except urllib.error.HTTPError as exc: + status = exc.code + result = exc.read() + assert status == expected, f'{method} {path}: expected {expected}, got {status}: {result!r}' + return json.loads(result) if result else None + + +def main(): + username = 'review_' + str(time.time_ns())[-16:] + password = 'Пример:пароля-12345' + user = request('POST', '/api/v1/users', {'username': username, 'display_name': 'Проверка', 'password': password}, expected=201) + session = request('POST', '/api/v1/auth/sessions', basic=username + ':' + password, expected=201) + assert session['user']['id'] == user['id'] + token = session['token'] + first = request('POST', '/api/v1/chats', {'title': 'Первый', 'member_ids': [user['id']]}, token=token, expected=201) + second = request('POST', '/api/v1/chats', {'title': 'Второй', 'member_ids': [user['id']]}, token=token, expected=201) + page1 = request('GET', '/api/v1/chats?limit=1', token=token) + assert len(page1['items']) == 1 and page1['next_cursor'], page1 + page2 = request('GET', '/api/v1/chats?limit=1&cursor=' + urllib.parse.quote(page1['next_cursor']), token=token) + assert len(page2['items']) == 1 and page2['next_cursor'] is None, page2 + assert [page1['items'][0]['id'], page2['items'][0]['id']] == [first['id'], second['id']] + request('GET', '/api/v1/chats?limit=1&cursor=invalid', token=token, expected=400) + print('PASS: UTF-8 Basic Auth, colon in password, chat cursor, last page, invalid cursor') + + +if __name__ == '__main__': + main()