From 4696f89de21aff0394cfa0dc505140cb83418a3a Mon Sep 17 00:00:00 2001 From: ViktoriyaKa Date: Fri, 30 Oct 2026 11:01:02 +0300 Subject: [PATCH] =?UTF-8?q?=D0=9F=D1=80=D0=BE=D0=B2=D0=B5=D1=80=D1=8F?= =?UTF-8?q?=D1=82=D1=8C=20=D1=87=D0=BB=D0=B5=D0=BD=D1=81=D1=82=D0=B2=D0=BE?= =?UTF-8?q?=20=D0=B2=20=D1=87=D0=B0=D1=82=D0=B5=20=D1=80=D0=B0=D0=BD=D1=8C?= =?UTF-8?q?=D1=88=D0=B5=20=D1=82=D0=B5=D0=BB=D0=B0=20=D0=BF=D0=BE=D0=B2?= =?UTF-8?q?=D1=82=D0=BE=D1=80=D0=BD=D0=BE=D0=B3=D0=BE=20=D0=BA=D0=BB=D1=8E?= =?UTF-8?q?=D1=87=D0=B0.?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Исключённый участник получает 404 и на другой текст. Отдельная серия показывает, что при потолке CPU Postgres лишние реплики перестают поднимать RPS. --- .env.example | 2 + .github/pull_request_template.md | 2 +- REPORT.md | 24 +++- compose.yaml | 4 +- evidence/load-sat-pg020-r1.json | 17 +++ evidence/load-sat-pg020-r2.json | 17 +++ evidence/load-sat-pg020-r4.json | 17 +++ evidence/load-sat-pg100-r4.json | 17 +++ evidence/saturation.json | 101 ++++++++++++++++ src/db.py | 10 +- student-tests/check_idem_access.py | 76 ++++++++++++ student-tests/experiment_saturation.py | 160 +++++++++++++++++++++++++ 12 files changed, 436 insertions(+), 11 deletions(-) create mode 100644 evidence/load-sat-pg020-r1.json create mode 100644 evidence/load-sat-pg020-r2.json create mode 100644 evidence/load-sat-pg020-r4.json create mode 100644 evidence/load-sat-pg100-r4.json create mode 100644 evidence/saturation.json create mode 100644 student-tests/check_idem_access.py create mode 100644 student-tests/experiment_saturation.py diff --git a/.env.example b/.env.example index 71ef50b3..14c2a39c 100644 --- a/.env.example +++ b/.env.example @@ -11,6 +11,8 @@ REDIS_PASSWORD=replace-with-a-local-password API_REPLICAS=2 API_CPUS=0.50 API_MEMORY=512M +POSTGRES_CPUS=1.0 +LB_CPUS=0.50 POOL_MAX=4 CAP_MODE=off DRAIN_SECONDS=2 diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index a6b6f5e6..11e77672 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -7,7 +7,7 @@ Что реализовано и что перенесено: API лабораторной 2 за HAProxy, две и больше реплик без локальных сессий, общий Postgres и Redis, одноразовая миграция, общий Idempotency-Key, X-Instance-Id, graceful shutdown. Контракт и публичные тесты не менялись. Команды запуска из чистого clone: см. REPORT.md. Кратко: скопировать `.env.example` в `.env`, задать локальные пароли, `docker compose --env-file .env up -d --build --scale api=2`, дождаться `/health/ready`. Результаты проверок и ссылка на REPORT.md: smoke, persistence и failover прошли; grade 4 и трек 1 лежат в `evidence/`. Подробности и числа — в REPORT.md. -Ограничения / известные ошибки: LB, Postgres и Redis не продублированы. На фиксированном CPU четыре реплики медленнее одной. Короткие ошибки при SIGTERM измеряются и допустимы. На Windows hook для публичного теста — `scripts/*.cmd`, на Linux — `scripts/*.sh`. +Ограничения / известные ошибки: LB, Postgres и Redis не продублированы. На фиксированном CPU четыре реплики медленнее одной. При потолке Postgres 0.20 CPU лишние реплики RPS не поднимают; снятие потолка на тех же четырёх репликах поднимает RPS примерно в 3.3 раза. Короткие ошибки при SIGTERM измеряются и допустимы. На Windows hook для публичного теста — `scripts/*.cmd`, на Linux — `scripts/*.sh`. Источники: контракт skeleton, код лабораторной 2, документация HAProxy и Compose. Числа сняты локально. - [x] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. diff --git a/REPORT.md b/REPORT.md index 26208c02..45d218f1 100644 --- a/REPORT.md +++ b/REPORT.md @@ -35,6 +35,8 @@ python tests/resilience.py --mode failover --action-script scripts/stop-one.cmd python tests/load.py --base-url http://127.0.0.1:8080 --duration 20 --concurrency 4 --output evidence/load.json python student-tests/experiment_grade4.py python student-tests/experiment_track1.py +python student-tests/experiment_saturation.py +python student-tests/check_idem_access.py ``` На Linux то же самое через `make test`, `make test-persistence ACTION_SCRIPT=scripts/restart.sh` и `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`. @@ -47,13 +49,13 @@ python student-tests/experiment_track1.py `X-Instance-Id` — hostname контейнера, первые 12 символов его id. Он не меняется, пока живёт этот контейнер, и это не cookie клиента. Балансировка `roundrobin`, sticky session нет. -Отправка сообщения требует `Idempotency-Key` (`[A-Za-z0-9._:-]{1,128}`). Область ключа: пользователь, метод POST, путь `/api/v1/chats/{id}/messages`, сам ключ. Отпечаток тела — SHA-256 канонического JSON. Пустой список вложений и отсутствующее поле для этого отпечатка совпадают. Успешная вставка сообщения и строка ключа коммитятся одной транзакцией. На время транзакции берётся advisory lock именно этой области, поэтому два параллельных повтора через разные реплики не создают два сообщения. Повтор того же тела возвращает тот же 201 и то же сообщение. Другое тело — 409. Ошибка 5xx транзакцию откатывает, ключ не занимается, клиент может повторить тот же ключ. Перед повтором снова проверяются сессия и членство в чате. Срок хранения ключа — `IDEMPOTENCY_TTL_SECONDS`, по умолчанию 86400. +Отправка сообщения требует `Idempotency-Key` (`[A-Za-z0-9._:-]{1,128}`). Область ключа: пользователь, метод POST, путь `/api/v1/chats/{id}/messages`, сам ключ. Отпечаток тела — SHA-256 канонического JSON. Пустой список вложений и отсутствующее поле для этого отпечатка совпадают. Успешная вставка сообщения и строка ключа коммитятся одной транзакцией. На время транзакции берётся advisory lock именно этой области, поэтому два параллельных повтора через разные реплики не создают два сообщения. Повтор того же тела возвращает тот же 201 и то же сообщение. Другое тело — 409. Ошибка 5xx транзакцию откатывает, ключ не занимается, клиент может повторить тот же ключ. Перед повтором снова проверяются сессия и членство в чате. Членство проверяется раньше сравнения отпечатка тела: если участника уже исключили, повтор с тем же ключом и другим текстом даёт 404, а не 409. Проверка: сообщение создано, тот же ключ с другим текстом дал 409, затем строка участника удалена прямо в Postgres, и оба повтора (старый и новый текст) дали 404. История этого чата для него тоже 404. Срок хранения ключа — `IDEMPOTENCY_TTL_SECONDS`, по умолчанию 86400. `GET /health/live` отвечает 200, пока процесс жив, в том числе после SIGTERM. `GET /health/ready` отвечает 200 только если процесс принимает запросы, схема уже накатана, Postgres и Redis отвечают. На SIGTERM процесс сразу перестаёт принимать работу, ready становится 503, ждёт `DRAIN_SECONDS` (2) и только потом закрывает сокет. `stop_grace_period` у API — 8 с, `docker stop -t 6` укладывается в лимит hook 10 с. HAProxy сам обновляет адреса через DNS Docker `127.0.0.11`. `hold valid 1s`. Проверка backend: `GET /health/ready` каждые 1 с, `fall 2`, `rise 1`. Недоступный backend выводится примерно за 2 с по health-check и не позже чем за 1 с по DNS, когда контейнер уже исчез из DNS. Верхняя оценка обнаружения отказа — 3 с. Таймауты: connect 500 мс, server 10 с, client 15 с, check 1 с, queue 1 с. Для обычных запросов повтор на другой backend есть только при обрыве соединения до отправки и при 503, который API отдаёт до commit. Потерянный ответ 201 у создания чата балансировщик не повторяет. Повтор пустого ответа, 502 и 503 включён только у `POST /chats/{id}/messages`: там общий ключ идемпотентности. `depends_on` только упорядочивает первый старт и балансировщиком не является. -Соответствие `.env.example` и стенда: `APP_PORT` публикует только `lb`. `SESSION_TTL_SECONDS` и `IDEMPOTENCY_TTL_SECONDS` читает API. `DATABASE_URL` и `REDIS_URL` собирает Compose из паролей `.env`; файлы `DATABASE_URL_FILE` и `CACHE_URL_FILE` код умеет читать, но этот стенд их не монтирует. `API_REPLICAS`, `API_CPUS`, `API_MEMORY`, `POOL_MAX`, `CAP_MODE`, `DRAIN_SECONDS` задают число реплик, лимиты, пул и режим предела сообщений. +Соответствие `.env.example` и стенда: `APP_PORT` публикует только `lb`. `SESSION_TTL_SECONDS` и `IDEMPOTENCY_TTL_SECONDS` читает API. `DATABASE_URL` и `REDIS_URL` собирает Compose из паролей `.env`; файлы `DATABASE_URL_FILE` и `CACHE_URL_FILE` код умеет читать, но этот стенд их не монтирует. `API_REPLICAS`, `API_CPUS`, `API_MEMORY`, `POOL_MAX`, `CAP_MODE`, `DRAIN_SECONDS` задают число реплик, лимиты API, пул и режим предела сообщений. `POSTGRES_CPUS` и `LB_CPUS` задают потолок CPU базы и балансировщика. В обычном стенде это 1.0 и 0.50. В серии насыщения Postgres временно ставился на 0.20, затем возвращался на 1.0. Лимиты по умолчанию: API 2 × 0.50 CPU и 512 МиБ, Postgres 1.0 CPU и 512 МиБ, Redis 0.25 CPU и 128 МиБ, HAProxy 0.50 CPU и 128 МиБ. `max_connections` Postgres — 100, `shared_buffers` — 128 МиБ, `fsync` и `synchronous_commit` включены. Пул API по умолчанию 4 соединения на процесс. @@ -77,6 +79,7 @@ HAProxy сам обновляет адреса через DNS Docker `127.0.0.11 | Поочерёдная замена под нагрузкой | `scripts/rolling-replace.ps1` из grade4-скрипта | 7.219 с, 1341 успешное чтение, 401 ошибка на закрываемых сокетах, после замены два новых id | `evidence/grade4.json` | | Миграция один раз | `psql` по `schema_migrations` | одна строка `001_init.sql` | команда в этом разделе | | Трек 1 | `student-tests/experiment_track1.py` | см. таблицу ниже. Все 10 прогонов: 0 ошибок клиента, видно ровно заявленное число реплик | `evidence/track1.json`, `evidence/track1.svg` | +| Насыщение Postgres | `student-tests/experiment_saturation.py` | при потолке Postgres 0.20 CPU ряд 1/2/4 реплики по 1.0 CPU даёт 135.440 / 141.407 / 107.017 RPS. Те же 4 реплики со снятым потолком (1.0 CPU у Postgres) дают 352.885 RPS. Ошибок 0 | `evidence/saturation.json`, `evidence/load-sat-*.json` | | Нагрузка рабочего стенда | `tests/load.py --duration 20 --concurrency 4` | 3630 успехов, 0 ошибок, 180.651 RPS, p50/p95/p99 16/47/94 мс | `evidence/load.json` | `check_contract.py` тоже PASS. Контракт и публичные тесты я не меняла. @@ -108,7 +111,20 @@ HAProxy сам обновляет адреса через DNS Docker `127.0.0.11 При фиксированном 1.0 CPU четыре реплики хуже одной: 109 против 185 RPS и p99 329 мс против 109 мс. Каждая реплика с лимитом 0.25 CPU сидит около этого потолка (среднее 17–19%). Postgres при этом занят на 0.11–0.26 ядра из разрешённого 1.0. Узкое место здесь — нарезанный CPU процессов API, а не база и не балансировщик. -Когда у каждой реплики остаётся 0.50 CPU, ряд 1/2/4 даёт 84.7 → 148.0 → 329.2 RPS. Четыре реплики почти в 3.9 раза быстрее одной. Postgres доходит до 0.34 ядра, LB до 0.30 при своём лимите 0.50. Это ещё не насыщение базы. Ближе к своему лимиту оказывается балансировщик, но и он не упёрся. Увеличение пула с 4 до 16 на этой точке RPS не подняло: 329.2 против 319.0. Пул на этом профиле не насыщен. +Когда у каждой реплики остаётся 0.50 CPU, ряд 1/2/4 даёт 84.7 → 148.0 → 329.2 RPS. Четыре реплики почти в 3.9 раза быстрее одной. Postgres доходит до 0.34 ядра из разрешённого 1.0, LB до 0.30 при своём лимите 0.50. На этом профиле база и балансировщик ещё не упёрлись: предел здесь нарезанный CPU API. Увеличение пула с 4 до 16 на этой точке RPS не подняло: 329.2 против 319.0. Пул на этом профиле не насыщен. + +Отдельная серия ищет предел уже не в CPU реплик. Каждой реплике отдан целый 1.0 CPU, пул оставлен 4, CAP выключен, нагрузка та же `tests/load.py`, но 12 с и concurrency 16. Postgres ограничен 0.20 CPU. В `docker stats` 100% — одно ядро, поэтому этот потолок виден около 20%. + +| Серия | Реплики | CPU Postgres | RPS | p50/p95/p99, мс | CPU API, среднее | CPU Postgres | CPU LB | +| --- | --- | --- | --- | --- | --- | --- | --- | +| потолок базы 0.20 | 1 | 0.20 | 135.440 | 94/203/375 | 63.85 | 13.31 | 6.64 | +| потолок базы 0.20 | 2 | 0.20 | 141.407 | 109/219/328 | 43.39 | 15.00 | 9.32 | +| потолок базы 0.20 | 4 | 0.20 | 107.017 | 110/312/453 | 23.35 | 16.89 | 8.50 | +| тот же 4×1.0, потолок снят | 4 | 1.0 | 352.885 | 31/156/203 | 49.66 | 44.90 | 28.18 | + +Сырые ответы: `evidence/load-sat-*.json`, сводка: `evidence/saturation.json`. Ошибок клиента не было. + +При потолке 0.20 рост реплик останавливается: 135.4 → 141.4 → 107.0 RPS. Четыре реплики медленнее одной, p99 вырастает до 453 мс. Средний CPU Postgres подходит к потолку (13.3, затем 15.0, затем 16.9 при видимом потолке около 20). CPU одной реплики при этом падает (64 → 43 → 23), значит ядра API простаивают и не они держат RPS. Те же четыре реплики по 1.0 CPU, но уже с Postgres 1.0 CPU, дают 352.9 RPS, примерно в 3.3 раза больше. База тогда занята на 0.45 ядра из разрешённого 1.0, балансировщик на 0.28 при лимите 0.50, среднее API около половины ядра при лимите в целое ядро. Пул в этой серии не менялся. Общий предел, из-за которого лишние реплики перестают помогать, — CPU Postgres. Пока этот потолок снят, ни база, ни балансировщик, ни пул на этой точке ещё не заполнены. Подтверждённое улучшение: не резать 1.0 CPU на четыре процесса, а давать реплике отдельные 0.50 CPU и добавлять такие реплики. Переход 1×0.50 → 2×0.50 поднимает RPS с 84.7 до 148.0, переход к 4×0.50 — до 329.2. Обратная нарезка того же суммарного CPU на четыре процесса снижает RPS со 184.7 до 109.2. Глобальный lock предела сообщений на одном ядре дал 158 против 185 RPS, но на двух и четырёх репликах картина уже шумная, поэтому улучшением я его не объявляю. В рабочем стенде он выключен. @@ -125,7 +141,7 @@ HAProxy сам обновляет адреса через DNS Docker `127.0.0.11 Стенд переживает остановку одного процесса API и поочерёдную замену контейнеров. Он не переживает потерю узла, на котором лежат LB, Postgres или Redis: все три в одном экземпляре. Это не трек 2, и я не утверждаю отказоустойчивость базы. -Точки трека сняты по одному разу, по 12 секунд, closed-loop, с клиента на той же машине. Это не интервал доверия и не открытый поток запросов. Postgres на этом профиле не насытился, поэтому я не называю базу пределом. Пул 16 против 4 тоже ничего не ускорил. Следующий кандидат при ещё большем числе реплик — лимит 0.50 CPU у HAProxy: на четырёх репликах он уже был на 0.30 ядра. +Точки трека и серия насыщения сняты по одному разу, по 12 секунд, closed-loop, с клиента на той же машине. Это не интервал доверия и не открытый поток запросов. На профиле с Postgres 1.0 CPU база не упиралась в свой потолок. Она упирается, когда потолок задан в 0.20 CPU: это и есть измеренная точка, после которой новые реплики не поднимают RPS. Пул 16 против 4 на серии 4×0.50 ничего не ускорил. При снятом потолке базы ближайший общий кандидат — лимит 0.50 CPU у HAProxy: на четырёх репликах по 1.0 CPU он был на 0.28 ядра и ещё не заполнился. Короткие ошибки в момент SIGTERM и удаления контейнера есть. Подтверждённая запись не пропадает: ключ и сообщение коммитятся вместе, а неподтверждённый POST можно повторить с тем же ключом. POST регистрации и создания чата так повторять нельзя, у них ключа нет. diff --git a/compose.yaml b/compose.yaml index 6afef408..f6a51dd4 100644 --- a/compose.yaml +++ b/compose.yaml @@ -41,7 +41,7 @@ services: deploy: resources: limits: - cpus: "1.0" + cpus: "${POSTGRES_CPUS:-1.0}" memory: 512M logging: *logging networks: [lab] @@ -154,7 +154,7 @@ services: deploy: resources: limits: - cpus: "0.50" + cpus: "${LB_CPUS:-0.50}" memory: 128M logging: *logging networks: [lab] diff --git a/evidence/load-sat-pg020-r1.json b/evidence/load-sat-pg020-r1.json new file mode 100644 index 00000000..d913a976 --- /dev/null +++ b/evidence/load-sat-pg020-r1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 12.0, + "elapsed_seconds": 12.5, + "concurrency": 16, + "successful_requests": 1693, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 135.44, + "successful_latency_ms": { + "p50": 94.0, + "p95": 203.0, + "p99": 375.0 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-sat-pg020-r2.json b/evidence/load-sat-pg020-r2.json new file mode 100644 index 00000000..f6b36fdf --- /dev/null +++ b/evidence/load-sat-pg020-r2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 12.0, + "elapsed_seconds": 12.609, + "concurrency": 16, + "successful_requests": 1783, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 141.407, + "successful_latency_ms": { + "p50": 109.0, + "p95": 219.0, + "p99": 328.0 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-sat-pg020-r4.json b/evidence/load-sat-pg020-r4.json new file mode 100644 index 00000000..ca8516a4 --- /dev/null +++ b/evidence/load-sat-pg020-r4.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 12.0, + "elapsed_seconds": 12.484, + "concurrency": 16, + "successful_requests": 1336, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 107.017, + "successful_latency_ms": { + "p50": 110.0, + "p95": 312.0, + "p99": 453.0 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-sat-pg100-r4.json b/evidence/load-sat-pg100-r4.json new file mode 100644 index 00000000..af0c0592 --- /dev/null +++ b/evidence/load-sat-pg100-r4.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 12.0, + "elapsed_seconds": 12.531, + "concurrency": 16, + "successful_requests": 4422, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 352.885, + "successful_latency_ms": { + "p50": 31.0, + "p95": 156.0, + "p99": 203.0 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/saturation.json b/evidence/saturation.json new file mode 100644 index 00000000..6bed3585 --- /dev/null +++ b/evidence/saturation.json @@ -0,0 +1,101 @@ +{ + "question": "With a whole core per API replica, extra replicas stop helping when Postgres CPU is the shared cap.", + "conclusion": "At a 0.20 CPU Postgres cap, 1/2/4 replicas gave 135.440 / 141.407 / 107.017 RPS. Postgres mean CPU rose toward the cap (13.31, 15.00, 16.89; the cap is about 20 in these units) while API CPU per replica fell, so the API cores were idle. The same 4 replicas with the Postgres cap released to 1.0 CPU gave 352.885 RPS and Postgres used 44.90, under its new cap. LB stayed at 28.18 against a 0.50 cap. The shared limit that stopped replica growth is Postgres CPU.", + "method": "tests/load.py closed-loop POST, 12s, concurrency 16, one run each. Postgres limit 0.20 CPU for 1/2/4 replicas, then the same 4 replicas with Postgres limit 1.0.", + "host": { + "platform": "Windows-10-10.0.26100-SP0", + "python": "3.11.5", + "docker_info": "16 8173215744" + }, + "note": "docker stats 100 percent is one core. A 0.20 CPU limit is saturated near 20 percent.", + "runs": [ + { + "name": "pg020-r1", + "replicas": 1, + "api_cpus_each": "1.0", + "postgres_cpus": "0.20", + "lb_cpus": "0.50", + "pool_max": 4, + "concurrency": 16, + "duration_seconds": 12, + "successful_rps": 135.44, + "failed_requests": 0, + "successful_requests": 1693, + "latency_ms": { + "p50": 94.0, + "p95": 203.0, + "p99": 375.0 + }, + "cpu_api_mean": 63.85, + "cpu_postgres_mean": 13.31, + "cpu_lb_mean": 6.64, + "load_exit": 0 + }, + { + "name": "pg020-r2", + "replicas": 2, + "api_cpus_each": "1.0", + "postgres_cpus": "0.20", + "lb_cpus": "0.50", + "pool_max": 4, + "concurrency": 16, + "duration_seconds": 12, + "successful_rps": 141.407, + "failed_requests": 0, + "successful_requests": 1783, + "latency_ms": { + "p50": 109.0, + "p95": 219.0, + "p99": 328.0 + }, + "cpu_api_mean": 43.39, + "cpu_postgres_mean": 15.0, + "cpu_lb_mean": 9.32, + "load_exit": 0 + }, + { + "name": "pg020-r4", + "replicas": 4, + "api_cpus_each": "1.0", + "postgres_cpus": "0.20", + "lb_cpus": "0.50", + "pool_max": 4, + "concurrency": 16, + "duration_seconds": 12, + "successful_rps": 107.017, + "failed_requests": 0, + "successful_requests": 1336, + "latency_ms": { + "p50": 110.0, + "p95": 312.0, + "p99": 453.0 + }, + "cpu_api_mean": 23.35, + "cpu_postgres_mean": 16.89, + "cpu_lb_mean": 8.5, + "load_exit": 0 + }, + { + "name": "pg100-r4", + "replicas": 4, + "api_cpus_each": "1.0", + "postgres_cpus": "1.0", + "lb_cpus": "0.50", + "pool_max": 4, + "concurrency": 16, + "duration_seconds": 12, + "successful_rps": 352.885, + "failed_requests": 0, + "successful_requests": 4422, + "latency_ms": { + "p50": 31.0, + "p95": 156.0, + "p99": 203.0 + }, + "cpu_api_mean": 49.66, + "cpu_postgres_mean": 44.9, + "cpu_lb_mean": 28.18, + "load_exit": 0 + } + ] +} diff --git a/src/db.py b/src/db.py index 166345c4..66d9d467 100644 --- a/src/db.py +++ b/src/db.py @@ -424,8 +424,10 @@ def add_message(chat_id, sender_id, text, method, path, idem_key, request_hash, """Insert a message and its idempotency row in one transaction. The advisory lock is the scope (user, method, path, key), so two replicas - cannot both commit the same key. A 5xx rolls the transaction back, and the - client can repeat that key. An expired row is removed inside the same lock. + cannot both commit the same key. A repeat checks chat membership before it + compares the body: a removed member gets 404 even when the new text would + otherwise be a 409. A 5xx rolls the transaction back, and the client can + repeat that key. An expired row is removed inside the same lock. """ message_id = str(uuid.uuid4()) created = stamp() @@ -455,8 +457,6 @@ def add_message(chat_id, sender_id, text, method, path, idem_key, request_hash, (_uuid(sender_id), method, path, idem_key), ).fetchone() if existing is not None: - if existing['request_hash'] != request_hash: - return 'conflict', None member = conn.execute( """ SELECT 1 AS ok @@ -467,6 +467,8 @@ def add_message(chat_id, sender_id, text, method, path, idem_key, request_hash, ).fetchone() if member is None: return 'missing', None + if existing['request_hash'] != request_hash: + return 'conflict', None stored = conn.execute( """ SELECT id, chat_id, sender_id, body, created_at diff --git a/student-tests/check_idem_access.py b/student-tests/check_idem_access.py new file mode 100644 index 00000000..2dd90f34 --- /dev/null +++ b/student-tests/check_idem_access.py @@ -0,0 +1,76 @@ +"""Removed member must get 404 on a repeated key before the body is compared. + +Membership is revoked with DELETE in Postgres, the same way an isolated +database check does it. The script prints status codes only. +""" +import re +import subprocess +import sys +import uuid +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +from client import Client +import stand + +UUID = re.compile(r'^[0-9a-fA-F-]{36}$') + + +def revoke(user_id, chat_id): + if UUID.fullmatch(user_id) is None or UUID.fullmatch(chat_id) is None: + raise SystemExit('refusing to interpolate a non-uuid') + sql = ( + "DELETE FROM chat_members WHERE user_id = '%s' AND chat_id = '%s'" + % (user_id, chat_id) + ) + stand.compose(['exec', '-T', 'postgres', 'psql', '-U', 'messenger', '-d', 'messenger', '-c', sql]) + + +def post(client, actor, chat_id, text, key, expected): + result = client.call( + 'POST', + '/api/v1/chats/%s/messages' % chat_id, + expected, + actor=actor, + body={'text': text}, + headers={'Idempotency-Key': key}, + schema='Message' if expected == 201 else 'Error', + ) + print('status', result['status'], 'expected', expected) + return result + + +def main(): + stand.wait_ready() + client = Client(stand.BASE, timeout=10) + alice = client.user('acl') + bob = client.user('aclpeer') + chat = client.call( + 'POST', + '/api/v1/chats', + 201, + actor=alice, + body={'title': 'Проверка ключа', 'member_ids': [alice['id'], bob['id']]}, + schema='Chat', + )['json'] + key = 'same-' + uuid.uuid4().hex[:16] + post(client, alice, chat['id'], 'первое', key, 201) + post(client, alice, chat['id'], 'другое', key, 409) + revoke(alice['id'], chat['id']) + post(client, alice, chat['id'], 'другое', key, 404) + post(client, alice, chat['id'], 'первое', key, 404) + history = client.call( + 'GET', + '/api/v1/chats/%s/messages' % chat['id'], + 404, + actor=alice, + schema='Error', + ) + print('history', history['status']) + print('access check passed') + + +if __name__ == '__main__': + main() diff --git a/student-tests/experiment_saturation.py b/student-tests/experiment_saturation.py new file mode 100644 index 00000000..47656d96 --- /dev/null +++ b/student-tests/experiment_saturation.py @@ -0,0 +1,160 @@ +"""Find the shared limit that stops extra API replicas from raising RPS. + +Each API replica gets a whole core, so the earlier CPU-slicing effect is gone. +Postgres is capped at 0.20 CPU for three points (1/2/4 replicas). A fourth +point releases that cap to 1.0 CPU with the same four replicas. If RPS stops +growing while Postgres sits on 0.20, and jumps when the cap is released, the +database CPU is the saturation point. +""" +import json +import platform +import subprocess +import sys +import threading +import time +from pathlib import Path + +sys.path.insert(0, str(Path(__file__).resolve().parents[1] / 'tests')) +sys.path.insert(0, str(Path(__file__).resolve().parent)) + +import stand + +ROOT = stand.ROOT +DURATION = 12 +CONCURRENCY = 16 + +RUNS = [ + {'name': 'pg020-r1', 'replicas': 1, 'pg_cpus': '0.20'}, + {'name': 'pg020-r2', 'replicas': 2, 'pg_cpus': '0.20'}, + {'name': 'pg020-r4', 'replicas': 4, 'pg_cpus': '0.20'}, + {'name': 'pg100-r4', 'replicas': 4, 'pg_cpus': '1.0'}, +] + + +def deploy(cfg): + env = { + 'API_CPUS': '1.0', + 'API_MEMORY': '256M', + 'CAP_MODE': 'off', + 'POOL_MAX': '4', + 'API_REPLICAS': str(cfg['replicas']), + 'POSTGRES_CPUS': cfg['pg_cpus'], + 'LB_CPUS': '0.50', + 'MAX_INFLIGHT_BODIES': '64', + 'MAX_PER_SECOND': '100000', + } + stand.compose(['up', '-d', '--no-deps', '--force-recreate', 'postgres'], extra_env=env) + stand.compose( + ['up', '-d', '--no-deps', '--force-recreate', '--scale', 'api=%d' % cfg['replicas'], 'api'], + extra_env=env, + ) + stand.compose(['up', '-d', '--no-deps', '--force-recreate', 'lb'], extra_env=env) + stand.wait_ready(timeout=120) + + +def run_load(output): + samples = [] + stop = {'flag': False} + + def stats(): + while not stop['flag']: + try: + samples.append(stand.sample_stats()) + except Exception: + pass + time.sleep(2) + + thread = threading.Thread(target=stats) + thread.start() + completed = subprocess.run( + [ + sys.executable, + str(ROOT / 'tests' / 'load.py'), + '--base-url', stand.BASE, + '--duration', str(DURATION), + '--concurrency', str(CONCURRENCY), + '--output', str(output), + ], + cwd=ROOT, + text=True, + capture_output=True, + ) + stop['flag'] = True + thread.join() + report = json.loads(output.read_text(encoding='utf-8')) if output.exists() else {} + report['load_exit'] = completed.returncode + if completed.returncode != 0 and 'successful_requests' not in report: + report['stderr_tail'] = (completed.stderr or completed.stdout or '')[-400:] + return report, samples + + +def restore(): + stand.compose( + ['up', '-d', '--no-deps', '--force-recreate', 'postgres'], + extra_env={'POSTGRES_CPUS': '1.0'}, + ) + stand.compose( + ['up', '-d', '--no-deps', '--force-recreate', '--scale', 'api=2', 'api'], + extra_env={ + 'API_CPUS': '0.50', + 'API_MEMORY': '512M', + 'CAP_MODE': 'off', + 'POOL_MAX': '4', + 'API_REPLICAS': '2', + 'MAX_INFLIGHT_BODIES': '32', + 'MAX_PER_SECOND': '10000', + }, + ) + stand.compose( + ['up', '-d', '--no-deps', '--force-recreate', 'lb'], + extra_env={'LB_CPUS': '0.50'}, + ) + stand.wait_ready(timeout=120) + + +def main(): + info = subprocess.run(['docker', 'info', '--format', '{{.NCPU}} {{.MemTotal}}'], text=True, capture_output=True) + rows = [] + for cfg in RUNS: + print('run %s' % cfg['name'], flush=True) + deploy(cfg) + output = ROOT / 'evidence' / ('load-sat-%s.json' % cfg['name']) + report, samples = run_load(output) + rows.append({ + 'name': cfg['name'], + 'replicas': cfg['replicas'], + 'api_cpus_each': '1.0', + 'postgres_cpus': cfg['pg_cpus'], + 'lb_cpus': '0.50', + 'pool_max': 4, + 'concurrency': CONCURRENCY, + 'duration_seconds': DURATION, + 'successful_rps': report.get('successful_rps'), + 'failed_requests': report.get('failed_requests'), + 'successful_requests': report.get('successful_requests'), + 'latency_ms': report.get('successful_latency_ms'), + 'cpu_api_mean': stand.mean_cpu(samples, '-api-'), + 'cpu_postgres_mean': stand.mean_cpu(samples, '-postgres-'), + 'cpu_lb_mean': stand.mean_cpu(samples, '-lb-'), + 'load_exit': report.get('load_exit'), + }) + print(json.dumps(rows[-1], ensure_ascii=False), flush=True) + evidence = { + 'question': 'With a whole core per API replica, extra replicas stop helping when Postgres CPU is the shared cap.', + 'method': 'tests/load.py closed-loop POST, 12s, concurrency 16, one run each. Postgres limit 0.20 CPU for 1/2/4 replicas, then the same 4 replicas with Postgres limit 1.0.', + 'host': { + 'platform': platform.platform(), + 'python': platform.python_version(), + 'docker_info': (info.stdout or '').strip(), + }, + 'note': 'docker stats 100 percent is one core. A 0.20 CPU limit is saturated near 20 percent.', + 'runs': rows, + } + dest = ROOT / 'evidence' / 'saturation.json' + dest.write_text(json.dumps(evidence, ensure_ascii=False, indent=2) + '\n', encoding='utf-8') + restore() + print('restored', flush=True) + + +if __name__ == '__main__': + main()