diff --git a/REPORT.md b/REPORT.md index 5814508..50f628b 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,243 +1,262 @@ -Отчёт — лабораторная 3 +# Отчёт — лабораторная 3 - Автор, группа: Кузнецова Марина, БВТ2304 - Целевая оценка; выбранный трек 5. Трек 1 — цена масштабирования - Commit/PR: пока пусто - Использованные источники, библиотеки и помощь ИИ: официальная документация FastAPI, asyncpg, Nginx, Docker Compose. ИИ применялся для пояснения требований задания, обсуждения архитектурных решений и проверки корректности реализации. +- **Автор, группа:** Кузнецова Марина, БВТ2304 +- **Целевая оценка:** 5, Трек 1 — цена масштабирования +- **Commit/PR:** пока пусто +- **Использованные источники и помощь ИИ:** официальная документация FastAPI, asyncpg, Nginx, Docker Compose. ИИ применялся для пояснения требований, обсуждения архитектурных решений и проверки корректности реализации. -Запуск из чистого clone +## Запуск из чистого clone Требования к окружению: - Python 3.13.15 - Docker 26.1.1 - git +- Python 3.13.15 +- Docker 26.1.1 +- git Подготовка и запуск через Docker Compose: -cp .env.example .env -docker compose --env-file .env up -d --build --scale api=2 + cp .env.example .env + docker compose --env-file .env up -d --build --scale api=2 -Ожидаемый признак готовности: ответ {"status":"ok"} на http://localhost:8080/health/ready. В логах migrate должна быть строка migrations applied, контейнер migrate переходит в Exited (0). Реплики api-1 и api-2 становятся healthy. +Ожидаемый признак готовности: ответ `{"status":"ok"}` на `http://localhost:8080/health/ready`. В логах `migrate` должна быть строка `migrations applied`, контейнер `migrate` переходит в `Exited (0)`. Реплики `api-1` и `api-2` становятся `healthy`. -Проверка публичным smoke-тестом (в отдельном терминале, при запущенном стенде): +Проверка публичным smoke-тестом: -python tests/smoke.py --base-url http://localhost:8080 + python -X utf8 tests/smoke.py --base-url http://localhost:8080 Проверка собственными тестами: -pytest student-tests/test_validation.py -v -pytest student-tests/test_race.py -v -pytest student-tests/test_cache.py::test_read_after_write_sees_new_message -v + python -X utf8 -m pytest student-tests/test_validation.py -v + python -X utf8 -m pytest student-tests/test_race.py -v + python -X utf8 -m pytest student-tests/test_cache.py -v -Проверка сохранности (перезапуск API и всех хранилищ с сохранением volumes): +Проверка сохранности: -python tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:8080 + python -X utf8 tests/resilience.py --mode persistence --action-script scripts/restart.cmd --base-url http://localhost:8080 Проверка отказа одной реплики: -python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://localhost:8080 + python -X utf8 tests/resilience.py --mode failover --action-script scripts/stop-one.cmd --base-url http://localhost:8080 Проверка идемпотентности: -python scripts/test-idempotency.py + python -X utf8 scripts/test-idempotency.py Проверка времени обнаружения отказа: -python scripts/measure-detection.py + python -X utf8 scripts/measure-detection.py Проверка rolling update: -python scripts/rolling-update.py + python -X utf8 scripts/rolling-update.py Бенчмарк масштабирования: -python scripts/scaling-benchmark.py + python -X utf8 scripts/fair-scaling-benchmark.py Безопасная остановка: - docker compose down — остановка без потери данных. - docker compose down -v — удаление volumes, все данные пропадут. Использовать только для чистого повтора. +- `docker compose down` — остановка без потери данных. +- `docker compose down -v` — удаление volumes, все данные пропадут. -Удаление учебных данных: остановка без -v данные сохраняет; для полного сброса используется docker compose down -v. - -Секреты: в .env.example указаны только учебные значения (POSTGRES_USER=messenger, POSTGRES_PASSWORD=messenger). Файл .env создаётся локально из .env.example и не коммитится. - -Архитектура и решения +## Архитектура и решения Схема: -Client → HTTP (Nginx :8080) → api-1, api-2 (FastAPI/Uvicorn) - ↓ - PostgreSQL (users/chats/messages/idempotency_keys) - Valkey (sessions + cache) + Client → HTTP (Nginx :8080) → api-1, api-2 (FastAPI/Uvicorn) + ↓ + PostgreSQL (users/chats/messages/idempotency_keys) + Valkey (sessions + cache) Компоненты: - compose.yaml — шесть сервисов: postgres, valkey, migrate, api, lb. - nginx.conf — конфигурация балансировщика. - app/main.py — создание FastAPI, lifespan, middleware для X-Request-Id и X-Instance-Id, обработчики ошибок, подключение роутеров. - app/config.py — конфигурация из переменных окружения: DATABASE_URL, SESSION_TTL_SECONDS, SESSION_STORE, CACHE_URL, INSTANCE_ID. - app/db.py — асинхронный пул соединений asyncpg. - app/migrate.py — отдельный модуль для применения миграций. Запускается сервисом migrate. - app/migrations.py — раннер миграций: читает SQL-файлы из migrations/, применяет новые, ведёт applied_migrations. - app/models.py — Pydantic-модели. - app/security.py — Argon2id для паролей, токены, Basic и Bearer, get_current_user. - app/storage.py — работа с PostgreSQL. Параметризованные запросы, транзакции, idempotency_keys. - app/session_store.py — два backend для сессий: PostgreSQL и Redis/Valkey. - app/cache.py — кэш истории сообщений и single-flight через Redis SET NX. - app/api/health.py, users.py, auth.py, chats.py — обработчики эндпоинтов. - migrations/*.sql — 8 миграций: users, chats, chat_members, messages, sessions, messages_index, idempotency, idempotency_index. - scripts/stop-one.py, stop-one.cmd — остановка одной API-реплики. - scripts/measure-detection.py — замер времени обнаружения отказа. - scripts/rolling-update.py — rolling update под нагрузкой. - scripts/test-idempotency.py — тест идемпотентности под нагрузкой. - scripts/scaling-benchmark.py — бенчмарк масштабирования. - compose-scale.yaml — override для смены лимитов и числа реплик. +- `compose.yaml` — сервисы: postgres, valkey, migrate, api, lb. +- `nginx.conf` — конфигурация балансировщика. +- `app/main.py` — FastAPI, lifespan, middleware для `X-Request-Id` и `X-Instance-Id`, обработчики ошибок. +- `app/config.py` — конфигурация из переменных окружения. +- `app/db.py` — асинхронный пул соединений asyncpg. +- `app/migrate.py` — отдельный модуль для применения миграций. +- `app/migrations.py` — раннер миграций. +- `app/models.py` — Pydantic-модели с валидацией. +- `app/security.py` — Argon2id, токены, Basic и Bearer. +- `app/storage.py` — работа с PostgreSQL, транзакции, `idempotency_keys`, версионирование кэша. +- `app/session_store.py` — backend для сессий. +- `app/cache.py` — кэш истории и single-flight. +- `migrations/*.sql` — 9 миграций. +- `scripts/stop-one.py`, `stop-one.cmd` — остановка реплики. +- `scripts/measure-detection.py`, `rolling-update.py`, `test-idempotency.py`, `fair-scaling-benchmark.py` — эксперименты. +- `compose-scale.yaml` — override для смены лимитов и числа реплик. -Источник истины: PostgreSQL для пользователей, чатов, участников, сообщений, idempotency_keys. Сессии — в Valkey с TTL 3600 секунд. Кэш истории — в Valkey с TTL 30 секунд. При перезапуске Valkey сессии и кэш восстанавливаются из append-only файла (--appendonly yes). +**Источник истины:** PostgreSQL для пользователей, чатов, участников, сообщений, `idempotency_keys`. Сессии — в Valkey с TTL 3600 секунд. Кэш истории — в Valkey с TTL 30 секунд. При перезапуске Valkey сессии и кэш восстанавливаются из AOF (`--appendonly yes`). -Транзакционные границы: операции с пользователями и сообщениями — один SQL-запрос. Создание чата вместе со всеми участниками — в одной транзакции asyncpg. Запись в idempotency_keys и вставка сообщения — в одной транзакции. Уникальность username и Idempotency-Key гарантируется UNIQUE/PK-констрейнтами в БД, а не проверкой в коде. +**Транзакционные границы:** операции с пользователями и сообщениями — один SQL-запрос. Создание чата с участниками — одна транзакция. Запись в `idempotency_keys` и вставка сообщения — одна транзакция. Уникальность `username` и `Idempotency-Key` гарантируется констрейнтами БД. -Идентификация и сессии. С lab2 применяется Basic → Bearer. POST /api/v1/auth/sessions принимает Basic, возвращает 201 с токеном (secrets.token_urlsafe(48)) и сроком действия. Все бизнес-эндпоинты требуют Bearer. X-User-Id игнорируется. DELETE /auth/sessions/current отзывает сессию и возвращает 204. +**Идемпотентность.** Обязательный `Idempotency-Key` (`ASCII [A-Za-z0-9._:-]{1,128}`). Область уникальности: `user_id + method + path + key`. При повторе того же тела — сохранённый 201. При другом теле — 409. Конкурентные повторы через разные реплики создают одно сообщение. -Идемпотентность POST сообщений. Обязательный заголовок Idempotency-Key (ASCII [A-Za-z0-9._:-]{1,128}). Область уникальности: user_id + method + path + key. При повторе того же тела сервер возвращает сохранённый ответ 201. При другом теле — 409. Одновременные повторы через разные реплики создают ровно одно сообщение благодаря PRIMARY KEY на idempotency_keys и обработке UniqueViolationError с повторным чтением записи. +**X-Instance-Id.** Генерируется в `Dockerfile` через `secrets.token_hex(6)`, логируется при старте. Middleware добавляет заголовок во все ответы. -X-Instance-Id. Генерируется в Dockerfile через secrets.token_hex(6), логируется при старте. Middleware добавляет заголовок во все ответы. По нему видно, какая реплика обслужила запрос. +**Балансировка.** Nginx с round-robin (после улучшения), `max_fails=1 fail_timeout=10s`, `proxy_next_upstream error timeout http_502 http_503 http_504`. API-реплики не публикуют порты наружу. -Балансировка. Nginx с round-robin (после улучшения), max_fails=1 fail_timeout=60s, proxy_connect_timeout=1s, proxy_next_upstream error timeout http_502 http_503 http_504. API-реплики не публикуют порты наружу. +**Healthcheck.** У api: `interval=5s`, `timeout=3s`, `retries=3`, `start_period=10s`. Readiness проверяет PostgreSQL и Valkey через `asyncio.wait_for` с таймаутом 2 секунды. -Healthcheck. У api healthcheck с interval=5s, timeout=3s, retries=3, start_period=10s. Readiness проверяет PostgreSQL и Valkey через asyncio.wait_for с таймаутом 2 секунды. +**Миграции.** Отдельный сервис `migrate` запускается однократно и завершается с `Exited (0)`. API стартует после `service_completed_successfully`. -Миграции. Отдельный сервис migrate запускается однократно и завершается с Exited (0). API стартует после service_completed_successfully. Нет гонки между репликами за применение миграций. +**Версионирование кэша.** В `chats` добавлена колонка `version BIGINT NOT NULL DEFAULT 0`. При POST `version` увеличивается. При записи в кэш сохраняется версия. При чтении проверяется совпадение с текущей версией в БД. Если версия изменилась — кэш удаляется, результат не публикуется. Это защищает от race condition: старый GET не сможет опубликовать устаревший снимок после инвалидации. -Обработка ошибок: единый формат {"error": {"code", "message", "request_id"}}. При недоступности PostgreSQL или Valkey /health/ready возвращает 503 unavailable. +**Валидация входных моделей.** Pydantic `extra="forbid"` — лишние поля → 400. `field_validator` проверяет наличие непробельных символов в `display_name`, `title`, `text`. -Пагинация: keyset-cursor по (created_at, id). Cursor привязан к чату: при несовпадении — 400. +**Валидация `member_ids`.** В `create_chat` до обращения к БД проверяются дубликаты и формат UUID. Невалидный UUID или дубликат → 400. -Кэш истории. Ключ messages:::, TTL 30 секунд. При вставке нового сообщения add_message инвалидирует все ключи messages::*. Защита от cache stampede — single-flight через try_lock (SET NX EX). Проверка членства выполняется до возврата из кэша. +**Обработка ошибок:** единый формат `{"error": {"code", "message", "request_id"}}`. При недоступности PostgreSQL или Valkey `/health/ready` → 503 `unavailable`. `HTTPException`, `PostgresConnectionError`, `redis.exceptions.ConnectionError` обрабатываются в `main.py`. -Соответствие переменных .env.example: +**Пагинация:** keyset-cursor по `(created_at, id)`. Cursor привязан к чату: `||`, при несовпадении — 400. - APP_HOST / APP_PORT — задаются в compose.yaml. - SESSION_TTL_SECONDS — срок жизни сессии, 3600. - DATABASE_URL — строка подключения к PostgreSQL. - SESSION_STORE — redis. - CACHE_URL — redis://valkey:6379/0. - API_CPUS / API_MEMORY — лимиты реплик (через compose-scale.yaml). +**Кэш истории.** Ключ `messages:::`, TTL 30 секунд. При вставке `add_message` инвалидирует все ключи `messages::*`. Защита от cache stampede — single-flight через `try_lock` (`SET NX EX`). Проверка членства выполняется до возврата из кэша. -Доказательства критериев «3» -Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства -Публичный smoke python tests/smoke.py --base-url http://localhost:8080 PASS: lab3 public API scenario лог терминала -≥2 API-реплики через LB python -c "...20 GET /health/live..." Counter({'...': 10, '...': 10}) лог терминала -Разные реплики для одного токена python -c "...10 GET /users/me..." два id, по 5 лог терминала -Failover одной реплики python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd ... PASS, 7 успешных, 0 ошибок, recovery 5.1 с лог терминала -Persistence python tests/resilience.py --mode persistence --action-script scripts/restart.cmd ... PASS лог терминала -Идемпотентность python scripts/test-idempotency.py 10×201, 1 сообщение evidence/idempotency.json -Свои тесты pytest student-tests/ -v 13 passed лог pytest +## Доказательства критериев «3» -Доказательства критериев «4» -Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства -Healthcheck API docker compose ps Up (healthy) вывод команды -Healthcheck Nginx nginx.conf max_fails=1, fail_timeout=60s, proxy_read_timeout=1s nginx.conf -CPU/RAM-лимиты compose.yaml deploy.resources.limits для всех сервисов compose.yaml -Нет container_name compose.yaml не используется compose.yaml -Миграции однократно docker compose logs migrate migrations applied, Exited (0) лог терминала -Период проверок и время обнаружения python scripts/measure-detection.py max 0.046 сек, среднее 0.033 сек evidence/detection.json -Rolling update под нагрузкой python scripts/rolling-update.py 1294 успешных, 6710 ошибок, avg 39.7 мс evidence/rolling-update.json -Идемпотентность через разные реплики python scripts/test-idempotency.py 2 реплики, 1 сообщение evidence/idempotency.json +| Критерий | Команда | Результат | +|----------|---------|-----------| +| Публичный smoke | `python -X utf8 tests/smoke.py --base-url http://localhost:8080` | PASS: lab3 public API scenario | +| ≥2 API-реплики через LB | `python -X utf8 scripts/check-balance.py` | Counter({'f7c6d1104aab': 200, '1a6b2e1b3b45': 200}) | +| Разные реплики для одного токена | `python -X utf8 -c "...10 GET /users/me..."` | два id, по 5 | +| Failover одной реплики | `python -X utf8 tests/resilience.py --mode failover --action-script scripts/stop-one.cmd` | PASS, 7 успешных, 0 ошибок, recovery 5.1 с | +| Persistence | `python -X utf8 tests/resilience.py --mode persistence --action-script scripts/restart.cmd` | PASS | +| Идемпотентность | `python -X utf8 scripts/test-idempotency.py` | 10×201, 1 сообщение | +| Свои тесты | `python -X utf8 -m pytest student-tests/test_validation.py student-tests/test_race.py student-tests/test_cache.py -v` | 14 passed | -Трек 1: цена масштабирования +## Доказательства критериев «4» -Гипотеза: при фиксированных суммарных ресурсах API (2 CPU, 512 МБ) увеличение числа реплик с 1 до 2 удваивает RPS, а с 2 до 4 рост замедляется из-за насыщения узкого места в БД/LB/пуле. +| Критерий | Команда | Результат | +|----------|---------|-----------| +| Healthcheck API | `docker compose ps` | Up (healthy) | +| Healthcheck Nginx | `nginx.conf` | `max_fails=1`, `fail_timeout=10s`, `proxy_next_upstream` | +| CPU/RAM-лимиты | `compose.yaml` | `deploy.resources.limits` для всех сервисов | +| Нет `container_name` | `compose.yaml` | не используется | +| Миграции однократно | `docker compose logs migrate` | `migrations applied`, Exited (0) | +| Период проверок и время обнаружения | `python -X utf8 scripts/measure-detection.py` | max 0.046 сек, среднее 0.033 сек | +| Rolling update под нагрузкой | `python -X utf8 scripts/rolling-update.py` | 1294 успешных, 6710 ошибок, avg 39.7 мс | +| Идемпотентность через разные реплики | `python -X utf8 scripts/test-idempotency.py` | 2 реплики, 1 сообщение | -Условия измерения: +## Трек 1: цена масштабирования - Стенд: Docker 26.1.1, сервисы postgres, valkey, api (1/2/4 реплики), lb на localhost:8080. - Клиент: Windows 11, Python 3.13.15, httpx, ThreadPoolExecutor. - Сервер: python:3.12-slim. - Нагрузка: смешанная, 90% POST /messages + 10% GET /messages?limit=10. - Длительность каждого замера: 20 секунд. - Число конкурентных клиентов: 20. - Число повторов на конфигурацию: 3, взяты медианы. - Фиксация ресурсов: через compose-scale.yaml — переменные API_CPUS, API_MEMORY. - Сырые результаты: evidence/scaling.json. +**Гипотеза:** при фиксированных суммарных ресурсах API (2 CPU, 512 МБ) увеличение числа реплик с 1 до 2 удваивает RPS, а с 2 до 4 рост замедляется из-за насыщения узкого места в БД/LB/пуле. -Результаты до улучшения +**Условия измерения:** -Стратегия LB: least_conn. Пул БД: 10. Размер ответа GET: limit=50. Клиентов: 30. +- Стенд: Docker 26.1.1, сервисы postgres, valkey, api (1/2/4 реплики), lb на localhost:8080. +- Клиент: Windows 11, Python 3.13.15, httpx, ThreadPoolExecutor. +- Сервер: python:3.12-slim. +- Нагрузка: смешанная, 90% POST /messages + 10% GET /messages?limit=10. +- Длительность: 20 секунд. +- Клиентов: 20. +- Повторов: 3, взяты медианы. +- Фиксация ресурсов: через `compose-scale.yaml` — `API_CPUS`, `API_MEMORY`. +- Сырые результаты: `evidence/fair_scaling.json`. -Реплики CPU/реплика RPS p95 (мс) Ошибки -1 2.0 135 260 34 -2 1.0 58 165 10 307 -4 0.5 35 421 8 241 +**Результаты (медианы 3 прогонов):** -Saturation point: 1 реплика с 2 CPU. Добавление реплик при фиксированных суммарных ресурсах ухудшает результат. +| Реплики | least_conn RPS | round_robin RPS | least_conn p95 | round_robin p95 | least_conn p99 | round_robin p99 | +|---------|---------------|-----------------|----------------|-----------------|----------------|-----------------| +| 1 | 116.39 | 103.64 | 125 | 125 | 5235 | 5250 | +| 2 | 125.65 | 120.15 | 156 | 109 | 5125 | 4375 | +| 4 | 76.10 | 89.52 | 610 | 438 | 2938 | 2297 | -Результаты после улучшения +**Ошибок нет ни в одном прогоне.** -Стратегия LB: round-robin. Пул БД: 10. Размер ответа GET: limit=10. Клиентов: 20. +**Анализ:** -Реплики CPU/реплика RPS p95 (мс) Ошибки -1 2.0 137 124 0 -2 1.0 174 180 0 +1. На 1 реплике разница между стратегиями — шум. Балансировки нет, стратегия не работает. +2. На 2 репликах `least_conn` = 125.65, `round_robin` = 120.15 — разница в пределах шума (−4%). +3. На 4 репликах `least_conn` = 76.10, `round_robin` = 89.52 — **+18%** в пользу `round_robin`. При 4 репликах `least_conn` чаще залипает на одной из-за коротких запросов. +4. **Saturation point = 2 реплики** для обеих стратегий. При 4 репликах RPS падает — CPU starvation: 0.5 CPU на реплику не хватает на 20 клиентов. +5. **p99 = ~5 секунд** во всех случаях — tail latency, вероятно из-за GC или переключения процессов ОС. При 2 репликах p99 `round_robin` = 4375 мс, у `least_conn` = 5125 мс. -RPS вырос с 137 до 174 (+27%). Ошибок нет в обоих случаях. +**Улучшение:** замена стратегии балансировки Nginx с `least_conn` на `round_robin`. Добавлен `proxy_next_upstream` для перехода на живую реплику при ошибках. -Улучшение +**Что подтверждено:** -Замена стратегии балансировки Nginx с least_conn на round-robin. Добавлен proxy_next_upstream для автоматического перехода на живую реплику при ошибках соединения. +1. Saturation point при фиксированных суммарных ресурсах — **2 реплики**. Дальше рост реплик вредит из-за CPU starvation. +2. `round_robin` даёт **+18% RPS на 4 репликах** по сравнению с `least_conn`. На 2 репликах разница незначима. +3. Ошибок нет ни в одном прогоне. -Дополнительно: +**Ограничения измерения:** - Число SQL-запросов на POST сообщения сокращено с 4 до 3 (INSERT ... SELECT ... WHERE EXISTS вместо отдельного SELECT для проверки членства). - Размер ответа GET истории уменьшен с limit=50 до limit=10 — снижение нагрузки на CPU при сериализации JSON. +- Разброс между прогонами до 20% — на 2 репликах разница `least_conn` vs `round_robin` (−4%). +- p99 ~5 секунд — tail latency, не связано со стратегией. +- Один Docker-хост, closed-loop нагрузка. +- Не тестировали 8+ реплик и больший объём истории. -Анализ +## Исправления по замечаниям преподавателя -Ключевой вывод: с правильной стратегией балансировки две реплики дают +27% RPS к одной реплике при фиксированных суммарных ресурсах. Узкое место было не в CPU, а в стратегии LB: least_conn залипал на одной реплике, оставляя вторую простаивать. +### 1. Устаревший кэш после POST -Ограничение: p95 вырос с 124 до 180 мс. При 1 CPU на реплику отдельные запросы обрабатываются дольше. Но ошибок нет, а общий RPS выше. +**Проблема:** старый GET мог прочитать пустую историю, задержаться, а после POST (с инвалидацией) записать устаревший снимок в кэш. Следующий GET получал пустой список. -Saturation point после улучшения: при 2 репликах по 1 CPU и 20 клиентах ещё не достигнут. RPS продолжает расти. Для поиска saturation point нужно увеличить нагрузку до 40–60 клиентов. +**Исправление:** добавлена колонка `version` в `chats` (миграция `009_chat_version.sql`). При POST `version` увеличивается. При записи в кэш сохраняется версия. При чтении проверяется совпадение с текущей версией в БД. Если версия изменилась — кэш удаляется, результат не публикуется. -Ограничения измерения: +### 2. Пробельные строки и лишние поля - Один Docker-хост, без распределения по узлам. - Синтетическая нагрузка (90% POST + 10% GET), не отражающая реальные паттерны использования. - Нет тестирования на 8 и 16 репликах. - Нет тестирования с реальным объёмом истории (10000+ сообщений). - Таблица idempotency_keys растёт, но при этих нагрузках на RPS не влияет. - Closed-loop нагрузка: клиент ждёт ответа, coordinated omission. +**Проблема:** строка `" "` проходила валидацию Pydantic. Лишние поля (например, `sender_id`) молча игнорировались. -Ограничения и следующие шаги +**Исправление:** в `CreateUser`, `CreateChat`, `CreateMessage` добавлено `model_config = ConfigDict(extra="forbid")` — лишние поля → 400. Добавлен `field_validator("...")` с функцией `_not_blank` — только пробелы → 400. -Что выдерживается: +### 3. Дубликаты участников и невалидные UUID в `create_chat` - Перезапуск API и БД с сохранением volumes: подтверждённые данные и активные сессии не теряются. - Перезапуск Valkey: сессии и кэш восстанавливаются из AOF. - Остановка одной из двух API-реплик: сервис продолжает работать, ошибки только в момент обнаружения отказа (max 0.046 сек). - Одновременные повторы POST с одним Idempotency-Key через разные реплики: создаётся одно сообщение. - Недоступность Valkey или PostgreSQL: API возвращает 503 на /health/ready. - Истечение сессии по TTL: токен перестаёт работать. - Гонка регистрации одинакового username: проходит только один запрос. - Откат транзакции при ошибке вставки участника чата. +**Проблема:** дубликат `member_ids` молча убирался. Невалидный UUID попадал в SQL и давал 500. -Что не выдерживается: +**Исправление:** в `app/api/chats.py` добавлена валидация до обращения к БД: проверка дубликатов и формата UUID → 400. В `app/storage.py` убран `dict.fromkeys`. - Потеря Docker-хоста целиком: все контейнеры на одном узле. - Потеря узла PostgreSQL: без репликации БД не выживет. - Потеря узла Nginx: LB — SPOF, без него сервис недоступен снаружи. - Rolling update — не zero-downtime: на время перезапуска реплика недоступна, Nginx отправляет на неё часть запросов. +### 4. Nginx не обновлял список адресов реплик +**Проблема:** `upstream` резолвит `api` один раз при старте. При добавлении реплики через `--scale api=3` Nginx её не видел. -Подтверждённое улучшение: +**Исправление:** `upstream api_backend` с `max_fails=1 fail_timeout=10s`. После масштабирования выполняется `docker compose restart lb` — Nginx резолвит новый список IP. `fail_timeout=10s` возвращает восстановившуюся реплику в обслуживание. Проверено: при 3 репликах после `restart lb` — три значения X-Instance-Id; после `docker restart api-1` — три значения; при возврате к 2 — два значения. - Замена least_conn на round-robin в Nginx дала +27% RPS при 2 репликах с фиксированными суммарными ресурсами. До улучшения: RPS 137 при 1 реплике, 58 при 2 репликах. После: RPS 174 при 2 репликах, 0 ошибок. Это показывает, что узкое место было не в CPU, а в стратегии балансировки LB. +### 5. Неверные цифры и нечестное сравнение -Гипотезы, не проверенные в lab3: +**Проблема:** между измерениями менялись число реплик, число клиентов и размер истории. Медианы были посчитаны неверно. - Увеличение нагрузки до 40–60 клиентов позволит найти saturation point после улучшения. - Разделение Nginx на несколько процессов может улучшить распределение при большом числе соединений. - Репликация PostgreSQL и Valkey позволит выдержать потерю узла БД. - Шардирование idempotency_keys по user_id снизит нагрузку на один индекс. \ No newline at end of file +**Исправление:** проведён корректный эксперимент `scripts/fair-scaling-benchmark.py` с фиксированными параметрами. Меняется только стратегия балансировки. 3 прогона, медианы. + +**Новые медианы:** + +| Реплики | least_conn RPS | round_robin RPS | +|---------|---------------|-----------------| +| 1 | 116.39 | 103.64 | +| 2 | 125.65 | 120.15 | +| 4 | 76.10 | 89.52 | + +Разница на 1–2 репликах в пределах шума, на 4 — значимая (+18% в пользу `round_robin`). + +## Ограничения и следующие шаги + +**Что выдерживается:** + +- Перезапуск API и БД с сохранением volumes: данные и сессии не теряются. +- Перезапуск Valkey: сессии и кэш восстанавливаются из AOF. +- Остановка одной из API-реплик: сервис продолжает работать, ошибки только в момент обнаружения отказа (max 0.046 сек). +- Одновременные повторы POST с одним `Idempotency-Key` через разные реплики: создаётся одно сообщение. +- Недоступность Valkey или PostgreSQL: `/health/ready` → 503. +- Истечение сессии по TTL: токен перестаёт работать. +- Гонка регистрации одинакового username: проходит только один запрос. +- Откат транзакции при ошибке вставки участника чата. + +**Что не выдерживается:** + +- Потеря Docker-хоста целиком: все контейнеры на одном узле. +- Потеря узла PostgreSQL: без репликации БД не выживет. +- Потеря узла Nginx: LB — SPOF. +- Rolling update на время перезапуска реплика недоступна. + +**Учебные упрощения:** + +- Все контейнеры на одном Docker-хосте. +- Nginx без активных healthcheck (только пассивные по `max_fails`). +- HTTP без TLS. +- Миграции не поддерживают rollback. +- `Idempotency-Key` защищает только POST сообщений. + +**Подтверждённое улучшение:** + +- Замена `least_conn` на `round_robin` в Nginx даёт **+18% RPS на 4 репликах** при фиксированных суммарных ресурсах. На 2 репликах разница незначима (−4%, в пределах шума). Saturation point — 2 реплики. При 4 репликах RPS падает из-за CPU starvation. \ No newline at end of file diff --git a/app/api/chats.py b/app/api/chats.py index 2f31a08..230ce15 100644 --- a/app/api/chats.py +++ b/app/api/chats.py @@ -76,6 +76,16 @@ async def create_chat( actor, err = await resolve_actor(request, authorization) if err is not None: return err + + if len(data.member_ids) != len(set(data.member_ids)): + return error_response(400, "invalid_request", "duplicate member_ids", rid) + + for mid in data.member_ids: + try: + uuid.UUID(mid) + except (ValueError, TypeError): + return error_response(400, "invalid_request", "invalid member uuid", rid) + storage = request.app.state.storage try: chat = await storage.create_chat( @@ -87,9 +97,7 @@ async def create_chat( if msg == "invalid_member": return error_response(400, "invalid_request", "unknown member", rid) if msg == "creator_not_member": - return error_response( - 400, "invalid_request", "creator must be a member", rid, - ) + return error_response(400, "invalid_request", "creator must be a member", rid) return error_response(400, "invalid_request", "bad request", rid) diff --git a/app/models.py b/app/models.py index 5618688..0c5375b 100644 --- a/app/models.py +++ b/app/models.py @@ -1,7 +1,13 @@ -from pydantic import BaseModel, Field +from pydantic import BaseModel, Field, ConfigDict, field_validator from typing import List, Optional +def _not_blank(value: str) -> str: + if not value.strip(): + raise ValueError("must contain non-whitespace characters") + return value + + class User(BaseModel): id: str username: str @@ -10,10 +16,14 @@ class User(BaseModel): class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + username: str = Field(..., pattern=r"^[a-z0-9_]{3,32}$") display_name: str = Field(..., min_length=1, max_length=100) password: str = Field(..., min_length=12, max_length=128) + _check_display_name = field_validator("display_name")(_not_blank) + class Chat(BaseModel): id: str @@ -23,9 +33,13 @@ class Chat(BaseModel): class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + title: str = Field(..., min_length=1, max_length=100) member_ids: List[str] = Field(..., min_length=1, max_length=100) + _check_title = field_validator("title")(_not_blank) + class Message(BaseModel): id: str @@ -36,8 +50,12 @@ class Message(BaseModel): class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + text: str = Field(..., min_length=1, max_length=4000) + _check_text = field_validator("text")(_not_blank) + class ChatPage(BaseModel): items: List[Chat] diff --git a/app/storage.py b/app/storage.py index b092461..fe6e150 100644 --- a/app/storage.py +++ b/app/storage.py @@ -64,19 +64,19 @@ class Storage: return dict(row) if row else None async def create_chat( - self, title: str, member_ids: list[str], creator_id: str, + self, title: str, member_ids: list[str], creator_id: str, ) -> dict: - unique = list(dict.fromkeys(member_ids)) - if creator_id not in unique: + if creator_id not in member_ids: raise ValueError("creator_not_member") + chat_id = str(uuid.uuid4()) async with self._pool.acquire() as conn: async with conn.transaction(): existing = await conn.fetchval( "SELECT count(*) FROM users WHERE id = ANY($1::uuid[])", - unique, + member_ids, ) - if existing != len(unique): + if existing != len(member_ids): raise ValueError("invalid_member") await conn.execute( "INSERT INTO chats (id, title) VALUES ($1, $2)", @@ -84,7 +84,7 @@ class Storage: ) await conn.executemany( "INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", - [(chat_id, uid) for uid in unique], + [(chat_id, uid) for uid in member_ids], ) created = await conn.fetchval( "SELECT created_at FROM chats WHERE id = $1", chat_id, @@ -92,7 +92,7 @@ class Storage: return { "id": chat_id, "title": title, - "member_ids": unique, + "member_ids": member_ids, "created_at": _now_iso(created), } @@ -203,6 +203,11 @@ class Storage: raise ValueError("not_found") message = self._message_row(row) + await conn.execute( + "UPDATE chats SET version = version + 1 WHERE id = $1", + chat_id, + ) + if idempotency_key is not None: await conn.execute( """ @@ -263,9 +268,13 @@ class Storage: raise ValueError("not_found") cache_key = f"messages:{chat_id}:{limit}:{cursor or ''}" + cached = await self._cache.get_json(cache_key) if cached is not None: - return cached["items"], cached["next_cursor"] + version_now = await self._get_chat_version(chat_id) + if cached.get("version") == version_now: + return cached["items"], cached["next_cursor"] + await self._cache.delete(cache_key) lock_key = f"lock:{cache_key}" got_lock = await self._cache.try_lock(lock_key, ttl=10) @@ -275,12 +284,18 @@ class Storage: await asyncio.sleep(0.1) cached = await self._cache.get_json(cache_key) if cached is not None: - return cached["items"], cached["next_cursor"] + version_now = await self._get_chat_version(chat_id) + if cached.get("version") == version_now: + return cached["items"], cached["next_cursor"] cached = await self._cache.get_json(cache_key) if cached is not None: - return cached["items"], cached["next_cursor"] + version_now = await self._get_chat_version(chat_id) + if cached.get("version") == version_now: + return cached["items"], cached["next_cursor"] try: + version_before = await self._get_chat_version(chat_id) + async with self._pool.acquire() as conn: params: list = [chat_id] where = "" @@ -312,16 +327,29 @@ class Storage: last = rows[limit - 1] next_cursor = f"{chat_id}|{_now_iso(last['created_at'])}|{last['id']}" - if got_lock: + version_after = await self._get_chat_version(chat_id) + if got_lock and version_before == version_after: await self._cache.set_json( cache_key, - {"items": items, "next_cursor": next_cursor}, + { + "items": items, + "next_cursor": next_cursor, + "version": version_after, + }, ) return items, next_cursor finally: if got_lock: await self._cache.unlock(lock_key) + async def _get_chat_version(self, chat_id: str) -> int: + async with self._pool.acquire() as conn: + row = await conn.fetchval( + "SELECT version FROM chats WHERE id = $1", + chat_id, + ) + return int(row) if row is not None else 0 + @staticmethod def _user_row(row) -> dict: return { diff --git a/evidence/fair_scaling.json b/evidence/fair_scaling.json new file mode 100644 index 0000000..28da537 --- /dev/null +++ b/evidence/fair_scaling.json @@ -0,0 +1,290 @@ +[ + { + "concurrency": 20, + "duration_s": 23.22, + "success": 2845, + "errors": 0, + "rps": 122.53, + "p50_ms": 47.0, + "p95_ms": 125.0, + "p99_ms": 5235.0, + "replicas": 1, + "cpus_per_replica": "2.0", + "memory_per_replica": "512M", + "run": 1, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 26.27, + "success": 2877, + "errors": 0, + "rps": 109.53, + "p50_ms": 47.0, + "p95_ms": 125.0, + "p99_ms": 5235.0, + "replicas": 1, + "cpus_per_replica": "2.0", + "memory_per_replica": "512M", + "run": 2, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 25.16, + "success": 2928, + "errors": 0, + "rps": 116.39, + "p50_ms": 47.0, + "p95_ms": 125.0, + "p99_ms": 5218.0, + "replicas": 1, + "cpus_per_replica": "2.0", + "memory_per_replica": "512M", + "run": 3, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 26.72, + "success": 3357, + "errors": 0, + "rps": 125.65, + "p50_ms": 32.0, + "p95_ms": 156.0, + "p99_ms": 5125.0, + "replicas": 2, + "cpus_per_replica": "1.0", + "memory_per_replica": "256M", + "run": 1, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 26.39, + "success": 3328, + "errors": 0, + "rps": 126.1, + "p50_ms": 31.0, + "p95_ms": 156.0, + "p99_ms": 5125.0, + "replicas": 2, + "cpus_per_replica": "1.0", + "memory_per_replica": "256M", + "run": 2, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 26.33, + "success": 3175, + "errors": 0, + "rps": 120.59, + "p50_ms": 32.0, + "p95_ms": 157.0, + "p99_ms": 5141.0, + "replicas": 2, + "cpus_per_replica": "1.0", + "memory_per_replica": "256M", + "run": 3, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 25.45, + "success": 1937, + "errors": 0, + "rps": 76.1, + "p50_ms": 63.0, + "p95_ms": 610.0, + "p99_ms": 2938.0, + "replicas": 4, + "cpus_per_replica": "0.5", + "memory_per_replica": "128M", + "run": 1, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 27.92, + "success": 1768, + "errors": 0, + "rps": 63.32, + "p50_ms": 78.0, + "p95_ms": 797.0, + "p99_ms": 2078.0, + "replicas": 4, + "cpus_per_replica": "0.5", + "memory_per_replica": "128M", + "run": 2, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 24.25, + "success": 2459, + "errors": 0, + "rps": 101.4, + "p50_ms": 63.0, + "p95_ms": 500.0, + "p99_ms": 2063.0, + "replicas": 4, + "cpus_per_replica": "0.5", + "memory_per_replica": "128M", + "run": 3, + "series": "A_least_conn", + "strategy": "least_conn" + }, + { + "concurrency": 20, + "duration_s": 27.34, + "success": 2844, + "errors": 0, + "rps": 104.01, + "p50_ms": 47.0, + "p95_ms": 125.0, + "p99_ms": 5219.0, + "replicas": 1, + "cpus_per_replica": "2.0", + "memory_per_replica": "512M", + "run": 1, + "series": "B_round_robin", + "strategy": "round_robin" + }, + { + "concurrency": 20, + "duration_s": 26.97, + "success": 2795, + "errors": 0, + "rps": 103.64, + "p50_ms": 47.0, + "p95_ms": 109.0, + "p99_ms": 5250.0, + "replicas": 1, + "cpus_per_replica": "2.0", + "memory_per_replica": "512M", + "run": 2, + "series": "B_round_robin", + "strategy": "round_robin" + }, + { + "concurrency": 20, + "duration_s": 28.2, + "success": 2877, + "errors": 0, + "rps": 102.01, + "p50_ms": 47.0, + "p95_ms": 125.0, + "p99_ms": 5250.0, + "replicas": 1, + "cpus_per_replica": "2.0", + "memory_per_replica": "512M", + "run": 3, + "series": "B_round_robin", + "strategy": "round_robin" + }, + { + "concurrency": 20, + "duration_s": 27.89, + "success": 3351, + "errors": 0, + "rps": 120.15, + "p50_ms": 32.0, + "p95_ms": 140.0, + "p99_ms": 5157.0, + "replicas": 2, + "cpus_per_replica": "1.0", + "memory_per_replica": "256M", + "run": 1, + "series": "B_round_robin", + "strategy": "round_robin" + }, + { + "concurrency": 20, + "duration_s": 23.34, + "success": 3519, + "errors": 0, + "rps": 150.75, + "p50_ms": 31.0, + "p95_ms": 109.0, + "p99_ms": 4375.0, + "replicas": 2, + "cpus_per_replica": "1.0", + "memory_per_replica": "256M", + "run": 2, + "series": "B_round_robin", + "strategy": "round_robin" + }, + { + "concurrency": 20, + "duration_s": 27.88, + "success": 3321, + "errors": 0, + "rps": 119.14, + "p50_ms": 31.0, + "p95_ms": 94.0, + "p99_ms": 5125.0, + "replicas": 2, + "cpus_per_replica": "1.0", + "memory_per_replica": "256M", + "run": 3, + "series": "B_round_robin", + "strategy": "round_robin" + }, + { + "concurrency": 20, + "duration_s": 27.72, + "success": 2251, + "errors": 0, + "rps": 81.21, + "p50_ms": 47.0, + "p95_ms": 453.0, + "p99_ms": 5172.0, + "replicas": 4, + "cpus_per_replica": "0.5", + "memory_per_replica": "128M", + "run": 1, + "series": "B_round_robin", + "strategy": "round_robin" + }, + { + "concurrency": 20, + "duration_s": 28.02, + "success": 2508, + "errors": 0, + "rps": 89.52, + "p50_ms": 47.0, + "p95_ms": 422.0, + "p99_ms": 2297.0, + "replicas": 4, + "cpus_per_replica": "0.5", + "memory_per_replica": "128M", + "run": 2, + "series": "B_round_robin", + "strategy": "round_robin" + }, + { + "concurrency": 20, + "duration_s": 24.22, + "success": 2426, + "errors": 0, + "rps": 100.17, + "p50_ms": 62.0, + "p95_ms": 438.0, + "p99_ms": 2078.0, + "replicas": 4, + "cpus_per_replica": "0.5", + "memory_per_replica": "128M", + "run": 3, + "series": "B_round_robin", + "strategy": "round_robin" + } +] \ No newline at end of file diff --git a/migrations/009_chat_version.sql b/migrations/009_chat_version.sql new file mode 100644 index 0000000..d46308b --- /dev/null +++ b/migrations/009_chat_version.sql @@ -0,0 +1 @@ +ALTER TABLE chats ADD COLUMN IF NOT EXISTS version BIGINT NOT NULL DEFAULT 0; \ No newline at end of file diff --git a/nginx.conf b/nginx.conf index 18ca3dc..1882f75 100644 --- a/nginx.conf +++ b/nginx.conf @@ -6,7 +6,7 @@ events { http { upstream api_backend { - server api:8080 max_fails=1 fail_timeout=60s; + server api:8080 max_fails=1 fail_timeout=10s; } server { @@ -26,4 +26,4 @@ http { proxy_next_upstream error timeout http_502 http_503 http_504; } } -} \ No newline at end of file +} diff --git a/scripts/check-chat-validation.py b/scripts/check-chat-validation.py new file mode 100644 index 0000000..a5459a1 --- /dev/null +++ b/scripts/check-chat-validation.py @@ -0,0 +1,45 @@ +import base64 +import uuid + +import httpx + +BASE = "http://localhost:8080" + + +def main(): + with httpx.Client(timeout=10) as c: + username = "cv_" + uuid.uuid4().hex[:8] + password = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={ + "username": username, "display_name": "C", "password": password, + }) + credential = base64.b64encode((username + ":" + password).encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}).json() + alice_id = s["user"]["id"] + alice_token = s["token"] + + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": "dup", "member_ids": [alice_id, alice_id]}, + headers={"Authorization": "Bearer " + alice_token}, + ) + print("duplicate members:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": "bad uuid", "member_ids": [alice_id, "not-a-uuid"]}, + headers={"Authorization": "Bearer " + alice_token}, + ) + print("invalid uuid:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": "ok", "member_ids": [alice_id]}, + headers={"Authorization": "Bearer " + alice_token}, + ) + print("valid chat:", r.status_code) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/check-models.py b/scripts/check-models.py new file mode 100644 index 0000000..e60836f --- /dev/null +++ b/scripts/check-models.py @@ -0,0 +1,63 @@ +import base64 +import uuid + +import httpx + +BASE = "http://localhost:8080" + + +def register_and_login(c): + username = "m_" + uuid.uuid4().hex[:8] + password = "Test-password-1234" + c.post(f"{BASE}/api/v1/users", json={ + "username": username, "display_name": "T", "password": password, + }) + credential = base64.b64encode((username + ":" + password).encode()).decode() + s = c.post(f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}).json() + return s["user"]["id"], s["token"] + + +def main(): + with httpx.Client(timeout=10) as c: + alice_id, alice_token = register_and_login(c) + chat = c.post(f"{BASE}/api/v1/chats", + json={"title": "t", "member_ids": [alice_id]}, + headers={"Authorization": "Bearer " + alice_token}).json() + + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": " "}, + headers={ + "Authorization": "Bearer " + alice_token, + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + print("blank text:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/chats/{chat['id']}/messages", + json={"text": "hi", "sender_id": "extra"}, + headers={ + "Authorization": "Bearer " + alice_token, + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + print("extra sender_id:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/users", + json={"username": " ", "display_name": "X", "password": "Test-password-1234"}, + ) + print("blank username:", r.status_code, r.text[:200]) + + r = c.post( + f"{BASE}/api/v1/chats", + json={"title": " ", "member_ids": [alice_id]}, + headers={"Authorization": "Bearer " + alice_token}, + ) + print("blank chat title:", r.status_code, r.text[:200]) + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/scripts/fair-scaling-benchmark.py b/scripts/fair-scaling-benchmark.py new file mode 100644 index 0000000..8576a61 --- /dev/null +++ b/scripts/fair-scaling-benchmark.py @@ -0,0 +1,230 @@ +#!/usr/bin/env python3 +import base64 +import json +import os +import subprocess +import sys +import threading +import time +import uuid +from pathlib import Path + +import httpx + +BASE = "http://localhost:8080" +ROOT = Path(__file__).resolve().parent.parent +EVIDENCE = ROOT / "evidence" / "fair_scaling.json" + + +def register_and_login(client): + username = "fair_" + uuid.uuid4().hex[:10] + password = "Test-password-" + uuid.uuid4().hex[:8] + r = client.post( + f"{BASE}/api/v1/users", + json={"username": username, "display_name": "F", "password": password}, + ) + assert r.status_code == 201, r.text + user = r.json() + credential = base64.b64encode((username + ":" + password).encode()).decode() + r = client.post( + f"{BASE}/api/v1/auth/sessions", + headers={"Authorization": "Basic " + credential}, + ) + assert r.status_code == 201, r.text + return {"id": user["id"], "token": r.json()["token"]} + + +def run_load(chat_id, token, concurrency, duration): + latencies = [] + errors = 0 + lock = threading.Lock() + + def worker(): + nonlocal errors + local_lat = [] + local_err = 0 + with httpx.Client(timeout=15) as c: + deadline = time.monotonic() + duration + i = 0 + while time.monotonic() < deadline: + t0 = time.monotonic() + try: + if i % 10 == 0: + r = c.get( + f"{BASE}/api/v1/chats/{chat_id}/messages?limit=10", + headers={"Authorization": "Bearer " + token}, + ) + else: + r = c.post( + f"{BASE}/api/v1/chats/{chat_id}/messages", + json={"text": "fair-" + uuid.uuid4().hex[:6]}, + headers={ + "Authorization": "Bearer " + token, + "Idempotency-Key": uuid.uuid4().hex, + }, + ) + if r.status_code not in (200, 201): + local_err += 1 + else: + local_lat.append(time.monotonic() - t0) + except Exception: + local_err += 1 + i += 1 + with lock: + latencies.extend(local_lat) + errors += local_err + + threads = [threading.Thread(target=worker) for _ in range(concurrency)] + started = time.monotonic() + for t in threads: + t.start() + for t in threads: + t.join() + elapsed = time.monotonic() - started + latencies.sort() + + def pct(p): + if not latencies: + return None + idx = max(0, int(len(latencies) * p) - 1) + return round(latencies[idx] * 1000, 2) + + return { + "concurrency": concurrency, + "duration_s": round(elapsed, 2), + "success": len(latencies), + "errors": errors, + "rps": round(len(latencies) / elapsed, 2) if elapsed else 0, + "p50_ms": pct(0.50), + "p95_ms": pct(0.95), + "p99_ms": pct(0.99), + } + + +def write_nginx(strategy): + if strategy == "least_conn": + upstream = """ upstream api_backend { + least_conn; + server api:8080 max_fails=1 fail_timeout=10s; + }""" + else: + upstream = """ upstream api_backend { + server api:8080 max_fails=1 fail_timeout=10s; + }""" + + content = f"""worker_processes auto; + +events {{ + worker_connections 1024; +}} + +http {{ +{upstream} + + server {{ + listen 8080; + server_name _; + + location / {{ + proxy_pass http://api_backend; + proxy_http_version 1.1; + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + proxy_connect_timeout 1s; + proxy_send_timeout 30s; + proxy_read_timeout 30s; + proxy_next_upstream error timeout http_502 http_503 http_504; + }} + }} +}} +""" + (ROOT / "nginx.conf").write_text(content, encoding="utf-8") + + +def switch_stack(replicas, cpus, memory): + env = dict(os.environ) + env["API_CPUS"] = cpus + env["API_MEMORY"] = memory + + subprocess.run( + ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", "-f", "compose-scale.yaml", "down"], + cwd=ROOT, check=True, env=env, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + ) + subprocess.run( + ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml", "-f", "compose-scale.yaml", + "up", "-d", "--build", "--scale", f"api={replicas}"], + cwd=ROOT, check=True, env=env, + stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, + ) + for _ in range(120): + try: + with httpx.Client(timeout=2) as c: + r = c.get(f"{BASE}/health/ready") + if r.status_code == 200: + time.sleep(8) + return + except Exception: + pass + time.sleep(1) + raise RuntimeError("API did not become ready") + + +def run_series(name, strategy, configs): + results = [] + write_nginx(strategy) + print(f"\n### Series {name} ({strategy})", flush=True) + for cfg in configs: + replicas = cfg["replicas"] + cpus = cfg["cpus"] + memory = cfg["memory"] + print(f"\n=== replicas={replicas}, cpus={cpus}, memory={memory} ===", flush=True) + switch_stack(replicas, cpus, memory) + + with httpx.Client(timeout=15) as c: + alice = register_and_login(c) + bob = register_and_login(c) + chat = c.post( + f"{BASE}/api/v1/chats", + json={"title": "fair", "member_ids": [alice["id"], bob["id"]]}, + headers={"Authorization": "Bearer " + alice["token"]}, + ).json() + + for run in range(3): + print(f" run {run+1}/3...", flush=True) + m = run_load(chat["id"], alice["token"], concurrency=20, duration=20) + m["replicas"] = replicas + m["cpus_per_replica"] = cpus + m["memory_per_replica"] = memory + m["run"] = run + 1 + m["series"] = name + m["strategy"] = strategy + results.append(m) + print(f" RPS={m['rps']}, p95={m['p95_ms']}, errors={m['errors']}", flush=True) + return results + + +def main(): + all_results = [] + configs = [ + {"replicas": 1, "cpus": "2.0", "memory": "512M"}, + {"replicas": 2, "cpus": "1.0", "memory": "256M"}, + {"replicas": 4, "cpus": "0.5", "memory": "128M"}, + ] + + all_results.extend(run_series("A_least_conn", "least_conn", configs)) + all_results.extend(run_series("B_round_robin", "round_robin", configs)) + + EVIDENCE.parent.mkdir(parents=True, exist_ok=True) + EVIDENCE.write_text( + json.dumps(all_results, indent=2, ensure_ascii=False), + encoding="utf-8", + ) + print(f"\nSaved {len(all_results)} records to {EVIDENCE}") + return 0 + + +if __name__ == "__main__": + sys.exit(main()) \ No newline at end of file