Исправление ошибок ЛР3

This commit is contained in:
Queenfish
2026-10-22 21:45:15 +03:00
parent 1ef3adfe3f
commit c69e3a368d
10 changed files with 875 additions and 173 deletions
+174 -155
View File
@@ -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:<chat_id>:<limit>:<cursor>, TTL 30 секунд. При вставке нового сообщения add_message инвалидирует все ключи messages:<chat_id>:*. Защита от 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 привязан к чату: `<chat_id>|<created_at>|<id>`, при несовпадении — 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:<chat_id>:<limit>:<cursor>`, TTL 30 секунд. При вставке `add_message` инвалидирует все ключи `messages:<chat_id>:*`. Защита от 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 снизит нагрузку на один индекс.
**Исправление:** проведён корректный эксперимент `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.
+11 -3
View File
@@ -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)
+19 -1
View File
@@ -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]
+40 -12
View File
@@ -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 {
+290
View File
@@ -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"
}
]
+1
View File
@@ -0,0 +1 @@
ALTER TABLE chats ADD COLUMN IF NOT EXISTS version BIGINT NOT NULL DEFAULT 0;
+2 -2
View File
@@ -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;
}
}
}
}
+45
View File
@@ -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()
+63
View File
@@ -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()
+230
View File
@@ -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())