diff --git a/.env.example b/.env.example index d32b9be0..06ec8428 100644 --- a/.env.example +++ b/.env.example @@ -5,9 +5,37 @@ APP_PORT=8080 APP_ENV=lab SESSION_TTL_SECONDS=3600 # Choose credentials locally. File paths contain no secret values. +# The files are created by `python scripts/init_secrets.py` and mounted by compose as secrets. DATABASE_URL_FILE=/run/secrets/database_url # Optional on 3, required use on 4 in lab2; Redis OR Valkey: -SESSION_STORE=postgres +# valkey = sessions live only in Valkey (AOF, appendfsync always); postgres = table `sessions`. +SESSION_STORE=valkey CACHE_URL_FILE=/run/secrets/cache_url +# Number of interchangeable API replicas behind HAProxy (compose deploy.replicas). API_REPLICAS=2 +# Idempotency-Key results are kept at least this long (contract: >= 24 h). IDEMPOTENCY_TTL_SECONDS=86400 +# Write path of POST message: function = one SQL call (migration 0003), multi = lab3 baseline path. +MESSAGE_WRITE_PATH=function +# Additional settings of this implementation (defaults shown; all optional): +LOG_LEVEL=info +DB_POOL_MIN=1 +DB_POOL_MAX=10 +DB_TIMEOUT_SECONDS=3 +CACHE_TIMEOUT_SECONDS=0.5 +PASSWORD_HASH_CONCURRENCY=2 +DOCS_ENABLED=true +# Graceful stop of a replica: readiness 503 + drain, then up to SHUTDOWN for in-flight requests. +DRAIN_SECONDS=3 +SHUTDOWN_TIMEOUT_SECONDS=8 +# CPU/RAM limits (docker compose deploy.resources.limits); API_* are per replica. +API_CPUS=1.0 +API_MEMORY=256m +PG_CPUS=2.0 +PG_MEMORY=1g +VALKEY_CPUS=0.5 +LB_CPUS=1.0 +PG_MAX_CONNECTIONS=100 +# Host ports of the load balancer (published on 127.0.0.1 only; API replicas publish nothing) +APP_PUBLISH_PORT=8080 +LB_STATS_PORT=8404 diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 00000000..3c10fe54 --- /dev/null +++ b/.gitattributes @@ -0,0 +1,5 @@ +# LF everywhere: identical files on Windows/Linux and inside `git archive | docker build -`. +* text=auto eol=lf +*.png binary +# cmd.exe expects CRLF in batch files. +*.cmd text eol=crlf diff --git a/.github/workflows/app.yml b/.github/workflows/app.yml new file mode 100644 index 00000000..c13c7dd2 --- /dev/null +++ b/.github/workflows/app.yml @@ -0,0 +1,36 @@ +name: Application (lab3) +on: [push, pull_request] +permissions: + contents: read +jobs: + app: + runs-on: ubuntu-latest + timeout-minutes: 40 + steps: + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 + with: + python-version: '3.13' + - name: Synthetic secrets and env (CI only, never committed) + run: python scripts/init_secrets.py && cp .env.example .env + - name: Build, migrate once, start 2 API replicas behind HAProxy, wait for healthy + run: docker compose --env-file .env up -d --build --wait + - name: Contract and public smoke + run: make check test PYTHON=python + - name: Persistence across restart of LB, API replicas and stores + run: make test-persistence ACTION_SCRIPT=scripts/restart.sh PYTHON=python + - name: Failover of the replica that served the test, then restore it + run: | + make test-failover ACTION_SCRIPT=scripts/stop-one.sh PYTHON=python + sh scripts/restore-api.sh && python scripts/lbctl.py wait-up 2 + - name: Own tests (unit + stand; every failure is restored in finally) + run: | + python -m pip install --require-hashes --no-deps -r requirements.txt + python -m pip install -r requirements-test.txt + make student-test PYTHON=python + - name: Logs + if: always() + run: docker compose logs --tail 100 api lb + - name: Remove CI stand and its synthetic data + if: always() + run: docker compose down -v diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..f46ac0be --- /dev/null +++ b/Dockerfile @@ -0,0 +1,59 @@ +# syntax=docker/dockerfile:1 +# Messenger API, lab 3 (replicas behind HAProxy, PostgreSQL + Valkey). Built by compose.yaml (services api, migrate). +# +# Python is interpreted, so there is no separate compile stage; the image +# contains only the interpreter, locked dependencies and the source code. +# Base image is pinned by version AND digest (python 3.13.16, Debian 12 bookworm). +FROM python:3.13.16-slim-bookworm@sha256:a1165e272e578941b84abc79e4ab38a0305cd12803a5c4247979ac7655f4d641 + +ENV PYTHONDONTWRITEBYTECODE=1 \ + PYTHONUNBUFFERED=1 \ + PIP_NO_CACHE_DIR=1 \ + PIP_DISABLE_PIP_VERSION_CHECK=1 + +WORKDIR /app + +# 1. Dependencies first (layer cache survives source edits). Every package, +# including transitive ones, is pinned with sha256 hashes in requirements.txt; +# --no-deps guarantees nothing outside the lock file is installed. +COPY requirements.txt ./ +RUN pip install --root-user-action=ignore --require-hashes --no-deps -r requirements.txt + +# 2. Unprivileged runtime user. Code stays owned by root, so the process +# cannot modify its own code. +RUN groupadd --system --gid 10001 app \ + && useradd --system --uid 10001 --gid app --no-create-home --shell /usr/sbin/nologin app + +COPY src/ ./src/ +# Versioned SQL migrations, applied by `python -m messenger.migrate` (compose service migrate). +COPY migrations/ ./migrations/ +# Course contract, served read-only at /openapi.json for Swagger UI (/docs). +COPY contracts/openapi.json ./contracts/openapi.json + +# Non-secret defaults; compose.yaml passes the rest. Passwords come only as files +# (DATABASE_URL_FILE / CACHE_URL_FILE -> Docker secrets), never as ENV or COPY. +ENV PYTHONPATH=/app/src \ + APP_HOST=0.0.0.0 \ + APP_PORT=8080 \ + APP_ENV=lab \ + LOG_LEVEL=info \ + SHUTDOWN_TIMEOUT_SECONDS=8 \ + DOCS_ENABLED=true \ + SESSION_TTL_SECONDS=3600 \ + DATABASE_URL_FILE=/run/secrets/database_url + +# Build revision (scripts/rolling-update.sh passes git commit + time): makes every rolled-out +# image distinguishable in `docker inspect` and in the "starting" log line of each replica. +ARG BUILD_REVISION=dev +LABEL org.opencontainers.image.revision=$BUILD_REVISION +ENV APP_REVISION=$BUILD_REVISION + +USER app:app +EXPOSE 8080 +STOPSIGNAL SIGTERM + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD ["python", "-m", "messenger.healthcheck"] + +# Exec form: the Python server is PID 1 and receives SIGTERM directly (no shell in between). +CMD ["python", "-m", "messenger"] diff --git a/Makefile b/Makefile index 5d86d171..58704a5a 100644 --- a/Makefile +++ b/Makefile @@ -28,3 +28,56 @@ test-persistence: test-failover: @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) + +# --------------------------------------------------------------------------- +# Student solution (lab 3, Python). On Windows: PowerShell/Git Bash with GNU make, public +# tests need PYTHONUTF8=1, and the hooks are started through scripts/*.cmd (Git Bash). +.PHONY: secrets up down logs ps migrate student-test unit-test explain lb-status restore rolling-update failover-series + +secrets: + $(PYTHON) scripts/init_secrets.py + +# Build, apply migrations ONCE (service migrate), start API replicas and the LB, wait for healthy. +up: secrets + docker compose up -d --build --wait + +# Safe stop: containers stop, named volumes (data) stay. +down: + docker compose down + +logs: + docker compose logs --tail 50 api lb + +ps: + docker compose ps -a + +migrate: + docker compose run --rm migrate + +# HAProxy view of the replicas (UP/DOWN) mapped to containers and X-Instance-Id. +lb-status: + $(PYTHON) scripts/lbctl.py status + $(PYTHON) scripts/lbctl.py replicas + +# Start replicas stopped by scripts/stop-one.sh again and wait until the LB has them all UP. +restore: + sh scripts/restore-api.sh + $(PYTHON) scripts/lbctl.py wait-up $${API_REPLICAS:-2} + +# Replace every API replica one by one with a freshly built image (no downtime). +rolling-update: + sh scripts/rolling-update.sh + +# Level 4: stop each replica in turn under load, measure RPS/errors/recovery (evidence/failover/). +failover-series: + $(PYTHON) bench/failover_series.py --output evidence/failover + +# Own tests: unit + black-box against the running stand (needs requirements*.txt in a venv). +student-test: + $(PYTHON) -m pytest student-tests -v + +unit-test: + $(PYTHON) -m pytest student-tests -m "not stack" -q + +explain: + $(PYTHON) scripts/explain_history.py --output evidence/explain-history.txt diff --git a/REPORT.md b/REPORT.md index c2679005..7f4f015a 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,288 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Боданюк Алексей, БВТ2302 +- Целевая оценка: **5**, трек 1 «Цена масштабирования» +- Ветка: `solution/bvt2302-bodanyuk`. Форк: `https://gitea.privcloud.tech/wfa/mtusi2026lab3`. PR: «ЛР 3 — БВТ2302 — Боданюк — на 5» в mtusi2026/mtusi2026lab3 +- Стек: Python 3.13.16, Starlette 1.7.0, uvicorn 0.54.0, psycopg 3.3.6 + psycopg-pool 3.3.3, redis-py 8.1.0, argon2-cffi 25.1.0; PostgreSQL 18.6, Valkey 8.1.3, HAProxy 3.2.26 (LTS); замеры — k6 2.3.0, py-spy 0.4.2. Все образы закреплены по тегу **и** digest, все Python-пакеты — по sha256 ([requirements.txt](requirements.txt), [bench/track1/pyspy/requirements.txt](bench/track1/pyspy/requirements.txt)) +- Источники: README, COURSE, контракт ([openapi.json](contracts/openapi.json), [семантика](contracts/README.md)), документация HAProxy 3.2 (server-template, resolvers, http-check, retry-on, http-error), Docker Compose (deploy, networks), PostgreSQL (INSERT … ON CONFLICT, PL/pgSQL, pg_stat_statements, libpq keepalives/tcp_user_timeout), psycopg 3 (pool, autocommit), k6 (constant-arrival-rate, dropped_iterations). Учтены все замечания преподавателя к PR lab3 и lab2 других студентов ([раздел ниже](#проверки-на-которых-ловили-другие-работы)); мой PR lab2 (#42) принят без замечаний +- Помощь ИИ: код, тесты, скрипты экспериментов и черновик отчёта написаны с помощью ИИ-ассистента Claude Code (Anthropic). Все команды и замеры реально выполнены на стенде ниже; вывод — в [evidence/](evidence/). Ответы на вопросы защиты — [docs/DEFENSE.md](docs/DEFENSE.md), запуск на Windows и сценарий защиты по шагам — [docs/WINDOWS.md](docs/WINDOWS.md) ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Нужны Git, Docker с Compose v2 (проверено: Docker 29.8.0, Compose 5.5.1), Python 3.9+ и GNU make (на Windows — см. [WINDOWS.md](docs/WINDOWS.md)). Учётные данные в Git не хранятся, их создаёт скрипт. + +```sh +git clone https://gitea.privcloud.tech/wfa/mtusi2026lab3 mtusi2026lab3 && cd mtusi2026lab3 && git checkout solution/bvt2302-bodanyuk +python3 scripts/init_secrets.py # случайные локальные пароли -> ./secrets (git-ignored), идемпотентно +cp .env.example .env # API_REPLICAS=2, лимиты, таймауты; значения по умолчанию есть и в compose.yaml +docker compose --env-file .env config --quiet +docker compose --env-file .env up -d --build --wait +# postgres, valkey healthy -> migrate (один раз, exit 0) -> api x2 healthy -> lb healthy +curl -i http://127.0.0.1:8080/health/ready # 200, X-Instance-Id: ; Swagger /docs; LB: http://127.0.0.1:8404/ +make check && make test +make test-persistence ACTION_SCRIPT=scripts/restart.sh +make test-failover ACTION_SCRIPT=scripts/stop-one.sh && make restore +``` + +- **Windows:** публичным тестам нужен `PYTHONUTF8=1`; Windows не исполняет `.sh`, поэтому хуки запускаются через обёртки `scripts/restart.cmd` и `scripts/stop-one.cmd` (тот же `.sh` в Git Bash); рецептам Makefile нужен `sh` из `C:\Program Files\Git\usr\bin`. +- **Свои тесты:** `python3 -m venv .venv`, `pip install --require-hashes --no-deps -r requirements.txt`, `pip install -r requirements-test.txt`, затем `make student-test` (~8 мин, стенд должен быть поднят). Без стенда — `make unit-test`. +- **Все доказательства одной командой** (на чистом clone, ~25 мин): `python scripts/collect_evidence.py`. +- **Миграции:** только сервис `migrate` (`python -m messenger.migrate`, advisory lock, checksum файлов), до старта реплик. Повтор: `make migrate` → `already applied, skipped`. +- **Остановка:** безопасно — `docker compose down` (volumes сохраняются). Намеренное удаление учебных данных — `docker compose down -v` и `rm -rf secrets`. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +```text +клиент ──127.0.0.1:8080──> lb: HAProxy 3.2 ──сеть edge──> api × N (Starlette/uvicorn, без состояния, X-Instance-Id = hostname) + │ check GET /health/ready 1 с, fall 2/rise 2 │ + │ Docker DNS `api` каждые 1 с (server-template, 8 слотов) └──сеть data (internal)──> postgres 18.6 (источник истины) + └ свои 502/503/504 — JSON по контракту с X-Request-Id valkey 8.1.3 (сессии, AOF always) +migrate (одноразовый) ──data──> postgres: миграции 0001–0003 до старта реплик +``` + +| Роль | Service | Образ | Health / readiness | Volume | Сеть / порт | Credentials | CPU / RAM | +| --- | --- | --- | --- | --- | --- | --- | --- | +| Точка входа | `lb` | `haproxy:3.2.26-alpine@sha256:254e6370…` | `haproxy -c` + stats; бэкенды — активная проверка `/health/ready` | — | edge; `127.0.0.1:8080` и `[::1]:8080` (loopback, см. ниже), `127.0.0.1:8404` (stats) | нет | 1.0 / 128m | +| API × 2 | `api` (`deploy.replicas`) | `mtusi-messenger:lab3` из исходников | Docker: `/health/ready` 2 с; LB: своя проверка | — | edge + data, только `expose 8080` | secrets `database_url`, `cache_url` | 1.0 / 256m каждая | +| Миграции | `migrate` | тот же образ | exit 0 | — | data | secret `database_url` | 0.5 / 256m | +| БД | `postgres` | `postgres:18.6-bookworm@sha256:afc7e2d4…` | `pg_isready` | `pgdata` | data (internal) | secret `postgres_password` | 2.0 / 1g | +| Сессии | `valkey` | `valkey/valkey:8.1.3-bookworm@sha256:fea8b3e6…` | `valkey-cli ping` | `valkeydata` | data (internal) | secret `valkey_password` → include-файл | 0.5 / 256m | + +**Что перенесено из lab2** (отдельный коммит `4f6cfda`, без изменений): API, PostgreSQL-схема 0001, сессии только в Valkey, Argon2id, keyset-cursor, строгая валидация, дедлайны БД/Valkey, собственные тесты. **Что изменено в lab3:** + +- **Балансировка без sticky.** Один Compose-сервис `api` масштабируется (`--scale`, `deploy.replicas`), без `container_name` и `ports`. HAProxy находит реплики через Docker DNS (`server-template api 8 api:8080 … resolvers docker`, `hold valid 1s`), поэтому scale up/down, новый IP после рестарта и полный restart стенда подхватываются без перезапуска LB (проверено тестами). +- **Readiness управляет маршрутизацией.** `option httpchk GET /health/ready`, `inter 1s fastinter 500ms fall 2 rise 2`, `timeout check 1s`, без backup-слотов. Ready = PostgreSQL и Valkey отвечают и нет drain. Реплика, живая по `/health/live`, но без БД/Valkey, не получает ни одного бизнес-запроса. +- **Повторы в LB только безопасные.** `retry-on conn-failure` + `option redispatch`: повторяется только запрос, который не удалось отправить реплике. Всё, что могло дойти до API (включая неидемпотентные POST создания чата/пользователя), повторяет клиент сам; отправку сообщения — с тем же `Idempotency-Key`. +- **Graceful shutdown.** SIGTERM → readiness 503 сразу → `DRAIN_SECONDS=3` реплика ещё обслуживает (LB успевает пометить её DOWN) → uvicorn закрывает сокет, запросы в полёте ≤ `SHUTDOWN_TIMEOUT_SECONDS=8` → exit 0. 3 + 8 < `stop_grace_period: 15s`, SIGKILL не нужен. +- **`X-Instance-Id`** = hostname контейнера (короткий container ID): стабилен для процесса, однозначно сопоставляется контейнеру (`docker inspect`), что использует `scripts/stop-one.sh`. Middleware ставит его и `X-Request-Id` на **каждый** ответ API, включая 404/405/413/500/503. Ошибки, созданные самим HAProxy, — без `X-Instance-Id` (их создал не API), но в формате контракта и с тем же `X-Request-Id`. +- **Общая идемпотентность** ([0002](migrations/0002_idempotency_keys.sql), [0003](migrations/0003_post_message_function.sql), [repo.py](src/messenger/repo.py), [app.py](src/messenger/app.py)). Таблица `idempotency_keys (user_id, chat_id, key)` → SHA-256 канонического тела → `message_id`. Ключ, часы чата, сообщение и «результат» — **одна транзакция**; отдельного pending-состояния нет, поэтому сбой не оставляет «висящий» ключ, а транзиентная 5xx не фиксируется. Конкурентный повтор ждёт на уникальном индексе завершения первой транзакции и затем видит её результат (READ COMMITTED). Тот же ключ и тело → тот же 201 и Message; другое тело → 409; постороннему — 404 всегда (членство проверяется до ключа); `attachment_ids: []` = отсутствие поля, порядок ключей JSON не важен. Ключи хранятся ≥ 24 ч, старше — очищаются пачками раз в 10 мин под advisory-замком. +- **Миграции** — только сервис `migrate`, до старта реплик; 0002 и 0003 только добавляют объекты и совместимы с работающей предыдущей версией (rolling update: сначала миграция новым образом, затем замена реплик). При `docker compose start api` (например, в `restart.sh`) Compose снова запускает `migrate` как зависимость — он берёт advisory-замок и отвечает `already applied, skipped`; реплики ждут его завершения ([test-persistence.txt](evidence/test-persistence.txt)). +- **Порты только на loopback.** LB опубликован на `127.0.0.1` и `[::1]`. На Windows `localhost` сначала разрешается в `::1`, и отказ соединения по нему стоил ~2 с на **каждый** запрос (измерено: 2,0 с против 0,007 с). Публичные тесты по умолчанию ходят на `http://localhost:8080`, и в первом прогоне из чистого clone `make test-failover` из-за этого успел сделать лишь 8 записей за 15 с. После исправления — 0,013 с. +- **Сети.** `edge` (lb, api) и internal `data` (api, migrate, postgres, valkey): LB не видит хранилища, у хранилищ нет выхода наружу. Secrets — каждому сервису только свои (проверяется тестом по `docker compose config`). +- **Дефект, найденный на lab3-сценарии рецензента.** Если одной реплике отключить сеть `data`, по дедлайну задача psycopg отменялась, psycopg слал cancel-запрос, а libpq `PQcancelStart` синхронно резолвит имя хоста **в потоке event loop** — вся реплика, включая `/health/live`, зависала примерно на минуту и не возвращалась сама. Теперь по дедлайну запрос сразу получает 503, а задача не отменяется и завершается сама; мёртвые соединения рвёт TCP keepalive + `tcp_user_timeout` = 3 с ([db.py](src/messenger/db.py)). Повторная проверка: live отвечает за 0,00 с, ready 503 за 1,0 с, после восстановления сети реплика сама UP за ~2 с (тест `test_lb_stops_routing_…[network]`). +- **Улучшение трека 1** — запись сообщения одним вызовом SQL-функции `post_message` (подробно в треке); прежний путь доступен как `MESSAGE_WRITE_PATH=multi`, оба проходят одни и те же тесты. + +Readiness-критичные зависимости: PostgreSQL (всё, кроме health) и Valkey (все защищённые запросы). Swagger/stats LB на readiness не влияют. + +Соответствие `.env.example` реальной конфигурации ([config.py](src/messenger/config.py), [compose.yaml](compose.yaml)): + +| Переменная | Значение | Где используется | +| --- | --- | --- | +| `APP_HOST`, `APP_PORT`, `APP_ENV` | `0.0.0.0`, `8080`, `lab` | bind uvicorn, стартовый лог | +| `SESSION_TTL_SECONDS` | `3600` | срок сессии (compose передаёт в каждую реплику) | +| `DATABASE_URL_FILE`, `CACHE_URL_FILE` | `/run/secrets/…` | строки подключения из secret-файлов | +| `SESSION_STORE` | `valkey` (или `postgres`) | хранилище сессий | +| `API_REPLICAS` | `2` | `deploy.replicas` сервиса `api` | +| `IDEMPOTENCY_TTL_SECONDS` | `86400` (меньше нельзя) | срок хранения результата ключа | +| `MESSAGE_WRITE_PATH` | `function` (или `multi`) | путь записи сообщения (трек 1, A/B) | +| `DRAIN_SECONDS`, `SHUTDOWN_TIMEOUT_SECONDS` | `3`, `8` | graceful shutdown | +| `DB_POOL_MIN/MAX`, `DB_TIMEOUT_SECONDS`, `CACHE_TIMEOUT_SECONDS`, `PASSWORD_HASH_CONCURRENCY` | 1/10, 3, 0.5, 2 | пул, дедлайны, параллельность Argon2id | +| `API_CPUS/MEMORY`, `PG_CPUS/MEMORY`, `VALKEY_CPUS`, `LB_CPUS`, `PG_MAX_CONNECTIONS` | 1.0/256m, 2.0/1g, 0.5, 1.0, 100 | лимиты контейнеров | +| `APP_PUBLISH_PORT`, `LB_STATS_PORT` | `8080`, `8404` | порты LB на `127.0.0.1` (API портов не публикует) | +| `LOG_LEVEL`, `DOCS_ENABLED` | `info`, `true` | логи, Swagger | ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +Стенд: Windows 10 22H2, AMD Ryzen 5 3400G (4 ядра / 8 потоков), 30 ГБ RAM, Docker Desktop 29.8.0 (WSL2, 8 vCPU), Python 3.14 на хосте, GNU make 4.4.1. Все проверки уровней 3 и 4 ниже выполнены 2026-10-19 **на стенде из чистого clone** (новая папка, `git clone`, пустые volumes, secrets созданы заново) одной командой `python scripts/collect_evidence.py`, коммит `2708732`. Вывод сохранён целиком. + +| Критерий README | Команда / сценарий | Наблюдаемый результат | Файл | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | +| Чистый clone, secrets, миграции с нуля, одна команда запуска | `init_secrets.py`, `compose config --quiet`, `compose up -d --build --wait`, `compose logs migrate`, `git check-ignore` | все 5 сервисов healthy, `migrate` Exited (0): `0001…0003: applied`; образы по digest; `secrets/` и `.env` игнорируются Git | [clean-clone.txt](evidence/clean-clone.txt) | +| Контракт | `make check`, `make validate` | PASS, PASS | [make-check-validate-test.txt](evidence/make-check-validate-test.txt) | +| **3:** публичный smoke | `make test` | `PASS: lab3 public API scenario` | там же | +| **3:** ≥ 2 реплики, одна точка входа, общая БД и сессии | `lbctl.py replicas/status`, `test_one_session_is_served_by_every_real_replica`, `test_write_on_one_replica_is_read_on_the_other` | 2 контейнера `api` UP в HAProxy; один токен — ответы от обоих, `X-Instance-Id` = их hostname; запись на одной сразу читается на другой; logout сразу действует на обеих | [clean-clone.txt](evidence/clean-clone.txt), [student-tests.txt](evidence/student-tests.txt) | +| **3:** остановка любой реплики, ≤ 10 с, подтверждённое на месте | `make test-failover ACTION_SCRIPT=scripts/stop-one.cmd` → `make restore` → снова (по очереди обе) | PASS для `api-1` и для `api-2`: 131 / 132 успешных записи, **0 неудачных попыток**, запись после хука — 5,9 / 5,7 с; остановленный контейнер `exited (0)`, вторая реплика UP | [test-failover.txt](evidence/test-failover.txt) | +| **3:** повтор POST без дубля, в т.ч. конкурентный и через другую реплику; неподтверждённую запись можно повторить | `test_idempotency.py` (21 тест) + публичный failover-тест (повторяет неопределённый POST с тем же ключом) | см. таблицу «ловушек» ниже; публичный тест: дублей нет | [student-tests.txt](evidence/student-tests.txt) | +| **3:** persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.cmd` | PASS; у `lb`, `api-1`, `api-2`, `postgres`, `valkey` новые PID и `StartedAt`, volumes те же, токен тот же | [test-persistence.txt](evidence/test-persistence.txt) | +| **4:** readiness, таймауты, SIGTERM согласованы; LB исключает недоступный backend | `test_lb_stops_routing_…[pg_hba/network × 2]`, `test_graceful_stop_…[×2]`, `test_graceful_shutdown_order_in_logs` | живая, но неготовая реплика выходит из ротации за 3–4 с, live 200 / ready 503, сама возвращается ≤ 15 с; graceful stop под нагрузкой — 0 ошибок; в логах `drain_started` → `shutdown_requested` → `stopped`, exit 0, в логе HAProxy — `is DOWN` для этой реплики | [student-tests.txt](evidence/student-tests.txt) | +| **4:** период проверок и максимальное время обнаружения | [haproxy.cfg](infra/haproxy/haproxy.cfg) + серия отказов | проверка раз в 1 с, `fall 2`/`rise 2`, `timeout check 1s`; максимум ≈ 3,5 с (заморозка); подробно — в следующем разделе | [failover/series.md](evidence/failover/series.md) | +| **4:** поочерёдная остановка каждой реплики: RPS, ошибки, восстановление | `bench/failover_series.py` (stop / kill / pause × обе реплики) | stop: 0 ошибок; kill: 3 оборванных запроса за ≤ 0,25 с; pause: 4 неудачные попытки за ≤ 3,2 с; потерь и дублей нет | [failover/series.md](evidence/failover/series.md), [series.json](evidence/failover/series.json) | +| **4:** общая идемпотентность параллельными запросами | `test_concurrent_same_key_through_different_replicas_creates_exactly_one`, `…_different_bodies_one_wins` | 24 одновременных → 24 × 201, одно тело, ≥ 2 реплики, 1 строка ключа и 1 сообщение (×3 раунда); разные тела → один победитель, остальные 409 | [student-tests.txt](evidence/student-tests.txt) | +| **4:** лимиты CPU/RAM, нет портов в обход LB, secrets по месту, нет `container_name` | `test_compose_policy_limits_ports_secrets_images`, `test_running_containers_have_limits_and_no_bypass_ports` | лимиты у всех 5 сервисов (config и `docker inspect`); порты только у `lb` и только loopback; secrets: lb — нет, migrate — `database_url`, api — `database_url`+`cache_url`; сети edge/data | там же | +| **4:** rolling update под нагрузкой | `bench/rolling_under_load.py` → `scripts/rolling-update.sh` | 57 с, 11 848 запросов, **0 ошибок**; `api-1/2 revision=dev` → `api-3/4 revision=2708732-…`; 7119 подтверждённых сообщений, 0 потерь и дублей | [rolling-update/](evidence/rolling-update/) | +| **4:** миграции однократно и совместимы | `test_migrations_ran_once_by_the_migrate_service`, `test_migrations_rerun_is_a_noop` | применяет только `migrate` (в логах API миграций нет); повтор — `already applied, skipped`; 0002/0003 только добавляют объекты и применяются до замены реплик | [student-tests.txt](evidence/student-tests.txt), [rolling-update/script-output.txt](evidence/rolling-update/script-output.txt) | +| Публичный генератор нагрузки | `tests/load.py --duration 30 --concurrency 4` | 5247 успешных, 0 ошибок, 174 req/s (closed-loop через порт Windows), p50/p95/p99 = 19 / 50 / 65 мс | [load.json](evidence/load.json) | +| Свои тесты | `python -m pytest student-tests -v` | **201 passed** (69 unit + 132 против стенда), 8 мин; все отказы восстанавливаются в `finally` | [student-tests.txt](evidence/student-tests.txt) | +| Оба пути записи эквивалентны | тесты идемпотентности, контракта и БД с `MESSAGE_WRITE_PATH=multi` | 105 passed (режим `function` — весь набор выше) | раздел трека 1 | +| **5:** трек 1 | `bench/track1/series.sh baseline|improved|ceiling`, `profile.py`, `analyze.py` | см. раздел «Трек 1» | [evidence/track1/](evidence/track1/) | -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +Первый прогон из чистого clone (тот же сценарий, коммит `2846cae`) нашёл проблему: через `localhost` каждое соединение на Windows стоило 2 с (LB был опубликован только на `127.0.0.1`), и `make test-failover` успел сделать 8 записей вместо ~130. Исправлено публикацией и на `[::1]` (коммит `2708732`). Таблица выше — второй, полный прогон. -## Эксперименты и отказы +## Проверки, на которых ловили другие работы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +Замечания преподавателя к PR lab3 (#1–#19) и lab2 других студентов, проверенные на своём стенде: -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | +| Замечание к чужим PR | У нас | Где проверено | +| --- | --- | --- | +| после сбоя ключ остаётся «pending»: повтор висит / 504 / 409 | ключ и сообщение в одной транзакции; сбой триггером **после** вставки ключа → нет ни ключа, ни сообщения (`n_tup_ins` доказывает, что INSERT был), повтор → 201 | `test_failure_after_the_key_insert_rolls_everything_back` | +| одновременные повторы дают 19×201 + 1×409 | 24 одновременных запроса через ≥ 2 реплики, три раунда → 24×201, одно тело, 1 сообщение, 1 строка ключа | `test_concurrent_same_key_through_different_replicas_creates_exactly_one` | +| посторонний: 404, затем 409 | всегда 404, и с чужим ключом, и с другим телом | `test_outsider_and_revoked_session_never_see_the_stored_result` | +| `attachment_ids: []` при повторе → 400 | равно отсутствию поля, тот же 201; порядок ключей не важен | `test_key_order_and_missing_attachment_ids_are_the_same_body` | +| `X-Instance-Id: unknown`; нет заголовков на 500 / 413 | hostname контейнера; middleware на всех ответах, включая 500 из триггера и 413 | `Api.call` проверяет **каждый** ответ; `test_every_api_response_carries_…` | +| LB шлёт запросы неготовой реплике (pg отнят, `network disconnect`, забит пул); fallback-слоты без проверки | активная проверка `/health/ready`, без backup; реплика выходит из ротации за 3,2–4,1 с и сама возвращается | `test_lb_stops_routing_to_a_replica_that_is_alive_but_not_ready[pg_hba/network × 2 реплики]` | +| после общего restart LB видит одну реплику | re-resolve Docker DNS каждую секунду | `test_full_restart_lb_rediscovers_all_replicas` | +| «обновление» останавливает обе API; нет проверки под нагрузкой | +1 новая реплика, затем graceful stop старой; под нагрузкой 0 ошибок | [evidence/rolling-update/](evidence/rolling-update/) | +| миграции в каждой API | только `migrate`; в логах API нет миграций | `test_migrations_ran_once_by_the_migrate_service` | +| нет лимитов у LB, migrate, PostgreSQL, Redis | лимиты у всех 5 сервисов; проверены и `compose config`, и `docker inspect` запущенных | `test_compose_policy_…`, `test_running_containers_have_limits_…` | +| неидемпотентные POST повторяются LB | `retry-on conn-failure` — только неотправленные запросы | [haproxy.cfg](infra/haproxy/haproxy.cfg), DEFENSE.md | +| cursor с числом/`null`/`[]`/`{}`/`false`, пустой, пробел → 500 или 200 | 400 на обоих списках; курсор одного списка в другом → 400 | `test_malformed_cursor_values_are_400_on_both_lists`, `test_cursor_of_one_list_is_rejected_by_the_other` | +| `{"text":"first","TEXT":"second"}`, дубли ключей, `{"text":123}`, хвост после JSON, байт FF | 400, ничего не сохраняется | `test_bad_message_body_is_400_and_nothing_is_stored` | +| `Bearer é` → 500; UUID в разном регистре → 503; тело при входе игнорируется | 401; 400 (дубль после нормализации); 400 | `test_non_ascii_or_garbage_bearer_…`, `test_member_ids_are_compared_as_uuids_…`, `test_login_with_a_body_is_rejected` | +| пароль `"a"` принят, `"я:"×64` отклонён; пробельные Unicode-строки (U+00A0, U+2003) приняты; `1e1000` роняет API; 101 участник | 400 / 201; 400; 400 и API живо; 400 | `test_password_range_…`, `test_unicode_whitespace_only_strings_are_400`, `test_odd_registration_bodies_…`, `test_more_than_100_members_is_400` | +| текст обрезается по краям, длина считается после обрезки | хранится как есть; 4001 code point → 400 | `test_text_is_stored_verbatim_and_length_counts_raw_text` | +| трек 1: в «RPS» входят ошибки; неверное суммирование CPU реплик; бюджет в отчёте не совпадает с данными; на графике несопоставимые точки | считаются только 201 (`ok_messages`), dropped отдельно; CPU реплик суммируется в каждый момент; фактические лимиты из `docker inspect` в каждом raw-файле; на графике серии одной конфигурации ресурсов | [analyze.py](bench/track1/analyze.py), [run.py](bench/track1/run.py) | +| трек 1: улучшение не воспроизвелось на другом хосте | улучшение структурное (число обращений к БД на запрос, видно в `pg_stat_statements`), A/B на одном образе одной переменной | серия D | +| lab2: отозванный токен «оживает» после восстановления Redis; БД упала → 401/500 | сессии только в Valkey (нет второй копии); 503 | `test_failures.py`, `test_sessions.py` (перенесены из lab2) | + +Сам Content-Type `text/plain` даёт 400, а не 415: в OpenAPI lab3 для `POST /users` и `POST …/messages` ответ 415 не объявлен, контракт требует отклонения — оно есть. + +## Эксперименты и отказы (уровень 4) + +**Поочерёдная остановка каждой реплики** ([bench/failover_series.py](bench/failover_series.py), [series.md](evidence/failover/series.md)). Нагрузка — 4 closed-loop клиента с хоста через LB: POST сообщения (неопределённый результат → повтор тем же ключом) + GET последней страницы, таймаут клиента 3 с. Раунд: 6 с прогрева → остановка → 12 с без реплики → старт → ожидание UP в HAProxy → 6 с. Перед каждым раундом предыдущая реплика уже восстановлена. + +| Воздействие | Что ожидаем | Что наблюдали (api-1 / api-2) | Восстановление / потери | | --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +| `docker stop` (SIGTERM, drain) | 0 ошибок: реплика сама уходит из ротации до закрытия сокета | 3568 / 3565 запросов во время отказа, **0 ошибок**; цель последний раз ответила через 1,28 / 1,24 с после SIGTERM (drain) | возврат: UP через 3,3 / 1,4 с, снова обслуживает через 3,4 / 3,1 с; 0 потерь, 0 дублей | +| `docker stop -t 0` (SIGKILL) | обрываются только запросы «в полёте» на убитой реплике | 3 неудачных попытки (обрыв соединения) за ≤ 0,25 с; новые запросы сразу идут на живую (`retry-on conn-failure`) | возврат 2,8 / 3,6 с; неопределённые POST повторены тем же ключом, 0 дублей | +| `docker pause` (заморожен процесс — худший случай) | запросы на замороженную реплику ждут до таймаута, пока проверки её не выключат | 4 неудачные попытки, последняя через 3,2 / 3,1 с; ok-RPS во время отказа падает ~вдвое (часть клиентов ждёт) | после `unpause` UP через 2,2 / 1,2 с; 0 потерь, 0 дублей | +| неготовая, но живая реплика (`pg_hba reject` / `network disconnect` сети `data`) | LB исключает её по readiness, бизнес-запросы к ней не идут | DOWN через 3,2–4,1 с, затем 40 из 40 чтений и 20 из 20 регистраций — через другую реплику; live 200 / ready 503, процесс отвечает | сама UP ≤ 15 с после восстановления доступа (тест) | +| rolling update | ≥ 2 реплики в каждый момент | 57 с, 11 848 запросов, 0 ошибок, p95 53 мс | обе реплики на новой ревизии; 0 потерь, 0 дублей | +| restart всего стенда (`restart.sh`) | данные и токен на месте, LB находит новые IP сам | PASS публичного теста; новые PID у всех 5 процессов | LB видит обе реплики без своего рестарта (тест) | + +**Период проверок и максимальное время обнаружения.** HAProxy проверяет `GET /health/ready` каждую 1 с, после первой неудачи — каждые 0,5 с (`fastinter`), DOWN после 2 неудач подряд, UP после 2 удач, таймаут проверки 1 с. + +| Ситуация | Максимум до DOWN | +| --- | --- | +| реплика сразу отвечает 503 (drain после SIGTERM) | ≈ 1 + 0,5 = 1,5 с | +| ready отвечает медленно (отнят PostgreSQL/Valkey: ответ ≈ 1 с = таймаут проверки) | ≈ 1 + 1 + 0,5 + 1 = 3,5 с | +| процесс заморожен (каждая проверка ждёт таймаут) | ≈ 1 + 1 + 0,5 + 1 = 3,5 с | +| процесс убит или порт закрыт | новые запросы получают отказ соединения, HAProxy сразу отправляет их на другую реплику (`retry-on conn-failure` + `redispatch`); проверка лишь фиксирует это | + +Измерения выше в эти пределы укладываются: при drain реплика выходит из ротации за ≈ 1,2–1,3 с, а 3,2–4,1 с (отнятая БД/сеть, заморозка) включают 0,1–0,5 с опроса через `docker exec`. + +**Ограничение измерения.** Нагрузка closed-loop с хоста Windows через проброс порта Docker Desktop (~200–290 ok-RPS). Это проверка доступности и корректности, а не ёмкости — ёмкость меряет трек 1 с k6 внутри сети стенда. Неудачной попыткой считается любой не-2xx ответ или ошибка соединения/таймаут клиента. + +## Трек 1. Цена масштабирования + +Все цифры ниже — из [evidence/track1/summary.md](evidence/track1/summary.md) (генерирует [analyze.py](bench/track1/analyze.py) из `results.csv`); сырые данные каждой ступени — `evidence/track1/<серия>/<метка>/raw/*.json` (k6 summary, CPU по контейнерам, ожидание пула, счётчики PostgreSQL и HAProxy, фактические лимиты из `docker inspect`). Полный план повторяется одной командой: [bench/track1/series.sh](bench/track1/series.sh). + +### Гипотезы + +1. Один процесс Python (uvicorn, 1 воркер) исполняет байткод на одном ядре (GIL). Поэтому при фиксированном суммарном CPU одна «толстая» реплика упрётся в одно ядро, а несколько «тонких» используют весь бюджет. Дробить сильнее, чем по ядру на процесс, бесполезно. +2. Реплики API без состояния масштабируют пропускную способность линейно, пока не насытится общий ресурс — PostgreSQL (одна БД на все реплики). После этого добавление реплик не помогает, и потолок задаёт CPU БД. Если дать БД больше CPU, потолок сдвинется — это проверка причины, а не совпадения. +3. LB (HAProxy) и пул соединений не являются узким местом на этих нагрузках: HAProxy тратит единицы процентов ядра на сотни запросов/с. +4. Улучшение: основная цена запроса — накладные расходы на каждый SQL-оператор, а не сама работа БД (гипотеза из профиля). Если выполнить идемпотентную запись одним вызовом, сократятся CPU на сообщение и в API, и в PostgreSQL, и потолок вырастет в обоих режимах — и когда упираемся в API, и когда в БД. + +### Методика + +- **Стенд.** Ноутбук: AMD Ryzen 5 3400G (4 ядра / 8 потоков SMT), 30 ГБ RAM, Windows 10 22H2, Docker Desktop 29.8.0 (WSL2, ядро 6.18, 8 vCPU, 15,6 ГБ). «1 CPU» в лимитах = 1 vCPU = один аппаратный поток SMT, то есть примерно половина физического ядра. +- **Изоляция.** На время серий основной стенд остановлен. Каждая конфигурация в каждом повторе — **свежий стенд** в отдельном compose-проекте `mtusi-lab3-bench` с пустыми volumes (`down -v` → `up`), чтобы размер истории не копился между конфигурациями. Роли закреплены за своими CPU (`cpuset`, [compose.bench.yaml](bench/track1/compose.bench.yaml)): k6 — 0–1, LB + Valkey — 2, PostgreSQL — 3–4, все реплики API — 5–7. Поверх набора CPU действуют квоты `cpus` из конфигурации (API_CPUS на реплику, PG_CPUS). Генератор и LB не отнимают CPU у API. +- **Код.** Образ API собирается из **коммита** (`git archive | docker build`), а не из рабочей копии: базовые серии A–C — коммит `3f45eb1` (до улучшения), серии D–E — `4830be4` (с улучшением, старый путь доступен через `MESSAGE_WRITE_PATH=multi`). Фактический образ и лимиты записаны в каждом raw-файле. +- **Нагрузка.** k6 2.3.0 в отдельном контейнере в сети `edge` идёт через LB, как внешний клиент, без проброса портов Windows. Open-loop `constant-arrival-rate`: итерации стартуют с заданной частотой независимо от ответов, поэтому нет coordinated omission. Итерации, которым не хватило VU, считаются в `dropped_iterations` как неудовлетворённый спрос. Одна итерация = `POST /chats/{id}/messages` с новым `Idempotency-Key` в один из 64 чатов (64 пользователя, у каждого свой чат), чтобы блокировка строки одного чата не доминировала. Пользователи и сессии создаются оркестратором до старта k6, файл с синтетическими токенами монтируется только для чтения и удаляется после серии. +- **Ступень:** прогрев 10 с (не учитывается) + замер 20 с. Ступени по возрастанию предложенной нагрузки, 3 повтора. Таймаут запроса 10 с. +- **Метрики.** Успешные = только ответы 201 (`ok_messages`). Ошибки и dropped — отдельно; задержки p50/p95/p99 — только успешных. CPU — `docker stats` каждые ~1–2 с, медиана за фазу замера; CPU реплик суммируется в каждый момент. Ожидание пула — счётчики psycopg-pool из лога реплик (`STATS_LOG_SECONDS=2`). PostgreSQL — `pg_stat_database` (транзакции, WAL) и `pg_stat_statements` (операторы на сообщение). HAProxy — `show stat` (переходы в DOWN, очереди). +- **Определения.** *Потолок* конфигурации — наибольший успешный RPS по ступеням в повторе, затем медиана и разброс по 3 повторам. *SLO-ёмкость* — наибольшая предложенная нагрузка, обслуженная на ≥ 97 % с p95 ≤ 500 мс. *Узкое место* — компонент, чей CPU ≥ 90 % своего лимита на ступени потолка. Для API отдельно отмечается «одно ядро на процесс», когда CPU ≈ 100 % × число реплик при большей квоте. + +### Результаты + +**A. Фиксированный суммарный CPU API = 2,0 (768 МиБ), PostgreSQL 2,0 CPU** ([график](evidence/track1/A-fixed-total/baseline/throughput.svg)): + +| Реплики × CPU | Потолок, успешных/с (мин–макс) | SLO-ёмкость | CPU API / квота | CPU БД / квота | CPU LB | Узкое место | +| --- | --- | --- | --- | --- | --- | --- | +| 1 × 2,0 | 214 (209–220) | 200 | 101 % / 200 % | 47 % / 200 % | 9 % | одно ядро на процесс (GIL) | +| 2 × 1,0 | **289** (281–291) | 250 | 198 % / 200 % | 66 % / 200 % | 14 % | CPU API | +| 4 × 0,5 | 239 (237–241) | 150 | 195 % / 200 % | 60 % / 200 % | 13 % | CPU API + флаппинг проверок | + +Гипотеза 1 подтверждена. Одна реплика с квотой 2,0 использует ~1 ядро, вторая половина квоты простаивает. Две реплики по 1,0 используют весь бюджет и дают +35 %. Четыре по 0,5 при том же бюджете хуже двух (−17 %): процесс с квотой 0,5 обрабатывает каждый запрос вдвое дольше, растёт задержка (p95 уже при 150/с — 460 мс). Кроме того, при перегрузке реплики не успевают ответить на `/health/ready` за 1 с: HAProxy выводит их из ротации — 78 переходов в DOWN за серию, до 11 % ответов 503 от LB. Дробление ниже ядра на процесс ухудшает и скорость, и стабильность. + +**B. Рост ресурсов API (1, 2, 3 реплики × 1,0 CPU) при узкой БД (PostgreSQL 0,5 CPU)** ([график](evidence/track1/B-replicas-vs-db/baseline/throughput.svg)): + +| Реплики | Потолок, успешных/с (мин–макс) | CPU API / квота | CPU БД / квота | Узкое место | Ошибки при перегрузке | +| --- | --- | --- | --- | --- | --- | +| 1 | 178 (177–180) | 94 % / 100 % | 39 % / 50 % | CPU API | до 26 % | +| 2 | **210** (208–222) | 145 % / 200 % | 49 % / 50 % | CPU PostgreSQL | до 20 % | +| 3 | 197 (197–205) | 167 % / 300 % | 49 % / 50 % | CPU PostgreSQL | до 42 % | + +Точка насыщения БД — около 200–210 успешных/с. Вторая реплика ещё помогает (+18 %), третья — нет: API простаивает (167 % из 300 %), CPU БД на квоте. При перегрузке выше этой точки запросы ждут соединения в пуле (до ~1 с), часть упирается в дедлайн 3 с (503). Readiness реплик тоже начинает отвечать дольше 1 с, и HAProxy выводит их из ротации (103 перехода в DOWN у 3 реплик). Больше реплик — больше конкурирующих соединений к той же БД и больше ошибок, а не больше пропускной способности. + +**C. Рост ресурсов БД при 3 репликах × 1,0** ([график](evidence/track1/C-db-growth/baseline/throughput.svg)): + +| CPU PostgreSQL | Потолок, успешных/с (мин–макс) | CPU API / квота | CPU БД / квота | Узкое место | +| --- | --- | --- | --- | --- | +| 0,5 (из серии B) | 197 (197–205) | 167 % / 300 % | 49 % / 50 % | PostgreSQL | +| 1,0 | **334** (316–337) | 281 % / 300 % | 94 % / 100 % | API и PostgreSQL | +| 2,0 | 347 (345–347) | 293 % / 300 % | 92 % / 200 % | CPU API | + +Гипотеза 2 подтверждена причинно. Удвоение CPU одной только БД при тех же трёх репликах поднимает потолок на 70 % — значит, в B ограничивала именно БД. Следующее удвоение даёт только +4 %: узкое место вернулось в API (293 % из 300 %), БД загружена меньше чем на половину квоты. Узкое место переходит между компонентами (API → БД → API), и масштабировать имеет смысл только тот компонент, который сейчас насыщен. + +**LB и пул (гипотеза 3).** HAProxy на всех ступенях занимает 4–24 % одного ядра. Очередь в LB появляется только на ступенях перегрузки, когда у реплики уже 200 одновременных запросов (`maxconn 200` на сервер): `qmax` 200–576 при 250–400/с, ни разу ниже потолка конфигурации. Это защита реплики, а не причина насыщения; `qmax` — максимум с момента старта стенда. Пул (10 соединений на реплику) не ограничивает сам по себе: ожидание соединения вырастает (сотни мс) только после насыщения CPU API или БД, то есть это симптом, а не причина. Под перегрузкой первым «ломается» не LB, а readiness: проверка `/health/ready` идёт через тот же пул и event loop, и под перегрузкой реплика честно сообщает «не готова». В итоге LB сбрасывает избыточную нагрузку ответами 503 — это видно в B и A (4 × 0,5). + +### Улучшение: идемпотентная запись одним вызовом + +**Диагностика.** Профиль одной реплики (2 × 1,0 CPU, 240 req/s, py-spy 20 с, [profile-baseline-3f45eb1.txt](evidence/track1/profile-baseline-3f45eb1.txt)) показал: **52,7 %** сэмплов — в драйвере psycopg, 23 % — в event loop, 9,6 % — в нашем коде, по 2–4 % — в uvicorn, redis-py, логировании, Starlette. Время делят функции, через которые проходит **каждый** оператор: ожидание ответа (`wait_async`), отправка команды, подготовка prepared statement, разбор результата. На одно сообщение старый путь делает ~15 операторов в двух транзакциях (`pg_stat_statements`): проверка членства, BEGIN, захват ключа, часы чата, вставка, COMMIT, проверки соединений пулом. + +**Изменение** (коммит `4830be4`, [0003_post_message_function.sql](migrations/0003_post_message_function.sql), [repo.py](src/messenger/repo.py)). Вся логика — та же проверка членства, тот же `INSERT … ON CONFLICT`, те же часы чата и вставка — перенесена в PL/pgSQL-функцию `post_message`. Её вызывает один оператор в autocommit, вызов и есть транзакция. Семантика не меняется: оба пути проходят одни и те же тесты идемпотентности, контракта и БД (105 тестов в режиме `multi`, весь набор — в режиме `function`). + +**A/B на одном образе одной переменной** (серия D, `MESSAGE_WRITE_PATH=multi|function`, [график](evidence/track1/D-improvement/4830be4/throughput.svg); пунктир — старый путь, сплошная — новый): + +| Конфигурация | `multi`, потолок (мин–макс) | `function`, потолок (мин–макс) | Прирост | p95 на 450/с | +| --- | --- | --- | --- | --- | +| 2 × 1,0 CPU, БД 2,0 (упор в API) | 283 (281–286) | **489** (488–491) — не насыщен на сетке до 500/с | ≥ +73 % | `multi` — перегружен; `function` — 399 мс | +| 3 × 1,0 CPU, БД 0,5 (упор в БД) | 202 (200–203) | **452** (444–462) | +124 % | `multi` — перегружен; `function` — 331 мс | + +Цена одного сообщения на ненасыщенных ступенях 200–250/с (медиана 3 повторов): + +| На одно сообщение | `multi` | `function` | Изменение | +| --- | --- | --- | --- | +| CPU API | 7,2–8,6 мс | 4,3–4,9 мс | −38…44 % | +| CPU PostgreSQL | 2,3–2,6 мс | 1,0–1,3 мс | −50…60 % | +| SQL-операторов (pg_stat_statements) | 15 | 3 | −80 % | +| транзакций в pg_stat_database (с проверками пула) | ~6 | ~3 | −50 % | +| WAL | ~1,9 КБ | ~1,9 КБ | без изменений: пишутся те же строки, durability та же | + +Профиль после изменения при тех же 240 req/s ([profile-function-4830be4.txt](evidence/track1/profile-function-4830be4.txt)): доля psycopg **19,0 %** вместо 52,7 %. Активных сэмплов реплики за те же 20 с — 2026 вместо 3889 (py-spy не считает простой), то есть −48 % CPU-времени на тот же поток запросов. + +Механизм подтверждён измерением, а не только итоговым RPS: работа с данными (WAL) не изменилась, исчезли накладные расходы на операторы. Поэтому улучшение не зависит от конкретного ноутбука. Число операторов и транзакций на сообщение — свойство кода, оно воспроизводится на любом хосте через `pg_stat_statements`. Абсолютные RPS на другом железе будут другими. + +**Потолок нового пути** (серия E, те же конфигурации, ступени 450–850/с, 3 повтора, [график](evidence/track1/E-improved-ceiling/4830be4/throughput.svg)): + +| Конфигурация | `function`, потолок (мин–макс) | CPU API / квота | CPU БД / квота | Узкое место | Итог против `multi` | +| --- | --- | --- | --- | --- | --- | +| 2 × 1,0 CPU, БД 2,0 | **552** (530–552) | 195 % / 200 % | 66 % / 200 % | CPU API | 283 → 552: **+95 %** | +| 3 × 1,0 CPU, БД 0,5 | 423 (395–440) | 177 % / 300 % | 50 % / 50 % | CPU PostgreSQL | 202 → 423–452: **+110…124 %** | + +В серии E DB-bound конфигурация начинает сразу со ступени 450 — это уже выше её потолка, поэтому её максимум здесь ниже, чем в D (452 при 450/с). Обе серии сходятся на ~420–460/с. + +После улучшения узкие места остались на своих местах, но каждый компонент делает вдвое больше полезной работы на единицу CPU. В 2 × 1,0 потолок снова задаёт CPU API (два процесса по ядру), и следующий рост — снова реплики и ядра под API. В 3 × 1,0 при БД 0,5 потолок задаёт CPU PostgreSQL: прирост реплик API за пределами точки насыщения БД по-прежнему не помогает. Улучшение сдвинуло эту точку более чем вдвое. + +### Ограничения трека + +- Один хост и SMT: 8 vCPU — это 4 физических ядра. k6, LB, БД и API разнесены по `cpuset`, но делят физические ядра попарно и общий кэш, а Windows-хост создаёт фоновый шум. Абсолютные числа годятся только для сравнения конфигураций **на этом стенде** (одинаковые ресурсы, одинаковый профиль), универсального RPS нет. +- Профиль нагрузки — только запись сообщений (новые ключи, 64 чата). Чтение истории, повторы ключей и вход (Argon2id) не нагружались. Профиль с горячим чатом (все пишут в один чат) упрётся в блокировку строки чата, а не в CPU — это отдельный эксперимент. +- Сетка ступеней шагом 50/с. Потолок известен с точностью до ступени; для `function` в 2 × 1,0 потолок в серии D не достигнут, его ищет серия E. +- CPU из `docker stats` — медиана выборок ~1–2 с. Это не точный учёт cgroup за окно. Окно замера определяется по времени выхода k6 (±1–2 с). +- Замер 20 с после прогрева 10 с на пустой БД: эффекты роста таблиц (autovacuum, раздувание индексов) не исследовались. +- py-spy с `--nonblocking` слегка замедляет профилируемую реплику, поэтому профиль показывает доли, а не абсолютный RPS. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +**Какие отказы выдерживаются (доказано на стенде):** + +- остановка, SIGKILL или заморозка **одной API-реплики** из двух: запись продолжается, подтверждённые сообщения на месте, дублей нет; +- потеря одной репликой связи с PostgreSQL/Valkey: реплика выходит из ротации, после восстановления сама возвращается; +- рестарт всего стенда с сохранением volumes: данные и прежний токен на месте, LB находит новые адреса реплик; +- поочерёдная замена реплик (rolling update) под нагрузкой — без ошибок; +- отказ PostgreSQL или Valkey целиком: ограниченные по времени 503, без анонимного доступа; после восстановления всё работает (перенесено из lab2). + +**Какие не выдерживаются (честно):** + +- **Один Docker-host** — это SPOF всего стенда: потеря хоста = потеря всего. +- **LB один.** Отказ HAProxy = недоступность API, хотя реплики живы. Нужны два LB с VIP (keepalived) или DNS/anycast. В Compose на одном хосте это не даёт реальной устойчивости. +- **PostgreSQL и Valkey не реплицированы.** Их отказ — 503 до восстановления, их диск — единственная копия данных (резервное копирование и PITR — тема трека 2 lab2, здесь не повторялось). +- **Обнаружение замороженной реплики** (`docker pause`) — до ~3,5 с. Запросы, попавшие на неё раньше, ждут клиентский таймаут: в доказательной серии — 4 неудачные попытки, последняя через 3,1–3,2 с (в предварительном прогоне — 8 попыток, последняя через 6,2 с: клиент дважды подряд попал на замороженную реплику до её выключения). HAProxy не повторяет такие запросы сам — они могли дойти до API, а неидемпотентные POST повторять нельзя. +- **Под глобальной перегрузкой** readiness всех реплик может стать 503 (проверка идёт через тот же пул и event loop), и LB отвечает 503 на всё. Это сброс нагрузки, но грубый. Следующий шаг — ограничение одновременных запросов на реплику ниже `maxconn` LB и отдельный лёгкий канал для readiness. Но рецензент требует исключать реплику с заблокированным пулом, поэтому зависимость readiness от пула сохранена сознательно. +- `X-Instance-Id` = hostname контейнера: в lab7 его нужно заменить непрозрачным alias. + +**Учебные упрощения:** HTTP без TLS (lab7), один `uvicorn`-воркер на контейнер (масштабирование — репликами), секреты — файлы Docker secrets на одном хосте, нет rate limiting. Ключи идемпотентности хранятся в PostgreSQL рядом с данными (так проще атомарность), очистка — пачками по расписанию. + +**Подтверждено измерениями:** улучшение записи сообщения (серии D и E, по 3 повтора): −80 % SQL-операторов, −40 % CPU API и −55 % CPU БД на сообщение, потолок +95 % в конфигурации с упором в API и +110…124 % с упором в БД; узкое место после улучшения — снова CPU API и CPU БД соответственно. **Пока гипотеза:** что ограничение одновременных запросов на реплику (ниже `maxconn` LB) уберёт флаппинг readiness под перегрузкой; что несколько uvicorn-воркеров в одном контейнере дадут то же, что реплики того же суммарного CPU. diff --git a/bench/failover_series.py b/bench/failover_series.py new file mode 100644 index 00000000..b4c5dafa --- /dev/null +++ b/bench/failover_series.py @@ -0,0 +1,141 @@ +#!/usr/bin/env python3 +"""Level 4: stop EACH API replica in turn under load (restoring the previous one first) and +measure RPS, errors and recovery. Modes: graceful `stop` (SIGTERM + drain), `kill` (SIGKILL) +and `pause` (frozen process: the kernel still accepts TCP, nothing answers - the worst case +for detection, only the active health check can find it). + + python bench/failover_series.py --output evidence/failover # ~5 min for 2 replicas x 3 modes + +Timeline of one round (all times from the moment the stop command is issued): + warm-up 6 s -> stop replica -> 12 s with it down -> start it again -> wait until HAProxy + has every replica UP (rejoin time) -> 6 s steady state. +Measured per round: requests/ok/failed and ok-RPS before / during / after, the last failed +request (+s), the first moment after which the stopped replica never answered again +(= removal from rotation), time until the restarted replica is UP in HAProxy and serves +traffic again, plus the history check (no confirmed message lost, no duplicate). +Output: /series.json (summary), /timeline--.csv (per second), +/series.md (table for REPORT.md). No tokens are written. +""" +from __future__ import annotations + +import argparse +import csv +import datetime as dt +import json +import platform +import subprocess +import sys +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "scripts")) +sys.path.insert(0, str(ROOT / "bench")) +import lbctl # noqa: E402 +from loadgen import Load # noqa: E402 + + +def docker(*args: str) -> str: + return subprocess.run(["docker", *args], capture_output=True, text=True, check=True, timeout=120).stdout + + +def one_round(replica: dict, mode: str, replicas: int, workers: int, out: Path) -> dict: + load = Load(workers).start() + time.sleep(6) + t_stop = load.now() + if mode == "pause": + docker("pause", replica["id"]) + else: + docker("stop", "--time", "15" if mode == "stop" else "0", replica["id"]) + t_stopped = load.now() + time.sleep(12) + t_start = load.now() + docker("unpause" if mode == "pause" else "start", replica["id"]) + lbctl.wait_up(replicas, timeout=90) + t_up = load.now() + # The restarted container keeps its hostname: wait until it serves requests again. + deadline = time.monotonic() + 30 + while time.monotonic() < deadline: + if any(e[3] == replica["hostname"] and e[0] > t_up for e in load.events): + break + time.sleep(0.1) + t_serves = load.now() + time.sleep(6) + load.stop() + t_end = load.now() + + failed_after_stop = [e for e in load.events if e[0] >= t_stop and e[2] not in (200, 201)] + served_by_target = [e[0] for e in load.events if e[3] == replica["hostname"] and t_stop <= e[0] < t_start] + out_of_rotation = (max(served_by_target) - t_stop) if served_by_target else 0.0 + rows = load.per_second() + with (out / f"timeline-{mode}-{replica['name']}.csv").open("w", newline="", encoding="utf-8") as f: + writer = csv.DictWriter(f, fieldnames=["second", "ok", "failed", "instances"]) + writer.writeheader() + for row in rows: + row = dict(row) + row["instances"] = row["instances"].replace(replica["hostname"], "TARGET") + writer.writerow(row) + state = json.loads(docker("inspect", replica["id"]))[0]["State"] + return { + "mode": mode, "replica": replica["name"], "instance_id": replica["hostname"], + "stop_command_seconds": round(t_stopped - t_stop, 2), + "before": load.window(0.5, t_stop), "during": load.window(t_stop, t_start), "after": load.window(t_serves, t_end), + "failed_after_stop": len(failed_after_stop), + "failed_statuses": sorted({e[2] for e in failed_after_stop}), + "last_failure_after_stop_s": round(max((e[0] for e in failed_after_stop), default=t_stop) - t_stop, 3), + "target_last_served_after_stop_s": round(out_of_rotation, 3), + "rejoin_up_in_lb_s": round(t_up - t_start, 2), "rejoin_serving_s": round(t_serves - t_start, 2), + "client_retries_same_key": load.retries, + "history": load.verify_history(), + "restarted_state": f"{state['Status']} health={(state.get('Health') or {}).get('Status')}", + } + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) + parser.add_argument("--output", default="evidence/failover") + parser.add_argument("--modes", default="stop,kill,pause") + parser.add_argument("--workers", type=int, default=4) + args = parser.parse_args() + out = ROOT / args.output + out.mkdir(parents=True, exist_ok=True) + replicas = sorted((r for r in lbctl.replicas() if r["state"] == "running"), key=lambda r: r["name"]) + assert len(replicas) >= 2, "need at least two running replicas" + lbctl.wait_up(len(replicas)) + results = [] + for mode in args.modes.split(","): + for replica in replicas: # each replica in turn; the previous one is already restored + print(f"== {mode} {replica['name']} ...", flush=True) + result = one_round(replica, mode, len(replicas), args.workers, out) + results.append(result) + print(json.dumps({k: result[k] for k in ("failed_after_stop", "last_failure_after_stop_s", + "target_last_served_after_stop_s", "rejoin_serving_s")}), flush=True) + meta = {"date": dt.datetime.now(dt.timezone.utc).isoformat(timespec="seconds"), + "commit": subprocess.run(["git", "rev-parse", "--short", "HEAD"], cwd=ROOT, capture_output=True, + text=True).stdout.strip(), + "host": f"{platform.system()} {platform.release()}, docker {docker('version', '--format', '{{.Server.Version}}').strip()}", + "workload": f"{args.workers} closed-loop workers from the host via 127.0.0.1:8080: POST message " + "(Idempotency-Key, uncertain -> same key) + GET last page; client timeout 3 s", + "lb": "HAProxy: check GET /health/ready inter 1s fastinter 500ms fall 2 rise 2, timeout check 1s; " + "retry-on conn-failure + redispatch", + "api": "DRAIN_SECONDS=3, SHUTDOWN_TIMEOUT_SECONDS=8, stop_grace_period 15s"} + (out / "series.json").write_text(json.dumps({"meta": meta, "rounds": results}, ensure_ascii=False, indent=2) + "\n", + encoding="utf-8") + lines = ["| Режим | Реплика | Запросов во время отказа | Ошибок после stop | ok-RPS до / во время / после | " + "Последняя ошибка, с | Цель ушла из ротации, с | Возврат в LB / обслуживает, с | Потери / дубли |", + "| --- | --- | --- | --- | --- | --- | --- | --- | --- |"] + for r in results: + h = r["history"] + lines.append(f"| {r['mode']} | {r['replica']} | {r['during']['requests']} | {r['failed_after_stop']} " + f"{r['failed_statuses'] or ''} | {r['before']['ok_rps']} / {r['during']['ok_rps']} / {r['after']['ok_rps']} | " + f"{r['last_failure_after_stop_s']} | {r['target_last_served_after_stop_s']} | " + f"{r['rejoin_up_in_lb_s']} / {r['rejoin_serving_s']} | " + f"{h['lost_confirmed']} / {h['duplicate_ids'] + h['duplicate_texts']} |") + (out / "series.md").write_text("\n".join([f"Дата {meta['date']}, commit {meta['commit']}. {meta['workload']}.", "", + *lines, ""]), encoding="utf-8") + print("\n".join(lines)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/bench/loadgen.py b/bench/loadgen.py new file mode 100644 index 00000000..97a94de8 --- /dev/null +++ b/bench/loadgen.py @@ -0,0 +1,212 @@ +#!/usr/bin/env python3 +"""Background HTTP traffic through the LB for failover / rolling-update experiments (level 4). + +Closed loop, N worker threads, each: POST a message (Idempotency-Key) + GET the last page. +An uncertain POST (timeout, connection error, 5xx) is retried with the SAME key and body, +exactly as a correct client must do; the history is checked afterwards for losses and +duplicates. Every request is recorded as (t, kind, status, instance, latency). +This is a correctness/availability probe, not a capacity benchmark (see bench/track1 for that). + + python bench/loadgen.py --duration 30 --workers 4 # prints a summary JSON +""" +from __future__ import annotations + +import argparse +import base64 +import json +import math +import os +import threading +import time +import uuid +from collections import Counter, defaultdict + +import urllib.error +import urllib.request + +BASE_URL = os.environ.get("BASE_URL", "http://127.0.0.1:8080").rstrip("/") + + +class Http: + """Minimal stdlib client with keep-alive per thread (http.client under urllib is not).""" + + def __init__(self, base_url: str, timeout: float): + import http.client + from urllib.parse import urlsplit + parts = urlsplit(base_url) + self.host, self.port = parts.hostname, parts.port or 80 + self.timeout = timeout + self.factory = lambda: http.client.HTTPConnection(self.host, self.port, timeout=self.timeout) + self.conn = self.factory() + + def request(self, method: str, path: str, body: bytes | None = None, headers: dict | None = None): + try: + self.conn.request(method, path, body=body, headers=headers or {}) + response = self.conn.getresponse() + data = response.read() + if response.getheader("connection", "").lower() == "close": + self.conn.close() + self.conn = self.factory() + return response.status, dict(response.getheaders()), data + except Exception: + self.conn.close() + self.conn = self.factory() + raise + + +def call(method: str, path: str, body=None, headers=None, timeout=10.0): + data = json.dumps(body).encode() if body is not None else None + h = {"Content-Type": "application/json", **(headers or {})} + req = urllib.request.Request(BASE_URL + path, data=data, headers=h, method=method) + try: + with urllib.request.urlopen(req, timeout=timeout) as r: + return r.status, json.loads(r.read() or b"null") + except urllib.error.HTTPError as e: + return e.code, json.loads(e.read() or b"null") + + +def make_user(label: str) -> dict: + username = f"{label}_{uuid.uuid4().hex[:12]}" + password = "Load-password-" + uuid.uuid4().hex + status, user = call("POST", "/api/v1/users", {"username": username, "display_name": label, "password": password}) + assert status == 201, (status, user) + cred = base64.b64encode(f"{username}:{password}".encode()).decode() + status, session = call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + cred}) + assert status == 201, (status, session) + return {"id": user["id"], "token": session["token"]} + + +class Load: + def __init__(self, workers: int = 4, timeout: float = 3.0, pause: float = 0.0): + self.workers = workers + self.timeout = timeout + self.pause = pause + self.alice, self.bob = make_user("load"), make_user("load") + status, chat = call("POST", "/api/v1/chats", {"title": "load", "member_ids": [self.alice["id"], self.bob["id"]]}, + headers={"Authorization": "Bearer " + self.alice["token"]}) + assert status == 201, chat + self.chat = chat + self.stop_event = threading.Event() + self.lock = threading.Lock() + self.events: list[tuple[float, str, int, str, float]] = [] + self.confirmed: dict[str, dict] = {} + self.retries = 0 + self.t0 = time.monotonic() + self.threads = [threading.Thread(target=self._worker, args=(i,), daemon=True) for i in range(workers)] + + def now(self) -> float: + return time.monotonic() - self.t0 + + def _record(self, kind: str, status: int, instance: str, latency: float) -> None: + with self.lock: + self.events.append((round(self.now(), 4), kind, status, instance, round(latency * 1000, 2))) + + def _worker(self, index: int) -> None: + http = Http(BASE_URL, self.timeout) + auth = {"Authorization": "Bearer " + self.alice["token"]} + path = f"/api/v1/chats/{self.chat['id']}/messages" + n, key = 0, uuid.uuid4().hex + text = f"w{index}-0-{key[:6]}" + while not self.stop_event.is_set(): + started = time.monotonic() + try: + status, headers, data = http.request("POST", path, json.dumps({"text": text}).encode(), + {**auth, "Idempotency-Key": key, "Content-Type": "application/json"}) + instance = headers.get("x-instance-id") or headers.get("X-Instance-Id") or "-" + except Exception: + status, instance, data = 0, "-", b"" + self._record("POST", status, instance, time.monotonic() - started) + if status == 201: + msg = json.loads(data) + with self.lock: + self.confirmed[msg["id"]] = msg + n += 1 + key = uuid.uuid4().hex + text = f"w{index}-{n}-{key[:6]}" + elif status in (0, 502, 503, 504, 500): + with self.lock: + self.retries += 1 # same key + same text on the next iteration + started = time.monotonic() + try: + status, headers, _ = http.request("GET", path + "?limit=5", None, auth) + instance = headers.get("x-instance-id") or headers.get("X-Instance-Id") or "-" + except Exception: + status, instance = 0, "-" + self._record("GET", status, instance, time.monotonic() - started) + if self.pause: + time.sleep(self.pause) + + def start(self) -> "Load": + self.t0 = time.monotonic() + for t in self.threads: + t.start() + return self + + def stop(self) -> None: + self.stop_event.set() + for t in self.threads: + t.join(timeout=15) + + def verify_history(self) -> dict: + """Walk the whole history with the second user: no confirmed message lost, no duplicate.""" + items, cursor = [], None + while True: + q = "?limit=100" + (f"&cursor={cursor}" if cursor else "") + status, page = call("GET", f"/api/v1/chats/{self.chat['id']}/messages{q}", + headers={"Authorization": "Bearer " + self.bob["token"]}, timeout=30) + assert status == 200, page + items += page["items"] + cursor = page["next_cursor"] + if not cursor: + break + ids = [m["id"] for m in items] + texts = [m["text"] for m in items] + lost = [i for i in self.confirmed if i not in set(ids)] + changed = [m for m in items if m["id"] in self.confirmed and self.confirmed[m["id"]] != m] + return {"history_messages": len(items), "confirmed_messages": len(self.confirmed), + "lost_confirmed": len(lost), "altered_confirmed": len(changed), + "duplicate_ids": len(ids) - len(set(ids)), "duplicate_texts": len(texts) - len(set(texts)), + "unconfirmed_but_stored": len(set(ids) - set(self.confirmed))} + + # ------------------------------------------------------------------ summaries + def window(self, start: float, end: float) -> dict: + ev = [e for e in self.events if start <= e[0] < end] + ok = [e for e in ev if e[2] in (200, 201)] + lat = sorted(e[4] for e in ok) + + def pct(p: float): + return lat[max(0, math.ceil(p * len(lat)) - 1)] if lat else None + span = max(end - start, 1e-9) + return {"seconds": round(span, 2), "requests": len(ev), "ok": len(ok), "failed": len(ev) - len(ok), + "ok_rps": round(len(ok) / span, 1), "error_ratio": round((len(ev) - len(ok)) / len(ev), 5) if ev else None, + "statuses": dict(Counter(e[2] for e in ev)), "instances": dict(Counter(e[3] for e in ok)), + "p50_ms": pct(.5), "p95_ms": pct(.95), "p99_ms": pct(.99)} + + def per_second(self) -> list[dict]: + buckets: dict[int, list] = defaultdict(list) + for e in self.events: + buckets[int(e[0])].append(e) + rows = [] + for second in sorted(buckets): + ev = buckets[second] + rows.append({"second": second, "ok": sum(1 for e in ev if e[2] in (200, 201)), + "failed": sum(1 for e in ev if e[2] not in (200, 201)), + "instances": "|".join(f"{k}:{v}" for k, v in sorted(Counter(e[3] for e in ev).items()))}) + return rows + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) + parser.add_argument("--duration", type=float, default=20) + parser.add_argument("--workers", type=int, default=4) + args = parser.parse_args() + load = Load(args.workers).start() + time.sleep(args.duration) + load.stop() + print(json.dumps({"total": load.window(0, load.now()), "history": load.verify_history(), + "client_retries_same_key": load.retries}, ensure_ascii=False, indent=2)) + return 0 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/bench/rolling_under_load.py b/bench/rolling_under_load.py new file mode 100644 index 00000000..c4fd9ba9 --- /dev/null +++ b/bench/rolling_under_load.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 +"""Level 4: scripts/rolling-update.sh while bench/loadgen.py traffic runs through the LB. + + python bench/rolling_under_load.py --output evidence/rolling-update + +Writes /summary.json (errors, RPS, history check, revisions before/after), +/timeline.csv (per second ok/failed/instances) and /script-output.txt. +""" +from __future__ import annotations + +import argparse +import csv +import json +import os +import subprocess +import sys +import time +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +sys.path.insert(0, str(ROOT / "scripts")) +sys.path.insert(0, str(ROOT / "bench")) +import lbctl # noqa: E402 +from loadgen import Load # noqa: E402 + + +def revisions() -> dict[str, str]: + result = {} + for r in lbctl.replicas(): + if r["state"] == "running": + label = subprocess.run(["docker", "inspect", "-f", '{{index .Config.Labels "org.opencontainers.image.revision"}}', + r["id"]], capture_output=True, text=True).stdout.strip() + result[r["name"]] = f"{r['hostname']} revision={label}" + return result + + +def main() -> int: + parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0]) + parser.add_argument("--output", default="evidence/rolling-update") + parser.add_argument("--workers", type=int, default=4) + args = parser.parse_args() + out = ROOT / args.output + out.mkdir(parents=True, exist_ok=True) + before = revisions() + load = Load(args.workers).start() + time.sleep(5) + t_begin = load.now() + bash = (os.path.join(os.environ.get("ProgramFiles", r"C:\Program Files"), "Git", "bin", "bash.exe") + if os.name == "nt" else "sh") + env = {**os.environ, "PYTHON": sys.executable} + script = subprocess.run([bash, str(ROOT / "scripts" / "rolling-update.sh")], cwd=ROOT, env=env, + capture_output=True, text=True, encoding="utf-8", timeout=900) + t_end = load.now() + time.sleep(5) + load.stop() + (out / "script-output.txt").write_text(f"$ sh scripts/rolling-update.sh (exit {script.returncode})\n" + + script.stdout + script.stderr, encoding="utf-8") + with (out / "timeline.csv").open("w", newline="", encoding="utf-8") as f: + writer = csv.DictWriter(f, fieldnames=["second", "ok", "failed", "instances"]) + writer.writeheader() + writer.writerows(load.per_second()) + summary = {"script_exit_code": script.returncode, "update_seconds": round(t_end - t_begin, 1), + "before": before, "after": revisions(), + "during_update": load.window(t_begin, t_end), "whole_run": load.window(0, load.now()), + "client_retries_same_key": load.retries, "history": load.verify_history(), + "workload": f"{args.workers} closed-loop workers: POST (Idempotency-Key) + GET page via 127.0.0.1:8080"} + (out / "summary.json").write_text(json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") + print(json.dumps({k: summary[k] for k in ("script_exit_code", "update_seconds", "before", "after", "history")}, + ensure_ascii=False, indent=2)) + print(json.dumps(summary["during_update"], ensure_ascii=False)) + return 0 if script.returncode == 0 else 1 + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/bench/track1/analyze.py b/bench/track1/analyze.py new file mode 100644 index 00000000..11a09c12 --- /dev/null +++ b/bench/track1/analyze.py @@ -0,0 +1,220 @@ +#!/usr/bin/env python3 +"""Track 1 analysis: evidence/track1//