фикс из пр

This commit is contained in:
2026-10-22 17:21:52 +03:00
parent 1ed7710973
commit 8d9dfc2da6
29 changed files with 716 additions and 62 deletions
+117 -19
View File
@@ -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-секундные серии можно воспроизвести по приведённым командам при необходимости.
````
+9 -1
View File
@@ -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:
redis_data:
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
@@ -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."
}
+28
View File
@@ -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
+65
View File
@@ -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 ==="
+17
View File
@@ -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}')
+27 -1
View File
@@ -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
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
+21 -10
View File
@@ -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,
)
)
+40 -31
View File
@@ -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,
)
)
+52
View File
@@ -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()