Report the second review fixes and the new records

The header names the code and harness commits of the second review
cycle and states that every level 3 and 4 record and the clean clone
run are on e049c26. Row 4.1 now carries the detection ranges and the
SIGTERM window of the current records, the 503 answer to a request
cancelled at shutdown replaces the 500 everywhere, and the launch block
loses the manual LB wait now done by make up and gains retry-check and
storage-evidence, so the clean clone run follows it verbatim. Rows 3.4
rest on the stand reproduction of a lost answer instead of failover runs
that never failed, a new row proves the contract, public tests and task
untouched against upstream and names the CI job, and the level 4
experiments state their repeats, data volume and resource snapshots.

Track 1: errors are attributed to the replicas that returned them, with
a failure column in the pool control table; the pool control states its
fixed variant order and growing base, pool 4 is a lower bound and no
longer compared with 4x1; the write command times are call-weighted over
all statement rows; the 3 600 rps comparison names the uneven foreign
load and rests on lock waits and CPU per request; the limits name the
database sizes behind the series A peaks and what host-others.csv
covers. AGENTS.md lists retry-check and the LB wait of make up.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
This commit is contained in:
Artyom
2026-10-30 05:59:52 +03:00
co-authored by Claude Opus 5.5
parent 7f2deec511
commit 472ce5b9ea
2 changed files with 154 additions and 98 deletions
+2 -1
View File
@@ -15,13 +15,14 @@ make student-test # собственные тесты (подни
make student-test PYTEST_ARGS='-v -k drain' # выборка тестов с именами
make secrets # локальные secrets/* и .env из .env.example (не коммитятся)
make up # docker compose up -d --build --wait: postgres, valkey, migrate, api ×API_REPLICAS, lb
make up # docker compose up -d --build --wait: postgres, valkey, migrate, api ×API_REPLICAS, lb; затем ждёт все реплики UP в LB
make test # публичный smoke через LB (BASE_URL по умолчанию — docker compose port lb 8080, без стенда http://localhost:8080)
make test-persistence ACTION_SCRIPT=scripts/restart.sh # рестарт lb, api, postgres, valkey с сохранением volumes
make test-failover ACTION_SCRIPT=scripts/stop-one.sh # остановка реплики TARGET_INSTANCE_ID под запросами
make test-faults # тесты стенда лабы 2 через LB (make faults-evidence → evidence/faults.txt)
make restore # вернуть остановленные реплики и дождаться их в ротации LB
make lb-check # ≥2 X-Instance-Id на одном токене и 20 гонок одного Idempotency-Key
make retry-check # потерянный ответ (запись ждёт блокировку чата) на живой и на убитой реплике, повтор тем же ключом
make limits # уровень 4: лимиты, порты, секреты, volumes, сети против политики scripts/limits.py
make detection # уровень 4: время обнаружения SIGTERM/kill/pause/PostgreSQL против заявленного максимума
make failover-each # уровень 4: каждая реплика по очереди под k6 (RATE=100) → evidence/failover-each
+152 -97
View File
@@ -3,17 +3,19 @@
- Автор, группа: Костылев Артём, БПИ2303
- Целевая оценка: **5**; трек «5» — **трек 1 «Цена масштабирования»**
- Commit/PR: ветка `solution/bpi2303-kostylev`. Код приложения (`src/`, `compose.yaml`, `Dockerfile`, `infra/`,
хуки) последний раз менялся в `a59e3a3` — перенос исправлений лабы 2 после её ревью (цикл
`2026-10-30-carry-over-lab2-review-fixes`); до него `e924281` — удалён комментарий `# type: ignore`, `22f0e62` —
улучшение трека 1 (отправка сообщения одной командой SQL) и `107fbbb` — закрепление CPU для замеров (по умолчанию
выключено). После `22f0e62` менялись также `AGENTS.md`, `student-tests/`, обвязка (`Makefile`, последний раз —
`b1c80ee`, `scripts/`, `tools/`), openspec, отчёт и `evidence/`. **Все доказательства уровней «3» и «4»**
(`checks`, `smoke`, `stack`, `environment`, `schema`, `migrations`, `kdf`, `secrets`, `lb-check`, `hooks`,
`failover-*`, `persistence`, `faults`, `limits*`, `detection/`, `failover-each/`, `rolling*/`, `student-tests`)
сняты на итоговом коде `b1c80ee`, запуск из чистого clone — на `f5fea5c` (тот же код плюс эти доказательства),
контрольные прогоны трека — на том же коде; после `b1c80ee` менялись только openspec, отчёт и `evidence/`. Серии трека A и B сняты на
коде до улучшения (его они и обосновывают), сравнение до/после — на `edc091d` против `22f0e62`. Дата и коммит —
в первой строке каждого отчёта `evidence/*.txt`, для JSON, CSV и сырья прогонов — в индексе `evidence/README.md`. PR «ЛР 3 —
хуки) последний раз менялся в `aa1485b` и `d99a48a` — исправления второго ревью (цикл
`2026-10-30-close-lab3-second-review-gaps`: запрос, прерванный при остановке, получает `503` в формате контракта;
readiness за портом `Readiness`; событие `service.draining`); до них `a59e3a3` — перенос исправлений лабы 2 после
её ревью (цикл `2026-10-30-carry-over-lab2-review-fixes`), `e924281` — удалён комментарий `# type: ignore`,
`22f0e62` — улучшение трека 1 (отправка сообщения одной командой SQL) и `107fbbb` — закрепление CPU для замеров (по
умолчанию выключено). Обвязка (`Makefile`, `scripts/`, CI) последний раз менялась в `e049c26`. **Все доказательства
уровней «3» и «4»** (`checks`, `smoke`, `stack`, `environment`, `schema`, `migrations`, `kdf`, `secrets`,
`lb-check`, `retry`, `hooks`, `failover-*`, `persistence`, `faults`, `limits*`, `detection/`, `failover-each/`,
`rolling*/`, `student-tests`) и запуск из чистого clone сняты на итоговом коде `e049c26`; после него менялись только
`AGENTS.md`, openspec, отчёт и `evidence/`. Контрольные прогоны трека сняты на коде `b1c80ee`: после него код
менялся только в остановке, readiness и журнале, путь записи и пул те же. Серии трека A и B сняты на коде до
улучшения (его они и обосновывают), сравнение до/после — на `edc091d` против `22f0e62`. Дата и коммит — в первой
строке каждого отчёта `evidence/*.txt`, для JSON, CSV и сырья прогонов — в индексе `evidence/README.md`. PR «ЛР 3 —
БПИ2303 — Костылев — на 5» в репозиторий преподавателя заполняется по `.github/pull_request_template.md`; его
ссылка появляется при публикации
- Использованные источники, библиотеки и помощь ИИ: FastAPI, gunicorn + uvicorn-worker, dishka, pydantic,
@@ -35,25 +37,28 @@ git clone <repo> && cd mtusi2026lab3 && git checkout solution/bpi2303-kostylev
make secrets # secrets/*: пароли PostgreSQL и Valkey, DATABASE_URL, CACHE_URL, ключ курсора; .env из .env.example
docker compose --env-file .env config --quiet
make up # docker compose up -d --build --wait: postgres, valkey → migrate (миграции, один раз) → api ×2 → lb
until curl -fsS "http://$(docker compose port lb 8080)/health/ready"; do sleep 1; done # готовность через LB
scripts/lb-wait.sh 2 # обе реплики UP в статистике LB
make up # docker compose up -d --build --wait: postgres, valkey → migrate (миграции, один раз) → api ×2 → lb,
# затем scripts/lb-wait.sh: ждёт, пока статистика LB покажет UP у всех запущенных реплик
make test # публичный smoke через балансировщик (BASE_URL — опубликованный порт lb, см. ниже)
make lb-check # ≥2 X-Instance-Id на одном токене и 20 × 8 параллельных POST с одним ключом → evidence/lb-check.json
make retry-check # потерянный ответ на живой и на убитой реплике, повтор тем же ключом → evidence/retry.json
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make restore # вернуть остановленную реплику и дождаться её в ротации LB
curl -s -o /dev/null "http://$(docker compose port lb 8080)/health/live" # сдвиг round robin: следующий прогон остановит другую реплику
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && make restore
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make migrate # повторный запуск миграций: «up to date», данные не меняются
make storage-evidence # \d+ схемы, повтор миграций, префикс KDF, правила ignore и volumes проекта → evidence/
make down # безопасная остановка: контейнеры и сети удаляются, volumes с данными остаются
make reset-data # НАМЕРЕННОЕ удаление учебных данных: docker compose down -v --remove-orphans
```
`make secrets` идемпотентен: существующие файлы не перезаписываются, значения нигде не печатаются; `make up`
вызывает его сам. `make up` ждёт `healthy` всех сервисов, включая балансировщик, а он здоров, только когда в
ротации есть реплика (`/healthz` на порту статистики). Миграции применяет одноразовый `migrate` под advisory lock
вызывает его сам. `make up` ждёт `healthy` всех сервисов, включая балансировщик (он здоров, когда в ротации есть хотя
бы одна реплика, `/healthz` на порту статистики), а затем — пока в ротацию войдут все реплики: вторая входит после
`rise 2` проверок, примерно через 2,5 с, и без этого ожидания `make test-failover` сразу после `make up` мог увидеть
один `X-Instance-Id`. Миграции применяет одноразовый `migrate` под advisory lock
до старта реплик; реплики схему не трогают. Публикуются только порты `lb` на `127.0.0.1`: `LB_HTTP_PORT`
(по умолчанию 8080) и `LB_STATS_PORT` (8404, статистика только для чтения). На машине, где выполнялась работа,
параллельно работали стенды других лаб, поэтому в локальном `.env` стояли `LB_HTTP_PORT=18083`,
@@ -63,14 +68,16 @@ make reset-data # НАМЕРЕННОЕ удаление учебных да
прогон сразу после первого попадает в ту же реплику, поэтому перед ним нужен один запрос через LB (строка
`curl …/health/live` выше или `make failover-evidence SHIFT=1`).
Последний прогон из свежего clone (`evidence/clean-clone.txt`, коммит `f5fea5c` — код `b1c80ee`, каталог `mtusi2026lab3-clean` —
свой compose-проект и пустые volumes, `LB_HTTP_PORT=18083`, команды дословно из блока выше, **без `BASE_URL`**):
`config` — `valid`; `make up` — 10 с, `migrate` применил `0001_init` и `0002_idempotency_keys` и вышел с кодом 0;
smoke `PASS`; 40 `GET` одним токеном — 20 + 20 на две реплики, 160 × `201` в гонках ключа; failover обеих реплик
по очереди (второй — после одного `GET` через LB) — 134 и 132 записи, 0 ошибок, первая запись через 2.934 и 2.736 с,
остановлены `api-1`, затем `api-2`, каждая `Exited (0)`; persistence `PASS`; повторный `migrate` — `up to date`;
`make storage-evidence` в клоне перечислил только volumes `mtusi2026lab3-clean_*`; после `make down` volumes
остались, после `make reset-data` их 0.
Последний прогон из свежего clone (`evidence/clean-clone.txt`, коммит `e049c26`, каталог `mtusi2026lab3-clean` —
свой compose-проект и пустые volumes, `LB_HTTP_PORT=18083`, **без `BASE_URL`**). Шаги — команды блока выше дословно,
кроме правки портов в `.env`; между шагами — наблюдения (`docker compose ps`, статистика LB, `docker volume ls`),
помеченные в файле. `config --quiet` — код 0; `make up` — 10 с вместе с ожиданием реплик, статистика LB сразу после —
`api1 UP`, `api2 UP`; `migrate` применил `0001_init` и `0002_idempotency_keys` и вышел с кодом 0; smoke `PASS`;
`lb-check` — 20 + 20 `GET` на две реплики, 160 × `201` в гонках ключа; `retry-check` — оба варианта `pass`; failover
обеих реплик по очереди (второй — после одного `GET` через LB) — по 135 записей, 0 ошибок, первая запись через 2.911
и 2.572 с, остановлены `api-2` (`Exited (0)`), затем `api-1` (её поднял следующий `make restore`); persistence
`PASS`; повторный `migrate` — `up to date`; `make storage-evidence` — код 0, volumes проекта только
`mtusi2026lab3-clean_*`; после `make down` volumes остались, после `make reset-data` их 0.
Собственные проверки и тулчейн:
@@ -142,7 +149,9 @@ advisory lock, тесты стенда (`make test-faults`). Уже в лабе
`2026-10-30-carry-over-lab2-review-fixes` (`a59e3a3`): предел тела считает фактически принятые байты
(`chunked` сверх 1 MiB → `413`), выход отзывает сессию через порт `SessionRevocations` и снимает отметку отзыва,
если PostgreSQL отверг удаление (`503` значит «сессия ещё действует»), пустой `cursor` → `400`, зоны связаны только
схемой БД, воркер сам прерывает зависший при остановке запрос (`500`) до `SIGKILL` мастера.
схемой БД, воркер сам прерывает зависший при остановке запрос до `SIGKILL` мастера. После второго ревью этот ответ —
`503 unavailable` в формате контракта (был `text/plain 500` uvicorn без `X-Request-Id` и `X-Instance-Id`), readiness
стоит за портом `Readiness`, а окно вывода пишется событием `service.draining` (цикл `2026-10-30-close-lab3-second-review-gaps`).
**`X-Instance-Id`.** `PlatformSettings.instance_id` по умолчанию — `socket.gethostname()`; Docker даёт
контейнеру hostname, равный короткому ID, поэтому значение одно на все воркеры реплики, стабильно на жизнь
@@ -194,16 +203,19 @@ SHA-256 канонического JSON распарсенной модели,
**Остановка и процессы (уровень «4»).** По `SIGTERM` реплика сначала выходит из ротации и только потом
перестаёт принимать соединения. Каждый воркер запускает `DrainingServer` (наследник `uvicorn.Server`,
`src/messenger/gunicorn_conf.py`): после сигнала он поднимает флаг, `/health/ready` отвечает `503`, `/health/live`
— `200`, запросы обслуживаются как обычно, и так `DRAIN_SECONDS=2` — дольше худшего обнаружения `503`
`src/messenger/gunicorn_conf.py`): после сигнала он поднимает флаг процесса `DRAINING`
(`shared/infrastructure/readiness.py`) и пишет `service.draining`; адаптер `DatabaseReadiness` за портом `Readiness`
проверяет флаг до пинга PostgreSQL, поэтому `/health/ready` отвечает `503`, `/health/live` — `200`, запросы обслуживаются как обычно, и так `DRAIN_SECONDS=2` — дольше худшего обнаружения `503`
балансировщиком (1,5 с). Затем uvicorn закрывает listener и дообрабатывает принятые запросы ещё
`SHUTDOWN_TIMEOUT_SECONDS − DRAIN_SECONDS − 1` = 3 с (не меньше таймаутов БД 1 + 2 с), а запрос, не завершённый
к этому сроку, прерывает сам с `500` и выходит с кодом 0; весь срок — ≤5 с < gunicorn `graceful_timeout` 6 с <
`SHUTDOWN_TIMEOUT_SECONDS − DRAIN_SECONDS − 1` = 3 с (не меньше таймаутов БД 1 + 2 с), а задачу запроса, не
завершённого к этому сроку, отменяет и выходит с кодом 0. Отмену ловит конвейер: пишет `request.cancelled` и, если
ответ ещё не начат, отвечает `503 unavailable` в общем формате с `X-Request-Id` и `X-Instance-Id`, затем пробрасывает
отмену дальше (без этого uvicorn отвечал своим `text/plain 500` без заголовков контракта); весь срок — ≤5 с < gunicorn `graceful_timeout` 6 с <
`docker stop -t 7` хука < `stop_grace_period: 8s` < 10 с, поэтому мастер gunicorn не доходит до `SIGKILL` воркера. Без окна (уровень «3») gunicorn закрывал listener сразу, и запрос, уже
стоявший в очереди `accept`, LB видел как обрыв после отправки: для `GET` и сообщений с ключом это повтор, для
`POST /users`, `/chats` и входа — `502`. Разница видна в счётчиках LB: rolling update со старой версии —
`wredis` 55 (запросы, перенаправленные на соседа), с новой — все 0 (`evidence/rolling*/result.json`). Хук
`stop-one.sh` теперь идёт 2,63 с (`evidence/hooks.txt`). На реплику `cpus: 1`, `512m`, 2 воркера, пул 8: 2 × 2 × 8 = 32 соединения <
`wredis` 56 (запросы, перенаправленные на соседа), с новой — все 0 (`evidence/rolling*/result.json`). Хук
`stop-one.sh` теперь идёт 2,66 с (`evidence/hooks.txt`). На реплику `cpus: 1`, `512m`, 2 воркера, пул 8: 2 × 2 × 8 = 32 соединения <
`max_connections=200`. API работает `read_only` с `tmpfs /tmp`.
**Проверки, период и максимум обнаружения.** `GET /health/ready` раз в `inter 1s`; после первого провала —
@@ -217,17 +229,17 @@ gunicorn — первый прогон `failover-each` показал `wredis` 1
| Отказ | Как замечает LB | Максимум обнаружения | Замер (`make detection`) |
| --- | --- | --- | --- |
| `SIGTERM` (`docker stop`, `stop-one.sh`) | readiness `503` в окне вывода | `inter + (fall−1)·fastinter` = 1,5 с, и раньше закрытия порта (2 с) | 0,99–1,43 с; действие (`docker stop -t 7`) завершилось через 2,53–2,61 с |
| процесс убит (`docker kill`) | отказ соединения, DNS | 1,5 с | 0,47–0,54 с |
| процесс завис (`docker pause`) | таймаут проверки | `inter + (fall−1)·fastinter + fall·timeout check` = 3,5 с | 2,91–3,23 с |
| PostgreSQL остановлен | readiness всех реплик `503` | 1,5 с до 0 `UP`; LB сам отвечает `503` | 0,93–1,44 с; `/health/live` через LB → `503 unavailable` без `X-Instance-Id` |
| `SIGTERM` (`docker stop`, `stop-one.sh`) | readiness `503` в окне вывода | `inter + (fall−1)·fastinter` = 1,5 с, и раньше закрытия порта (2 с) | 1,26–1,35 с; действие (`docker stop -t 7`) завершилось через 2,47–2,56 с |
| процесс убит (`docker kill`) | отказ соединения, DNS | 1,5 с | 0,42–0,53 с |
| процесс завис (`docker pause`) | таймаут проверки | `inter + (fall−1)·fastinter + fall·timeout check` = 3,5 с | 2,93–3,06 с |
| PostgreSQL остановлен | readiness всех реплик `503` | 1,5 с до 0 `UP`; LB сам отвечает `503` | 1,26–1,27 с; `/health/live` через LB → `503 unavailable` без `X-Instance-Id` |
Замер — три прогона `make detection` подряд (`evidence/detection/run{1,2,3}/`), в таблице диапазон. Время
считается от запуска команды отказа, поэтому замер включает задержку docker CLI до сигнала и период опроса
статистики LB (50 мс) и может превысить формулу на эту величину: допуск замера — 0,25 с. На итоговом коде все 12
замеров уложились в формулу без допуска (в `faults.txt` остановка PostgreSQL — 0,93 с); раньше допуск
замеров уложились в формулу без допуска (в `faults.txt` остановка PostgreSQL — 1,04 с); раньше допуск
понадобился: на `a02d442` у PostgreSQL в двух прогонах из трёх (1,553 и 1,551 с), при ревью — у `SIGTERM` (1,609 с),
на `e00eb6c` — у `SIGTERM` в `failover-each` (1,515 с). Возврат в ротацию после восстановления — 1,96–3,63 с.
на `e00eb6c` — у `SIGTERM` в `failover-each` (1,515 с). Возврат в ротацию после восстановления — 2,35–3,56 с.
**Цепочка таймаутов** (проверяется тестом `student-tests/unit/test_timeouts.py` по `compose.yaml`,
`haproxy.cfg` и `scripts/stop-one.sh`, а не только таблицей):
@@ -239,7 +251,7 @@ gunicorn — первый прогон `failover-each` показал `wredis` 1
| `DB_ACQUIRE_TIMEOUT_SECONDS` + `DB_COMMAND_TIMEOUT_SECONDS` (`statement_timeout` = `lock_timeout`) | 1 + 2 с | ≤ дообработки после окна |
| LB `timeout check` | 1 с | > readiness 0,8 с |
| `DRAIN_SECONDS` | 2 с | > обнаружения 1,5 с |
| дообработка после окна (uvicorn `timeout_graceful_shutdown`) | `SHUTDOWN − DRAIN − 1` = 3 с | ≥ таймаутов БД 1 + 2 с; затем зависший запрос → `500` |
| дообработка после окна (uvicorn `timeout_graceful_shutdown`) | `SHUTDOWN − DRAIN − 1` = 3 с | ≥ таймаутов БД 1 + 2 с; затем зависший запрос → `503 unavailable` |
| `SHUTDOWN_TIMEOUT_SECONDS` (gunicorn `graceful_timeout`) | 6 с | > окна + дообработки; < `STOP_TIMEOUT` хука |
| `STOP_TIMEOUT` хука `stop-one.sh` | 7 с | < `stop_grace_period` 8 с < 10 с |
| LB `timeout connect` / `queue` | 0,5 с / 3 с | отказ соединения повторяется на соседа сразу |
@@ -299,20 +311,21 @@ postgres 2/1g, valkey 0.5/128m, k6 2/512m (`make limits` сверяет их и
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | `make test` | `PASS: lab3 public API scenario` (включая replay == first, `409` на другой body, `400` без ключа, `X-Instance-Id` на каждом ответе); на итоговом коде — тоже `PASS` | `evidence/smoke.txt`, `evidence/clean-clone.txt`, `evidence/track1/after-checks.txt` |
| Офлайн-контракт, OpenAPI и тулчейн | `make check`; `make validate`; `make lint` | `PASS: offline skeleton structure, local refs and Python syntax`; `PASS: full OpenAPI 3.1 and JSON Schema validation`; ruff `All checks passed!`, 103 files already formatted, ty `All checks passed!` | `evidence/checks.txt` |
| Запуск из чистого clone | `git clone`, `make secrets`, `config --quiet`, `make up`, ожидание `/health/ready`, тесты, `make migrate`, `make down`, `make reset-data` | `valid`; `make up` 10 с, `migrate` применил `0001`/`0002` и `Exited (0)`; smoke, failover обеих реплик, persistence `PASS` без явного `BASE_URL` при `LB_HTTP_PORT=18083`; повтор миграций `up to date`; после `down` 2 volume, после `reset-data` 0 | `evidence/clean-clone.txt` |
| Офлайн-контракт, OpenAPI и тулчейн | `make check`; `make validate`; `make lint` | `PASS: offline skeleton structure, local refs and Python syntax`; `PASS: full OpenAPI 3.1 and JSON Schema validation`; ruff `All checks passed!`, 104 files already formatted, ty `All checks passed!` | `evidence/checks.txt` |
| Контракт, публичные тесты и задание не изменены; собственный CI | `git diff --stat upstream/main -- contracts tests README.md COURSE.md lab.json MAINTAINERS.md`; `git diff --stat upstream/main -- .github` | первый вывод пуст; во втором — только добавленный `.github/workflows/application.yml` (+82), шаблон PR не изменён. Job `quality` — `make lint`, `make student-test`; job `acceptance` — стенд из clone (`make up`), smoke, `lb-check`, `retry-check`, failover с `docker compose ps -a`, persistence, `test-faults`, `limits`, `detection`, порты только у `lb`, числовой uid процессов ≠ 0 (`docker top -eo pid,uid,comm`), остановка реплик по `SIGTERM` ≤10 с с кодом 0 (запускается в GitHub Actions при публикации) | `evidence/checks.txt`, `.github/workflows/application.yml` |
| Запуск из чистого clone | команды блока «Запуск» дословно: `git clone`, `make secrets`, `config --quiet`, `make up`, `make test`, `make lb-check`, `make retry-check`, failover ×2 с `restore`, persistence, `make migrate`, `make storage-evidence`, `make down`, `make reset-data` | `config` — код 0; `make up` 10 с с ожиданием обеих реплик в LB, `migrate` применил `0001`/`0002` и `Exited (0)`; smoke, `lb-check`, `retry-check`, failover обеих реплик, persistence `PASS` без явного `BASE_URL` при `LB_HTTP_PORT=18083`; повтор миграций `up to date`; после `down` 2 volume, после `reset-data` 0 | `evidence/clean-clone.txt` |
| **3.1** Весь стенд в `compose.yaml`, ≥2 API, одна точка входа, общая БД и общее хранилище сессий | `make stack-evidence` (`config --quiet`, `ps`, `docker port` реплик, `docker inspect`, статистика LB) | 2 контейнера `api` без портов (`docker port` пуст), порты только у `lb` на `127.0.0.1`; `container_name` 0; LB видит `api1 UP L7OK 200`, `api2 UP L7OK 200`; один `postgres`, один `valkey` | `evidence/stack.txt` |
| **3.2** Разные запросы одного пользователя — разные реплики без повторного входа, видно по `X-Instance-Id` | `make lb-check` (40 × `GET /users/me` одним токеном, новые соединения) + `docker inspect` | `{"286766bf2b32": 20, "fa81adafcb69": 20}` — ровно hostname двух контейнеров `api`; из чистого clone — тоже 20 + 20 | `evidence/lb-check.json`, `evidence/stack.txt`, `evidence/clean-clone.txt` |
| **3.3** Остановка любой одной реплики: ≤10 с, данные доступны, ошибки измерены | `make failover-evidence` → `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, `docker inspect` до/после, `restore`; затем `make failover-evidence SHIFT=1` — один `GET /health/live` через LB перед тестом сдвигает round robin на другую реплику | реплика `286766bf2b32`: первая запись после хука через 2.639 с от его старта, 139 записей, 0 ошибок; реплика `fa81adafcb69` (прогон с `SHIFT=1`): 2.747 с, 138, 0; после теста `exited` именно target, вторая `running`; в логе остановленной — сигнал, окно вывода из ротации с readiness `503`, закрытие и выход; `PASS: failover …` | `evidence/failover-286766bf2b32.txt`, `evidence/failover-fa81adafcb69.txt` |
| **3.3** Хук останавливает только заданную реплику | `scripts/stop-one.sh` с hostname, с неизвестным ID и без него | хук 2.63 с (окно вывода 2 с + остановка), код 0, target `exited exit_code=0`, вторая `running`; неизвестный ID → код 3, всё работает; без переменной → код 1 | `evidence/hooks.txt` |
| **3.4** Повтор с тем же ключом не создаёт дубль; конкурентный повтор и смена реплики | `make lb-check` (20 раундов × 8 параллельных POST с одним ключом через LB); `PYTEST_ADDOPTS=-vv make student-test`; failover-тест (после ошибки — тот же ключ и текст) | 160 × `201` от обеих реплик (80 + 80); в каждом из 20 раундов тела равны, в истории 1 копия, другой body → `409`; `test_replay_returns_the_same_message`, `test_same_json_in_other_layout_is_a_replay`, `test_other_body_with_same_key_conflicts`, `test_concurrent_retries_through_two_replicas_store_one_message` (8 повторов через два экземпляра приложения → одна строка ключа) — `PASSED` | `evidence/lb-check.json`, `evidence/student-tests.txt`, `evidence/failover-*.txt` |
| **3.4** Неподтверждённую запись можно безопасно повторить | `PYTEST_ADDOPTS=-vv make student-test`; failover-тест сверяет историю байт-в-байт | `test_rejected_attempt_does_not_take_the_key` (`4xx` не занимает ключ), `test_expired_key_starts_over`, `test_replay_checks_session_and_access_again` — `PASSED`; в истории после отказа нет дублей `id`/`text` | `evidence/student-tests.txt`, `evidence/failover-*.txt` |
| **3.2** Разные запросы одного пользователя — разные реплики без повторного входа, видно по `X-Instance-Id` | `make lb-check` (40 × `GET /users/me` одним токеном, новые соединения) + `docker inspect` | `{"fe75c6c37e5a": 20, "ff81f93e8b0d": 20}` — ровно hostname двух контейнеров `api`; из чистого clone — тоже 20 + 20 | `evidence/lb-check.json`, `evidence/stack.txt`, `evidence/clean-clone.txt` |
| **3.3** Остановка любой одной реплики: ≤10 с, данные доступны, ошибки измерены | `make failover-evidence` → `make test-failover ACTION_SCRIPT=scripts/stop-one.sh`, `docker inspect` до/после, `restore`; затем `make failover-evidence SHIFT=1` — один `GET /health/live` через LB перед тестом сдвигает round robin на другую реплику | реплика `ff81f93e8b0d`: первая запись после хука через 2.858 с от его старта, 132 записи, 0 ошибок; реплика `fe75c6c37e5a` (прогон с `SHIFT=1`): 2.682 с, 136, 0; после теста `exited` именно target, вторая `running`; в логе остановленной — сигнал, `service.draining` обоих воркеров (окно вывода из ротации), readiness `503`, закрытие и выход; `PASS: failover …` | `evidence/failover-ff81f93e8b0d.txt`, `evidence/failover-fe75c6c37e5a.txt` |
| **3.3** Хук останавливает только заданную реплику | `scripts/stop-one.sh` с hostname, с неизвестным ID и без него | хук 2.66 с (окно вывода 2 с + остановка), код 0, target `exited exit_code=0`, вторая `running`; неизвестный ID → код 3, всё работает; без переменной → код 1 | `evidence/hooks.txt` |
| **3.4** Повтор с тем же ключом не создаёт дубль; конкурентный повтор и смена реплики | `make lb-check` (20 раундов × 8 параллельных POST с одним ключом через LB); `make retry-check` (повтор потерянной записи через другую реплику); `PYTEST_ADDOPTS=-vv make student-test` | 160 × `201` от обеих реплик (80 + 80); в каждом из 20 раундов тела равны, в истории 1 копия, другой body → `409`; в `retry-check` оба повтора обслужила не та реплика, что приняла первую попытку, — 1 копия с тем же `id`; `test_replay_returns_the_same_message`, `test_same_json_in_other_layout_is_a_replay`, `test_other_body_with_same_key_conflicts`, `test_concurrent_retries_through_two_replicas_store_one_message` (8 повторов через два экземпляра приложения → одна строка ключа) — `PASSED` | `evidence/lb-check.json`, `evidence/retry.json`, `evidence/student-tests.txt` |
| **3.4** Неподтверждённую запись можно безопасно повторить | `make retry-check`: `psql` держит `SELECT … FOR UPDATE` строки чата 1,5 с (меньше `lock_timeout` 2 с), запрос с ключом и таймаутом клиента 0,5 с ждёт блокировку и остаётся без ответа, затем повтор с тем же ключом и текстом через LB; вариант «kill» — реплику, чей запрос ждёт (по `client_addr` в `pg_stat_activity`), убивают `docker kill`; `PYTEST_ADDOPTS=-vv make student-test` | «таймаут»: первая попытка без ответа, реплика `fe75c6c37e5a` сама ответила на неё `201` (её журнал), повтор через 1,522 с от `ff81f93e8b0d` — `201` с первой попытки, в истории 1 копия с тем же `id`, записала её первая попытка (`created_at` раньше повтора); «kill»: `ff81f93e8b0d` убита, пока её запрос ждал, повтор от `fe75c6c37e5a` — `201`, 1 копия с тем же `id`, и её тоже записала потерянная попытка — PostgreSQL доработал команду ушедшего клиента; `pass: true`. Failover-тесты такого повтора не дают: во всех прогонах 0 неудачных попыток. In-process: `test_rejected_attempt_does_not_take_the_key` (`4xx` не занимает ключ), `test_expired_key_starts_over`, `test_replay_checks_session_and_access_again` — `PASSED` | `evidence/retry.json`, `evidence/student-tests.txt` |
| **3.5** `make test`, persistence и failover проходят; ≥2 наблюдаемых реплики | `make test`, `make persistence-evidence`, `make test-failover …` | smoke `PASS`; persistence `PASS`, `StartedAt` у `lb`, обеих `api`, `postgres`, `valkey`, `migrate` после теста новее, ID контейнеров те же; failover `observed_instances_before: 2`; на итоговом коде — то же | `evidence/smoke.txt`, `evidence/persistence.txt`, `evidence/failover-*.txt`, `evidence/clean-clone.txt` |
| Перенос lab2: схема PK/FK/UNIQUE и миграции с нуля, повтор без дублей | чистый clone (`make up` на пустом volume); `make storage-evidence` | `0001_init`, `0002_idempotency_keys` применены на пустом volume; `\d+` всех таблиц; повтор `up to date`, счётчики строк до и после равны (сообщений столько же, сколько ключей: 160 и 160) | `evidence/clean-clone.txt`, `evidence/schema.txt`, `evidence/migrations.txt` |
| Перенос lab2: схема PK/FK/UNIQUE и миграции с нуля, повтор без дублей | чистый clone (`make up` на пустом volume); `make storage-evidence` | `0001_init`, `0002_idempotency_keys` применены на пустом volume; `\d+` всех таблиц; повтор `up to date`, счётчики строк до и после равны (сообщений столько же, сколько ключей: 30 748 и 30 748) | `evidence/clean-clone.txt`, `evidence/schema.txt`, `evidence/migrations.txt` |
| Перенос lab2: Basic только на `/auth/sessions`, Bearer, logout, `X-User-Id` игнорируется | `make test`; `PYTEST_ADDOPTS=-vv make student-test`; `make test-faults` | smoke `PASS`; тесты `test_sessions.py`, `test_authentication.py`, `test_negative.py` — `PASSED`; logout `204` → `401` → `401` через LB | `evidence/smoke.txt`, `evidence/student-tests.txt`, `evidence/faults.txt` |
| Перенос lab2: password KDF | `make storage-evidence` | `$argon2id$v=19$m=19456,t=2,p=1$` у всех 28 пользователей; в `sessions` только 32-байтовые SHA-256 | `evidence/kdf.txt` |
| Перенос lab2: password KDF | `make storage-evidence` | `$argon2id$v=19$m=19456,t=2,p=1$` у всех 120 пользователей; в `sessions` (114) только 32-байтовые SHA-256 | `evidence/kdf.txt` |
| Перенос lab2: секреты и volumes вне Git | `git ls-files secrets .env`; `git check-ignore -v …`; в чистом clone `git status --ignored` | пусто; пути игнорируются; в clone `secrets/` и `.env` — `!!` (ignored) | `evidence/secrets.txt`, `evidence/clean-clone.txt` |
| Перенос lab2: отказы Valkey и PostgreSQL через LB | `make test-faults` (`BASE_URL` — порт `lb`) | 12 passed: гонка регистрации 201×1/409×49, чат с несуществующим участником `400`, остановка Valkey (выход `503`, затем `204`) и PostgreSQL (`503` за ≤0.014 с; live внутри реплики `200`; LB исключил обе реплики ещё через 0.93 с и сам отвечает `503`; готовность через 2.3 с), рестарт API (готовность 2.6 с), полный рестарт с выходом `204` → `401`, срок сессии после рестарта не продлевается | `evidence/faults.txt` |
| Перенос lab2: отказы Valkey и PostgreSQL через LB | `make test-faults` (`BASE_URL` — порт `lb`) | 12 passed: гонка регистрации 201×1/409×49, чат с несуществующим участником `400`, остановка Valkey (выход `503`, затем `204`) и PostgreSQL (`503` за ≤0.014 с; live внутри реплики `200`; LB исключил обе реплики ещё через 1.04 с и сам отвечает `503`; готовность через 2.1 с), рестарт API (готовность 2.3 с), полный рестарт с выходом `204` → `401`, срок сессии после рестарта не продлевается | `evidence/faults.txt` |
| `X-Instance-Id` на каждом ответе приложения | `PYTEST_ADDOPTS=-vv make student-test` (`test_instance.py`) | `test_every_response_names_the_replica` (`200`, `401`, `404`, скрытый `405` как `404`, `400`, `204`), `test_rejected_body_names_the_replica` (`413`), `test_unhandled_error_names_the_replica` (`500`), `test_replica_defaults_to_container_hostname` — `PASSED` | `evidence/student-tests.txt`, `student-tests/api/test_instance.py` |
| Непривилегированные процессы | `make stack-evidence`; снимок окружения | api — uid 10001, lb — 99 (`haproxy`), postgres — 70, valkey — 999 | `evidence/stack.txt`, `evidence/environment.txt` |
@@ -324,13 +337,13 @@ postgres 2/1g, valkey 0.5/128m, k6 2/512m (`make limits` сверяет их и
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| **4.1** Health/readiness, таймауты и прекращение приёма при `SIGTERM` согласованы | `make student-test` (`test_timeouts.py`, `test_drain.py`, вывод `-s`) | цепочка: LB server 10 с > запрос 8 с > БД 3 с; readiness 0,8 с < check 1 с; окно 2 с > обнаружение 1,5 с; дообработка 3 с ≥ БД 3 с; остановка 6 с < хук 7 с < `stop_grace_period` 8 с; настоящий gunicorn по `SIGTERM` (в тесте окно 1 с, срок 3 с): ready/live `(503, 200)` в окне, порт закрыт через 1.18 с, запрос, принятый до сигнала и дописанный после закрытия порта, получил `201`, запрос, тело которого так и не пришло, прерван с `500`, выход через 2.62 с | `evidence/student-tests.txt`, `compose.yaml`, `infra/haproxy/haproxy.cfg`, `src/messenger/gunicorn_conf.py` |
| **4.1** LB исключает недоступный backend; период проверок и максимум обнаружения | `make detection` (три прогона) | период 1 с (0,5 с после провала), `fall 2`/`rise 2`; заявлено ≤1,5 с (`503`/отказ соединения) и ≤3,5 с (зависание), допуск замера 0,25 с; измерено (min–max трёх прогонов): `SIGTERM` 1.004–1.325 с — раньше конца остановки (2.446–2.634 с), `kill` 0.218–0.757 с, `pause` 3.013–3.045 с, PostgreSQL 1.269–1.553 с до 0 `UP` и `503 unavailable` от LB; возврат 1.92–3.04 с; все 12 `pass: true` | `evidence/detection/run{1,2,3}/{sigterm,kill,pause,postgres}.json` |
| **4.2** Последовательно остановить каждую реплику (с восстановлением предыдущей); RPS, ошибки, время восстановления | `make failover-each` (на реплику: `stop-one.sh`, `docker compose ps -a` реплик, 10 с без неё, `restore.sh` — всё внутри окна нагрузки) | `286766bf2b32`: 100.0 rps, 6000 запросов k6, ошибок 0, p50/p95/p99 2.04/6.56/13.68 мс, обнаружение 0.926 с, возврат в ротацию через 14.932 с от начала действия (действие 15.23 с: хук + 10 с + restore), зонд 655 попыток / 0 ошибок, пока реплика исключена, её `X-Instance-Id` не встречался (128 ответов только от `fa81adafcb69`); `fa81adafcb69`: 100.02 rps, 6001, 0 ошибок, 2.10/6.46/14.16 мс, 1.065 с, 14.587 с, 655/0; в `action.txt` сразу после хука — `Exited (0)` у остановленной и `Up (healthy)` у второй; счётчики LB `wretr`/`wredis`/`econ`/`eresp`/`hrsp_5xx` — 0. Обнаружение ≤1,5 с без допуска (на `e00eb6c` было 1.515 с — в пределах допуска замера 0,25 с на docker CLI и опрос, см. `make detection`) | `evidence/failover-each/summary.json`, `evidence/failover-each/<hostname>/` |
| **4.1** Health/readiness, таймауты и прекращение приёма при `SIGTERM` согласованы | `make student-test` (`test_timeouts.py`, `test_drain.py`, вывод `-s`) | цепочка: LB server 10 с > запрос 8 с > БД 3 с; readiness 0,8 с < check 1 с; окно 2 с > обнаружение 1,5 с; дообработка 3 с ≥ БД 3 с; остановка 6 с < хук 7 с < `stop_grace_period` 8 с; настоящий gunicorn по `SIGTERM` (в тесте окно 1 с, срок 3 с): ready/live `(503, 200)` в окне, порт закрыт через 1.17 с, запрос, принятый до сигнала и дописанный после закрытия порта, получил `201`, запрос, тело которого так и не пришло, прерван ответом `503 unavailable` в общем формате (`application/json`, `request_id` = `X-Request-Id`, есть `X-Instance-Id`), выход через 2.43 с | `evidence/student-tests.txt`, `compose.yaml`, `infra/haproxy/haproxy.cfg`, `src/messenger/gunicorn_conf.py` |
| **4.1** LB исключает недоступный backend; период проверок и максимум обнаружения | `make detection` (три прогона) | период 1 с (0,5 с после провала), `fall 2`/`rise 2`; заявлено ≤1,5 с (`503`/отказ соединения) и ≤3,5 с (зависание), допуск замера 0,25 с; измерено (min–max трёх прогонов): `SIGTERM` 1.259–1.348 с — раньше конца остановки (2.471–2.555 с), `kill` 0.420–0.526 с, `pause` 2.926–3.063 с, PostgreSQL 1.263–1.266 с до 0 `UP` и `503 unavailable` от LB; возврат 2.347–3.555 с; все 12 `pass: true`, все в пределах формулы без допуска | `evidence/detection/run{1,2,3}/{sigterm,kill,pause,postgres}.json` |
| **4.2** Последовательно остановить каждую реплику (с восстановлением предыдущей); RPS, ошибки, время восстановления | `make failover-each` (на реплику: `stop-one.sh`, `docker compose ps -a` реплик, 10 с без неё, `restore.sh` — всё внутри окна нагрузки) | `ff81f93e8b0d`: 100.02 rps, 6001 запрос k6, ошибок 0, p50/p95/p99 1.60/3.92/7.31 мс, обнаружение 1.405 с, возврат в ротацию через 14.834 с от начала действия (действие 15.296 с: хук + 10 с + restore), зонд 646 попыток / 0 ошибок, пока реплика исключена, её `X-Instance-Id` не встречался (121 ответ только от `fe75c6c37e5a`); `fe75c6c37e5a`: 100.02 rps, 6001, 0 ошибок, 1.57/3.62/6.24 мс, 0.859 с, 14.343 с, 646/0; в `action.txt` сразу после хука — `Exited (0)` у остановленной и `Up (healthy)` у второй, затем снимок без остановленной реплики: база 9,7 и 12,9 МБ (2 759 и 9 053 сообщения по `n_live_tup`), оставшаяся реплика 12,8 и 22,8 % CPU, 126 и 142 МиБ из 512, PostgreSQL ≈4 % и 49–55 МиБ; счётчики LB `wretr`/`wredis`/`econ`/`eresp`/`hrsp_5xx` — 0. Обнаружение ≤1,5 с без допуска (на `e00eb6c` было 1.515 с — в пределах допуска замера 0,25 с на docker CLI и опрос, см. `make detection`). Один прогон на реплику: критерий бинарный (0 ошибок), а остановки повторены в failover-тестах (`failover-*.txt`, `clean-clone.txt`) и `make test-faults` — неудачных записей нет ни в одном | `evidence/failover-each/summary.json`, `evidence/failover-each/<hostname>/` |
| **4.2** Общая идемпотентность — параллельными запросами с одним ключом | `make lb-check` | 20 раундов × 8: 160 × `201` от двух реплик, 20/20 раундов с одинаковыми телами, одной копией и `409` на другой body; на итоговом коде — то же | `evidence/lb-check.json`, `evidence/clean-clone.txt`, `evidence/track1/after-checks.txt` |
| **4.3** CPU/RAM-лимиты, API без портов в обход LB, секреты и хранилища только где нужно, нет `container_name` | `make limits` (`docker compose --profile bench config` + `docker inspect` против политики в `scripts/limits.py`) на итоговом коде | лимиты у всех 6 сервисов (api 1/512MiB, lb 1/128MiB, postgres 2/1024MiB, valkey 0.5/128MiB, migrate 0.5/256MiB, k6 2/512MiB) и применены у запущенных; порты только у `lb` на `127.0.0.1`; секреты: api — 3, migrate — `database_url`, postgres — пароль, valkey — конфиг, lb и k6 — нет; volumes `pgdata`/`valkeydata` только у своих хранилищ; `backend` internal, k6 только в `edge`; api и lb `read_only`; `PASS`. Подмешанные нарушения (порт и лишний секрет у api, `container_name`, снятый лимит) → 5 нарушений, код 1 | `evidence/limits.txt`, `evidence/limits-violations.txt` |
| **4.4** Rolling update под нагрузкой | `make rolling-update FROM_REV=8d28d45` (стенд на образе уровня «3» с тегом `mtusi-messenger:8d28d45`, затем замена на текущую версию с запасом +1) | `lb_up_min` 2 из 2, k6 100 rps, 8996 запросов, ошибок 0 (5 итераций k6 сброшены), зонд 934/0; после замены отвечают только новые контейнеры (`e2d392075b96`, `bc58bf60e518` → `c84bddf582a8`, `225f56282b82`; образ `84c47c47ad8a` → `cb0dac56ff0b`); старые реплики без окна дали `wredis` 55 — запросы, перенаправленные LB на соседа | `evidence/rolling-from-8d28d45/result.json`, `action.txt` |
| **4.4** То же на текущей версии | `make rolling-update` | `lb_up_min` 2, 9001 запрос, ошибок 0, зонд 942/0, все реплики новые (`c84bddf582a8`, `225f56282b82` → `89953d9764bd`, `1f35898d8b4e`); все счётчики LB 0. Образ пересобран из той же ревизии, ID другой (`cb0dac56ff0b` → `c23101d9a13d`): BuildKit пишет при сборке новый манифест с аттестацией (`exporting attestation manifest` в `clean-clone.txt`) — это эквивалентная поочерёдная замена | `evidence/rolling/result.json`, `action.txt` |
| **4.4** Rolling update под нагрузкой | `make rolling-update FROM_REV=8d28d45` (стенд на образе уровня «3» с тегом `mtusi-messenger:8d28d45`, затем замена на текущую версию с запасом +1) | `lb_up_min` 2 из 2, k6 100 rps, 8996 запросов, ошибок 0 (5 итераций k6 сброшены), зонд 913/0; после замены отвечают только новые контейнеры (`3e741644dba4`, `3e62ff0322c6` → `6c2a02267340`, `158dfc1bd95d`; в `action.txt` у каждой замены — тег и ID образа: `mtusi-messenger:8d28d45@75eeba4b5bfd` → `mtusi-messenger:mtusi2026lab3@c69a721bc974`); база 16 МБ / 15 139 сообщений, реплики по 20 % CPU и 145 МиБ; старые реплики без окна дали `wredis` 56 — запросы, перенаправленные LB на соседа | `evidence/rolling-from-8d28d45/result.json`, `action.txt` |
| **4.4** То же на текущей версии | `make rolling-update` | `lb_up_min` 2, 9001 запрос, ошибок 0, зонд 919/0, все реплики новые (`6c2a02267340`, `158dfc1bd95d` → `c2f5d82dee7c`, `65d10d346f4e`); все счётчики LB 0. Образ пересобран из той же ревизии, тег тот же, ID другой (`mtusi-messenger:mtusi2026lab3@c69a721bc974` → `@021faac1e94a`): BuildKit пишет при сборке новый манифест с аттестацией (`exporting attestation manifest` в выводе сборки `clean-clone.txt`) — это эквивалентная поочерёдная замена | `evidence/rolling/result.json`, `action.txt` |
| **4.4** Миграции однократно и совместимы с работающей версией | `scripts/rolling-update.sh`; `make storage-evidence` | `migrate` запускается один раз до замены первой реплики (`migration.completed up to date`), реплики схему не трогают, `migrate` под `pg_advisory_lock`; между уровнями «3» и «4» схема не менялась; `0002_idempotency_keys` только добавляет таблицу, код лабы 2 её не замечает | `evidence/rolling*/action.txt`, `evidence/migrations.txt` |
**Трек 1 «Цена масштабирования».** Подробности, таблицы и выводы — в разделе трека ниже; поля CSV —
@@ -341,34 +354,41 @@ postgres 2/1g, valkey 0.5/128m, k6 2/512m (`make limits` сверяет их и
| Гипотеза и повторяемая методика | `openspec/changes/archive/2026-10-29-add-lab3-scaling-cost/proposal.md` (коммит `d8d551a`); `make track1` | гипотезы H1–H3 записаны в предложении до первого прогона серий; серии, сравнение и графики — одной командой; снимок хоста и версий | `evidence/track1/host.txt`, `evidence/track1/README.md` |
| 1/2/4 реплики при фиксированном суммарном CPU/RAM | `make track1-a` (4 CPU / 2 GiB, воркеров = CPU, пул 32 и очередь LB 128 во всех вариантах, CPU 7–10 закреплены) | пик успешных RPS: 1×4 — 5 375, 2×2 — 4 964, 4×1 — 4 724; потолок по SLO у всех 4 560 rps, но p95 там 9 / 69 / 150 мс | `evidence/track1/series-a/summary.csv`, `plots/series-a-*.png`, `plots/capacity.md` |
| Серия с ростом ресурсов | `make track1-b` (1→2→4→8 реплик по 1 CPU) | пик 1 720 → 2 936 → 4 724 → **4 260**: восемь реплик хуже четырёх; USL σ = 0,014, κ = 0,038, максимум около 5 реплик | `evidence/track1/series-b/summary.csv`, `plots/scaling.png`, `plots/capacity.md` |
| Saturation point БД/LB/пула и почему реплики перестают помогать | метрики каждого прогона: `docker stats`, HAProxy CSV, `pg_stat_activity`, `pg_stat_statements` | на 8×1: API 473 из 800 %, LB 40 % ядра, PostgreSQL 178 из 200 %, **47,5 из 64 соединений ждут блокировку строки чата**, 6,8 — `idle in transaction`, `SELECT … FOR UPDATE` чата — ≈14,1 мс в среднем (13,6–14,4) и 98,7 % времени топ-20 операторов. Контроль (`make track1-control`, 3 повтора): `maxconn` LB 16/32/64 — пик 4 526 / 4 677 / 4 525 rps, интервалы перекрываются (LB не ограничивает); пул 4/8/16 на воркер — 5 358 / 4 677 / 3 789 rps при 14,7 / 47 / 102 ждущих блокировку (пул не мал, а лишние соединения только добавляют конкурентов); 8×0,5 на CPU 4×1 — пик 5 525 против 5 928 (число процессов, а не другие ядра) | `evidence/track1/series-b/summary.csv`, `series-b/base-8x1_rate5400_rep*/pg_statements.csv`, `plots/utilisation.png`, `track1/control-{pool,cpus}/summary.csv`, `plots/capacity.md` |
| Saturation point БД/LB/пула и почему реплики перестают помогать | метрики каждого прогона: `docker stats`, HAProxy CSV, `pg_stat_activity`, `pg_stat_statements` | на 8×1: API 473 из 800 %, LB 40 % ядра, PostgreSQL 178 из 200 %, **47,5 из 64 соединений ждут блокировку строки чата**, 6,8 — `idle in transaction`, `SELECT … FOR UPDATE` чата — ≈14,1 мс в среднем (13,6–14,4) и 98,7 % времени топ-20 операторов. Контроль (`make track1-control`, 3 повтора): `maxconn` LB 16/32/64 — пик 4 526 / 4 677 / 4 525 rps, интервалы перекрываются (LB не ограничивает); пул 4/8/16 на воркер — ≥5 358 (пул 4 при предложенных 5 400 rps в двух повторах из трёх не насыщен) / 4 677 / 3 789 rps при 14,7 / 47 / 102 ждущих блокировку (пул не мал, а лишние соединения только добавляют конкурентов); 8×0,5 на CPU 4×1 — пик 5 525 против 5 928 (число процессов, а не другие ядра) | `evidence/track1/series-b/summary.csv`, `series-b/base-8x1_rate5400_rep*/pg_statements.csv`, `plots/utilisation.png`, `track1/control-{pool,cpus}/summary.csv`, `plots/capacity.md` |
| Графики и сырые данные | `make plots` | RPS и p95/p99 от нагрузки, CPU по компонентам, пик от CPU с USL, загрузка звеньев на пике, сводка потолков; сырьё каждого прогона — k6, `docker stats`, HAProxy CSV, `pg_stat_activity`, `pg_stat_statements` | `evidence/track1/plots/`, `evidence/track1/<серия>/<прогон>/` |
| Одно подтверждённое улучшение (до/после при тех же ресурсах) | `make track1-compare` (8×1, образ `edc091d` против текущего, чередование по повторам) | запись сообщения одной командой: при 3 600 rps p95 64,5 → 3,7 мс, CPU на запрос API −14 %, PostgreSQL −26 %; пик 4 252 → 4 894 rps (+15 %), интервалы повторов не пересекаются | `evidence/track1/compare/summary.csv`, `plots/compare-*.png` |
| Улучшение не ломает уровни «3» и «4» | сразу после улучшения: `make student-test`, `make test`, 20 гонок ключа, `make test-failover`, `make test-persistence`; на итоговом коде `b1c80ee` — весь уровень «3», `make test-faults` и `make level4` под k6 | после улучшения: 240 passed, smoke `PASS`, 160 × `201`, failover 131 запись / 0 ошибок, persistence `PASS`; на итоговом коде — 243 passed, 12 тестов стенда и все строки 3.x и 4.x выше (`detection` ×3, `failover-each`, оба rolling update — 0 ошибок под 100 rps), чистый clone | `evidence/track1/after-checks.txt`, `evidence/clean-clone.txt`, файлы строк 3.x–4.x |
| Одно подтверждённое улучшение (до/после при тех же ресурсах) | `make track1-compare` (8×1, образ `edc091d` против текущего, чередование по повторам) | запись сообщения одной командой: при 3 600 rps ждут блокировку 12,8 → 0,15 соединения, `idle in transaction` 4,5 → 0, CPU на запрос API −14 %, PostgreSQL −26 %, p95 64,5 → 3,7 мс (у «до» больше чужой нагрузки на VM; в повторе 1 при равной — 35,7 → 5,4 мс); пик 4 252 → 4 894 rps (+15 %), интервалы повторов не пересекаются | `evidence/track1/compare/summary.csv`, `plots/compare-*.png` |
| Улучшение не ломает уровни «3» и «4» | сразу после улучшения: `make student-test`, `make test`, 20 гонок ключа, `make test-failover`, `make test-persistence`; на итоговом коде `e049c26` — весь уровень «3», `make retry-check`, `make test-faults` и `make level4` под k6 | после улучшения: 240 passed, smoke `PASS`, 160 × `201`, failover 131 запись / 0 ошибок, persistence `PASS`; на итоговом коде — 243 passed, 12 тестов стенда, `retry-check` и все строки 3.x и 4.x выше (`detection` ×3, `failover-each`, оба rolling update — 0 ошибок под 100 rps), чистый clone | `evidence/track1/after-checks.txt`, `evidence/clean-clone.txt`, файлы строк 3.x–4.x |
## Эксперименты и отказы
Стенд: 2 реплики × (1 CPU, 512 MiB, 2 воркера), PostgreSQL 2 CPU / 1 GiB, HAProxy 1 CPU / 128 MiB, Valkey
0.5 CPU / 128 MiB, k6 2 CPU / 512 MiB; Docker Desktop на Apple M4 Max. Нагрузка в failover-тесте — один клиент,
`POST` каждые 0.1 с в течение 15 с, таймаут 2 с, повтор после ошибки с тем же ключом; в строках уровня «4» —
k6 100 rps плюс зонд (см. выше). Данные синтетические: каждый прогон создаёт своих пользователей и чаты.
k6 100 rps плюс зонд (см. выше). Данные синтетические: каждый прогон создаёт своих пользователей и чаты; стенд
перед записью доказательств очищен (`make reset-data`), к rolling update база выросла до 16–21 МБ и 15–24 тыс.
сообщений, а к концу всех прогонов в ней 120 пользователей и 30 748 сообщений (`migrations.txt`). Размер базы и
`docker stats` стенда во время действия — в `action.txt` прогонов `failover-each` и `rolling*`. Повторы: `detection` —
три прогона на вид отказа, остальные сценарии — по одному: критерий у них бинарный (0 ошибок, одна копия), а
остановка реплики под записью повторена ещё четыре раза (`failover-*.txt` и два прогона в `clean-clone.txt`) и в
`make test-faults`, всегда без неудачных записей.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| stop api#1 (`stop-one.sh`, `286766bf2b32`) | запись продолжается ≤10 с, target больше не отвечает | 0 неудачных попыток, 139 записей; после теста `286766bf2b32` `exited`, `fa81adafcb69` `running` (`failover-286766bf2b32.txt`) | первая запись после хука через 2.639 с от его старта (хук ≈2,6 с из-за окна вывода; запись не прерывалась); потерь и дублей нет |
| stop api#2 (после `restore` и одного запроса через LB — `SHIFT=1`, `fa81adafcb69`) | то же для второй реплики | 0 неудачных попыток, 138 записей; `fa81adafcb69` `exited` (`failover-fa81adafcb69.txt`) | 2.747 с; потерь и дублей нет |
| Полный restart (`restart.sh`: lb, api ×2, postgres, valkey) | прежний токен работает, история побайтно та же | persistence `PASS`; ID контейнеров прежние, `StartedAt` всех обновился: postgres, valkey, lb — 23:44:29, api — 23:44:30–31 при старте прогона в 23:44:25 (`persistence.txt`) | потерь нет; в чистом clone — то же (`clean-clone.txt`) |
| stop api#1 (`stop-one.sh`, `ff81f93e8b0d`) | запись продолжается ≤10 с, target больше не отвечает | 0 неудачных попыток, 132 записи; после теста `ff81f93e8b0d` `exited`, `fe75c6c37e5a` `running` (`failover-ff81f93e8b0d.txt`) | первая запись после хука через 2.858 с от его старта (хук ≈2,7 с из-за окна вывода; запись не прерывалась); потерь и дублей нет |
| stop api#2 (после `restore` и одного запроса через LB — `SHIFT=1`, `fe75c6c37e5a`) | то же для второй реплики | 0 неудачных попыток, 136 записей; `fe75c6c37e5a` `exited` (`failover-fe75c6c37e5a.txt`) | 2.682 с; потерь и дублей нет |
| Полный restart (`restart.sh`: lb, api ×2, postgres, valkey) | прежний токен работает, история побайтно та же | persistence `PASS`; ID контейнеров прежние, `StartedAt` всех обновился: postgres и valkey — 02:45:49, lb — 02:45:50, api — 02:45:51 при старте прогона в 02:45:46 (`persistence.txt`) | потерь нет; в чистом clone — то же (`clean-clone.txt`) |
| Конкурентный одинаковый ключ (20 раундов × 8 POST через LB) | в каждом раунде одно сообщение, все ответы равны | 160 × `201`, 80 + 80 по репликам, 20/20 раундов с 1 копией, другой body → `409` (`lb-check.json`) | дублей нет |
| Потерянный ответ: запись ждёт блокировку строки чата 1,5 с, клиент сдаётся через 0,5 с и повторяет тот же ключ через LB (`make retry-check`) | повтор `201` с тем же `Message`, одна копия | реплика жива: она сама ответила на первую попытку `201`, повтор через 1,52 с от другой реплики — тот же `id`; реплику убили, пока запрос ждал: повтор от соседа — тот же `id`, сообщение записала первая попытка (`retry.json`) | дублей и потерь нет; повтор прошёл с первой попытки |
| Все реплики остановлены | LB отвечает `503` в формате контракта | `503 {"error":{"code":"unavailable",…,"request_id":"no-replica-1"}}` (`hooks.txt`) | после `make restore` — `200` |
| `docker compose stop postgres` | реплики выходят из ротации, ответы `503`, а не `500` | `503` за ≤0.014 с на ready, me, login, register; live внутри реплики `200`; LB исключил обе реплики через 0.93 с (`faults.txt`) и 0.93–1.44 с (`detection/run*/postgres.json`) и отвечает `503` сам | после `start` готовность через 2.3 с без рестарта API; в ротации через 2.48–2.65 с |
| `docker compose stop postgres` | реплики выходят из ротации, ответы `503`, а не `500` | `503` за ≤0.014 с на ready, me, login, register; live внутри реплики `200`; LB исключил обе реплики через 1.04 с (`faults.txt`) и 1.26–1.27 с (`detection/run*/postgres.json`) и отвечает `503` сам | после `start` готовность через 2.1 с без рестарта API; в ротации через 2.42–2.48 с |
| `docker compose stop valkey` | проверка сессий через PostgreSQL, без анонимного доступа | действующий токен `200`, неизвестный `401`, выход `503` (`faults.txt`) | после `start` выход `204` |
| Повторный `migrate` | схема и данные не меняются | `up to date`, счётчики равны (`migrations.txt`, `clean-clone.txt`) | — |
| `SIGTERM` реплике (`docker stop -t 7`) | LB исключает её раньше, чем она закроет порт | исключена через 0.99–1.43 с, остановка завершилась через 2.53–2.61 с (`detection/run*/sigterm.json`); код выхода 0, в логе — окно 2 с и readiness `503` (`hooks.txt`, `failover-*.txt`) | возврат после `restore` 1.96–3.63 с |
| Процесс реплики убит (`docker kill`) | исключение ≤1,5 с | 0.47–0.54 с (`detection/run*/kill.json`) | `restore` 2.65–3.05 с |
| Процесс реплики завис (`docker pause`) | исключение ≤3,5 с по таймауту проверки | 2.91–3.23 с; через LB — `200` от соседа (`detection/run*/pause.json`) | после `unpause` 2.37–2.86 с |
| Поочерёдная остановка каждой реплики под 100 rps | 0 ошибок, запись не прерывается, реплика возвращается | обе реплики: k6 0 ошибок из 6000 и 6001, зонд 0 из 655 и 655, p99 13.7 и 14.2 мс, повторов LB 0 (`failover-each/summary.json`) | обнаружение 0.93–1.07 с; снова в ротации через 14.59–14.93 с от начала действия (хук + 10 с без реплики + `restore`) |
| Rolling update с уровня «3» под 100 rps | ёмкость не ниже 2, 0 ошибок, после — только новые реплики | `lb_up_min` 2, 0 ошибок из 8996, зонд 0 из 934; старые реплики без окна: `wredis` 55 | замена двух реплик за 7.062 с |
| Rolling update текущей версии под 100 rps | то же, и без повторов LB | `lb_up_min` 2, 0 ошибок из 9001, зонд 0 из 942, все счётчики LB 0 | 12.010 с |
| `SIGTERM` реплике (`docker stop -t 7`) | LB исключает её раньше, чем она закроет порт | исключена через 1.26–1.35 с, остановка завершилась через 2.47–2.56 с (`detection/run*/sigterm.json`); код выхода 0 (`hooks.txt`), в логе — `service.draining` (окно 2 с) и readiness `503` (`failover-*.txt`) | возврат после `restore` 2.51–3.56 с |
| Процесс реплики убит (`docker kill`) | исключение ≤1,5 с | 0.42–0.53 с (`detection/run*/kill.json`) | `restore` 2.99–3.04 с |
| Процесс реплики завис (`docker pause`) | исключение ≤3,5 с по таймауту проверки | 2.93–3.06 с; через LB — `200` от соседа (`detection/run*/pause.json`) | после `unpause` 2.35–2.37 с |
| Поочерёдная остановка каждой реплики под 100 rps | 0 ошибок, запись не прерывается, реплика возвращается | обе реплики: k6 0 ошибок из 6001 и 6001, зонд 0 из 646 и 646, p99 7.3 и 6.2 мс, повторов LB 0 (`failover-each/summary.json`) | обнаружение 0.86–1.41 с; снова в ротации через 14.34–14.83 с от начала действия (хук + 10 с без реплики + `restore`) |
| Rolling update с уровня «3» под 100 rps | ёмкость не ниже 2, 0 ошибок, после — только новые реплики | `lb_up_min` 2, 0 ошибок из 8996, зонд 0 из 913; старые реплики без окна: `wredis` 56 | замена двух реплик за 7.451 с |
| Rolling update текущей версии под 100 rps | то же, и без повторов LB | `lb_up_min` 2, 0 ошибок из 9001, зонд 0 из 919, все счётчики LB 0 | 12.620 с |
### Трек 5 — трек 1 «Цена масштабирования»
@@ -401,7 +421,10 @@ H3: мера против найденного узкого места даёт
(15 + 12), 3,8 млн.
- Набор данных: перед каждой конфигурацией `down -v`, затем база растёт от прогона к прогону; размер в каждой
строке (`db_mb`, `messages` — перед прогоном): 7,7 МБ в начале конфигурации, до 1 019 МБ и 2,1 млн сообщений
перед последним прогоном серии A, 497 МБ и 1,0 млн — серии B, 1,77 ГБ и 3,7 млн — сравнения.
перед последним прогоном серии A, 497 МБ и 1,0 млн — серии B, 1,77 ГБ и 3,7 млн — сравнения. Пики серии A
(6 830 rps) сняты на базе 0,58–0,74 ГБ у 1×4, 0,58–0,87 ГБ у 2×2 и 0,87–1,02 ГБ у 4×1, точка 8×1 серии B при
5 400 rps — на 0,17–0,31 ГБ. В контроле пула база между вариантами не очищалась и выросла с 7,7 МБ до 2,26 ГБ
за 15 прогонов; в контроле размещения у каждой конфигурации своя свежая база, до 0,40 ГБ.
- Насыщение шага: ошибок > 1 %, сброшенных итераций > 1 % или p95 > 500 мс; интенсивность насыщена, если
насыщено большинство повторов. Потолок по SLO — наибольшая ненасыщенная интенсивность (грубо, шаг ×1,5),
пик — наибольшая медиана успешных RPS (в открытой модели при перегрузке это и есть пропускная способность).
@@ -434,10 +457,16 @@ rps):
| 4×1 (из A) | 4 560 | 4 724 (4 686–4 794) | 2,75 | 69 % | 381 / 400 | 164 | 40 | 15,3 / 6,8 / 32 | 872 |
| 8×1 | ≥3 600 (первая точка сетки) | **4 260** (4 217–4 424) | 2,48 | 31 % | 473 / 800 | 178 | 40 | **47,5** / 6,8 / 64 | 744 |
Ошибок нет ни в одном прогоне таблиц (доля неуспешных ≤ 0,02 %): перегрузка проявляется как очередь в LB
(до 1 000 одновременных сессий — предел VU k6), рост задержки и сброшенные итерации, а не как `5xx`, — таймауты
`lock_timeout` 2 с и `timeout queue` 3 с не достигались. Генератор нагрузки не был узким местом: k6 ≤ 84 % из
300 %, Valkey ≤ 12 % ядра. Память: API 116–374 МиБ на контейнер, PostgreSQL до 661 МиБ, k6 до 675 МиБ.
Перегрузка проявляется как очередь в LB (до 1 000 одновременных сессий — предел VU k6), рост задержки и
сброшенные итерации, а не как ошибки: доля неуспешных во всех прогонах таблиц ≤ 0,02 %, `timeout queue` LB (3 с) не
достигался — у LB `econ`, `eresp` и `wretr` равны 0, а единичные `5xx` отдали сами реплики (`hrsp_5xx` серверов в
`lb_stats.csv`, проваленные проверки k6). В сериях это один прогон: 1×4 при 600 rps, повтор 2 — 3 ответа из 16 883
во время короткой остановки записи (p99 645 мс, до 17 соединений ждут блокировку, `dropped_iterations` 1 117), ещё 18 —
в прогреве повтора 3, вне окна замера. Код ответа (`500` или `503`) сырьё LB не различает; вероятнее всего это
`503` по таймауту ожидания соединения из пула (1 с): самые долгие запросы этого прогона шли до 1,5 с. В контроле
такие ответы были только у пула 16 (таблица ниже). Генератор нагрузки не был узким
местом: k6 ≤ 84 % из 300 %, Valkey ≤ 12 % ядра. Память: API 116–374 МиБ на контейнер, PostgreSQL до 661 МиБ, k6 до
675 МиБ.
USL по пикам серии B (N = 1, 2, 4, 8 CPU): σ = 0,014 (последовательная доля), κ = 0,038 (стоимость
согласования), максимум при N* = √((1−σ)/κ) ≈ 5 реплик, дальше — спад (`plots/scaling.png`, `plots/capacity.md`).
@@ -458,23 +487,34 @@ event loop у держателей, а последовательная част
при 3 040 rps; 1,1–1,2 у 8×1 против 0,6–0,8 у 1×1), память — тоже (367 МиБ одной репликой против 4 × 133 =
532 МиБ четырьмя).
**Контрольные прогоны** (`make track1-control`, итоговый код `b1c80ee`; меняется один ресурс при прочих равных,
варианты чередуются по повторам, 3 повтора, `*` — прогон остался `disturbed` после трёх повторов). Первая часть —
8×1 при 5 400 rps (за коленом) с пулом 4/8/16 соединений на воркер и очередью LB `maxconn` 16/32/64 на реплику:
**Контрольные прогоны** (`make track1-control`, код `b1c80ee`; меняется один ресурс при прочих равных, 3 повтора,
`*` — прогон остался `disturbed` после трёх повторов). Первая часть — 8×1 при 5 400 rps (за коленом) с пулом 4/8/16
соединений на воркер и очередью LB `maxconn` 16/32/64 на реплику. Варианты чередуются по повторам, но в одном и том же
порядке (пул 4 → 8 → 16 → `maxconn` 16 → 64), и база между ними не очищается: 7,7 МБ перед первым прогоном, 2,26 ГБ
перед последним, поэтому каждый следующий вариант повтора идёт на базе больше предыдущего. Вывод от этого не зависит:
в повторе 3 при почти одинаковой базе (1,96–2,26 ГБ) порядок тот же — 5 394 / 4 966 / 4 077 rps у пула 4 / 8 / 16, а пул 4
в повторах 1 и 3 даёт 5 358 и 5 394 rps на базе 7,7 МБ и 1,96 ГБ:
| Вариант 8×1 | Успешные RPS, медиана (min–max) | p95, мс | Ждут блокировку / соединений с БД | Очередь LB, max | CPU API / PostgreSQL, % |
| --- | ---: | ---: | ---: | ---: | ---: |
| пул 4 | **5 358** (5 316–5 394) | 179 | 14,7 / 32 | 739 | 517 / 163 |
| пул 8, `maxconn` 32 (как в серии B) | 4 677 (3 749*–4 966) | 273 | 47,0 / 64 | 744 | 471 / 170 |
| пул 16 | 3 789 (2 291*–4 077) | 355 | 102,3 / 128 | 744 | 372 / 180 |
| `maxconn` 16 | 4 526 (3 776*–4 917) | 258 | 47,3 / 64 | 872 | 424 / 177 |
| `maxconn` 64 | 4 525 (4 005*–4 908) | 299 | 46,8 / 64 | 487 | 442 / 178 |
| Вариант 8×1 | Успешные RPS, медиана (min–max) | p95, мс | Ждут блокировку / соединений с БД | Очередь LB, max | CPU API / PostgreSQL, % | Неуспешные запросы по повторам |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| пул 4 | **≥5 358** (5 316–5 394), не насыщен в 2 из 3 | 179 | 14,7 / 32 | 739 | 517 / 163 | 0 / 0 / 0 |
| пул 8, `maxconn` 32 (как в серии B) | 4 677 (3 749*–4 966) | 273 | 47,0 / 64 | 744 | 471 / 170 | 0 / 0 / 0 |
| пул 16 | 3 789 (2 291*–4 077) | 355 | 102,3 / 128 | 744 | 372 / 180 | 1* / 5 / 3 |
| `maxconn` 16 | 4 526 (3 776*–4 917) | 258 | 47,3 / 64 | 872 | 424 / 177 | 0 / 0 / 0 |
| `maxconn` 64 | 4 525 (4 005*–4 908) | 299 | 46,8 / 64 | 487 | 442 / 178 | 0 / 0 / 0 |
Неуспешные запросы — проваленные проверки `message 201` k6 (из 69–122 тыс. запросов прогона); их отдали реплики (`hrsp_5xx`
серверов, у LB `eresp`/`econ` 0). У пула 16 самые долгие записи шли 2,2–2,8 с, дольше `lock_timeout` 2 с, — это `503`
по таймауту блокировки: чем больше пул, тем больше соединений в очереди за строкой чата и тем чаще запись не дожидается
её за 2 с. Это ещё один довод в пользу малого пула.
Очередь LB пик не меняет: при `maxconn` 16, 32 и 64 медианы 4 526 / 4 677 / 4 525 rps, интервалы перекрываются,
меняется только то, где ждут запросы (в очереди LB или в соединениях реплики). Пул меняет пик, но в обратную
сторону: чем он меньше, тем выше пропускная способность — 4 соединения на воркер дают 5 358 rps (интервал не
пересекается с пулом 8), 16 — 3 789. Число ждущих блокировку растёт вместе с пулом (14,7 → 47,0 → 102,3), а
запись в чат длится дольше (среднее время команды записи 1,7–3,2 → 12,2–15,6 → 35–47 мс, `pg_statements.csv`):
сторону: чем он меньше, тем выше пропускная способность — 4 соединения на воркер дают не меньше 5 358 rps (интервал
не пересекается с пулом 8; при 5 400 rps пул 4 почти не насыщен, поэтому это нижняя граница его пика), 16 — 3 789.
Число ждущих блокировку растёт вместе с пулом (14,7 → 47,0 → 102,3), а запись в чат длится дольше (среднее время
команды записи 1,7–3,4 → 12,2–15,4 → 35–56 мс по повторам; среднее по всем строкам этой команды в
`pg_statements.csv`, взвешенное по вызовам; 56 мс — возмущённый повтор 1 пула 16):
пул не ограничивает сверху, а, наоборот, впускает в PostgreSQL больше конкурентов за строку чата. Это прямое
подтверждение, что цена — согласование писателей одной строки (κ), а не нехватка соединений или LB; маленький пул
работает как admission control — второе возможное улучшение, в трек как основное не взято (выбрано до контроля).
@@ -489,8 +529,9 @@ event loop у держателей, а последовательная част
На тех же ядрах восемь процессов дают на 7 % меньший пик (интервалы не пересекаются), на 15 % дороже запрос по
CPU и вдвое больший p95 ниже колена. Значит, ретроградность 8×1 объясняется числом процессов и соединений, а не
тем, что CPU 11–14 медленнее: в прогонах того же часа 8×1 с пулом 4 (те же 32 соединения, что у 4×1) даёт
5 358 rps против 5 928 у 4×1 — цена процессов, а с пулом 8 (64 соединения) — 4 677 — плюс цена ожидающих.
тем, что CPU 11–14 медленнее. Пары «8×1 с пулом 4 против 4×1» для этого не хватает: пул 4 снят только при
5 400 rps и почти не насыщен, его пик не измерен, поэтому с 5 928 у 4×1 он не сравнивается; цену ожидающих
показывает сам контроль пула (пул 8 при 64 соединениях — 4 677 rps против ≥5 358 у пула 4).
Первая попытка этой части отброшена: в четырёх прогонах 4×1 команда записи замедлилась до 7–34 мс
(`IO: WalSync`, `aborted/control-cpus-1-*.csv`) при чужой нагрузке на CPU ниже порога отбраковки — она такое не ловит;
повтор сразу после дал 0,2–0,6 мс и вошёл в таблицу.
@@ -511,7 +552,11 @@ CPU и вдвое больший p95 ниже колена. Значит, рет
| 8 100 | **после** | 4 841 (4 618–5 046) | 202 / 254 / 287 | 462 / 174 | — | 46,3 / 0 / 9,2 |
Ниже колена (3 600 rps) p95 уменьшился в 17 раз, p99 — почти в 10, разброс повторов исчез; CPU API на запрос
−14 %, PostgreSQL −26 % (меньше операторов и обращений). За коленом пик вырос на 15 % (при 8 100 rps — на 18 %),
−14 %, PostgreSQL −26 % (меньше операторов и обращений). Чужая нагрузка на VM при этих прогонах была разной: у «до»
53 / 82 / 74 % ядра, у «после» 50 / 15 / 4 % (`cpu_other`, ниже порога отбраковки), поэтому кратность по p95
завышена шумом. Вывод опирается на то, что от шума не зависит: блокировку строки чата ждут 12,8 → 0,15 соединения,
`idle in transaction` 4,5 → 0, CPU на запрос ниже; а в повторе 1, где чужая нагрузка почти равна (53 и 50 %), p95
35,7 → 5,4 мс — в 6,7 раза. За коленом пик вырос на 15 % (при 8 100 rps — на 18 %),
интервалы повторов «до» и «после» не пересекаются. При насыщении соединений `idle in transaction` больше нет,
но пул по-прежнему занят ждущими блокировку: теперь держатель ждёт не приложение, а сброс WAL при фиксации
(ожидания `LWLock`, почти все — `WALWrite`, 8,5–9,2 против 1,9–2,3 «до»; `pg_activity.csv`), а CPU PostgreSQL —
@@ -522,7 +567,7 @@ CPU и вдвое больший p95 ниже колена. Значит, рет
**Выводы.**
- H1 **подтверждена частично.** Потолки 1×4, 2×2 и 4×1 действительно в пределах ±15 % (4 724–5 375, −12 % у
4×1), но различие систематическое и больше разброса: чем мельче реплики, тем дороже запрос по CPU (+33 % у
4×1; 4×1 шла на большей базе — см. ограничения трека), но различие систематическое и больше разброса: чем мельче реплики, тем дороже запрос по CPU (+33 % у
4×1) и памяти, и тем раньше растёт хвост (p95 при 4 560 rps — 9, 69 и 150 мс). Упор на пике — не только CPU
API (95 %): у всех трёх половина соединений ждёт блокировку чата. При фиксированном бюджете выгоднее меньше
реплик покрупнее, а число реплик определяется отказоустойчивостью (≥2), а не скоростью.
@@ -542,15 +587,23 @@ CPU и вдвое больший p95 ниже колена. Значит, рет
их по vCPU, но не по физическим ядрам (у M4 Max ядра двух типов), поэтому абсолютные RPS — свойство этой машины,
сравнимы только конфигурации внутри одного прогона. Эффект числа процессов отделён от размещения контролем на
одних CPU 7–10; насколько сами CPU 11–14 медленнее 7–10, отдельно не измерялось. Соседние стенды других лаб работали всё время замеров;
отбраковка ловит нагрузку больше одного ядра, меньшая остаётся шумом (`host-others.csv`), а задержки дисковой
подсистемы VM не ловит вовсе (отброшенная первая попытка контроля размещения). CFS-квоты дают
отбраковка ловит нагрузку больше одного ядра, меньшая остаётся шумом (`cpu_other` каждой строки `summary.csv`; для
серий A, B и сравнения ещё и `host-others.csv` с именами соседей, контрольные прогоны 30.10 он не покрывает), а задержки
дисковой подсистемы VM не ловит вовсе (отброшенная первая попытка контроля размещения). Такой шум не равен между
вариантами: при 3 600 rps у «до» чужой CPU 53–82 %, у «после» 4–50 %, поэтому вывод сравнения опирается на ожидание
блокировки и CPU на запрос, а не на кратность p95 (раздел улучшения). CFS-квоты дают
троттлинг мелких реплик; гипотеза, что из-за него 4×1 дороже по CPU, не проверялась счётчиками `cpu.stat`.
`docker stats` даёт точку раз в 4–6 с, `pg_stat_activity` — раз в секунду, это выборка, а не трасса.
Профиль с 10 чатами нарочно горячий; с тысячами чатов узким местом стали бы CPU API и PostgreSQL, и кривая
серии B была бы ближе к линейной. Сетка ×1,5 делает потолок по SLO грубым, поэтому сравнение идёт по пику.
`maxVUs` k6 ограничен 1 000, поэтому при перегрузке растут сброшенные итерации, а очередь в LB упирается в
1 000. Порт-форвардинг Docker Desktop в замеры не входит — k6 бьёт в `lb` изнутри сети. База растёт внутри
конфигурации (до 1 ГБ в серии A), поэтому старшие интенсивности идут на большей базе, чем младшие. Сравнение
конфигурации (до 1 ГБ в серии A), поэтому старшие интенсивности идут на большей базе, чем младшие, и конфигурации
на пике сравниваются на разной базе: из-за разного числа отбраковок 4×1 серии A шла на 0,87–1,02 ГБ, 1×4 — на
0,58–0,74 ГБ, а 8×1 серии B — на 0,17–0,31 ГБ. Смещение работает против 4×1: вывод «8×1 хуже 4×1» оно делает
только осторожнее, а в −12 % у 4×1 против 1×4 база может давать вклад. Внутри конфигурации рост базы на 0,16 ГБ
меняет пик не больше чем на 1 % (1×4: 5 384 → 5 332 rps, у 4×1 тренда нет), поэтому этот вклад, скорее всего, мал,
но отдельно не измерялся. Сравнение
до/после сделано на одной конфигурации 8×1; третий повтор «после» снят отдельным запуском после сбоя
`compose up` (`evidence/track1/README.md`). `compose up --wait` на восьми репликах при смене варианта изредка
проходит только со второй попытки (оркестратор повторяет его через 30 с). Причина видна в полном выводе
@@ -563,7 +616,7 @@ CPU и вдвое больший p95 ниже колена. Значит, рет
**Чем отказ процесса отличается от отказа узла?** Отказ процесса — это одна реплика: контейнер остановлен,
убит или завис, а host, LB, PostgreSQL и соседняя реплика работают. Его ловит проверка готовности LB, и
трафик уходит на соседа: `SIGTERM` — 1,0–1,4 с, `kill` — 0,5 с, зависание (`docker pause`) — 2,9–3,2 с по таймауту
трафик уходит на соседа: `SIGTERM` — 1,3 с, `kill` — 0,4–0,5 с, зависание (`docker pause`) — 2,9–3,1 с по таймауту
проверки (`evidence/detection/`), запись не прерывается (`failover-each`: 0 ошибок под 100 rps). Отказ узла
забирает всё, что на нём запущено, сразу: здесь узел один, поэтому вместе с репликами пропадают LB, PostgreSQL,
Valkey и volumes — отказ всего стенда, и никакая реплика его не переживёт. Кроме того, мёртвый узел не отвечает
@@ -579,15 +632,17 @@ Valkey и volumes — отказ всего стенда, и никакая ре
повторов отказавшего соединения на соседа, мягкого вывода из ротации и ответа `503` в формате контракта, когда
готовых реплик нет. Всё это делает HAProxy: активная проверка `/health/ready` раз в 1 с с `fall 2`/`rise 2`,
round robin, `retry-on conn-failure` и `redispatch`. Пример — остановка PostgreSQL: контейнеры `api` продолжают
работать, а LB исключает обе реплики за 0,9–1,4 с и сам отвечает `503 unavailable` (`detection/run*/postgres.json`).
работать, а LB исключает обе реплики за 1,0–1,3 с и сам отвечает `503 unavailable` (`detection/run*/postgres.json`, `faults.txt`).
**Какие POST можно повторять после timeout и что защищает Idempotency-Key?** Только `POST
/api/v1/chats/{chat_id}/messages` с тем же `Idempotency-Key` и тем же телом. Сообщение и квитанция ключа
фиксируются одной командой, поэтому повтор после таймаута, обрыва или гибели реплики посреди запроса либо
находит квитанцию и получает тот же `201` с тем же `Message`, либо, если исходная запись не зафиксировалась,
создаёт сообщение один раз. Одновременные повторы через разные реплики сериализуются блокировкой строки чата:
160 × `201` и одна копия в каждом из 20 раундов (`lb-check.json`); failover-тест повторяет запись с тем же ключом
после ошибки, и в истории нет дублей (`failover-*.txt`). Ключ не защищает от другого тела с тем же ключом
160 × `201` и одна копия в каждом из 20 раундов (`lb-check.json`). Потерянный ответ воспроизведён на стенде
(`make retry-check`, `retry.json`): запись ждёт блокировку строки чата дольше таймаута клиента, клиент повторяет её
с тем же ключом через LB — и когда реплика жива (она сама отвечает `201` уже без клиента), и когда её убили, пока
запрос ждал; в обоих случаях повтор получает `201` с тем же `id`, а в истории одна копия. Ключ не защищает от другого тела с тем же ключом
(`409`), от повтора через 24 ч и больше (`IDEMPOTENCY_TTL_SECONDS`, ключ начинается заново) и не отменяет
проверку сессии и доступа при повторе (`401`/`404`). `POST /users`, `POST /chats` и `POST /auth/sessions`
ключа не имеют: повтор после таймаута может создать второй чат или вторую сессию, поэтому их не повторяют ни
@@ -612,7 +667,7 @@ persistence с прежним токеном падают. Sticky-сессии
- Цель failover-теста выбирает round robin (кто обслужил первое сообщение); второй прогон сразу после первого
и `make restore` попадает в ту же реплику, поэтому перед ним нужен один запрос через LB:
`make failover-evidence SHIFT=1` или `curl -s -o /dev/null "http://$(docker compose port lb 8080)/health/live"`
перед `make test-failover` (так сняты `failover-fa81adafcb69.txt` и второй failover в `clean-clone.txt`).
перед `make test-failover` (так сняты `failover-fe75c6c37e5a.txt` и второй failover в `clean-clone.txt`).
- `X-Instance-Id` раскрывает короткий ID контейнера — допустимо до лабы 7, где появится непрозрачный alias.
- Таблица ключей растёт вместе с историей (строка на сообщение); истёкшие ключи только перезаписываются при
повторном использовании, фоновой очистки нет.