Files
mtusi2026lab5/REPORT.md

34 KiB
Raw Permalink Blame History

Отчёт — лабораторная 5

  • Автор, группа: Кошелев, БВТ2304
  • Целевая оценка: 5, трек 2 — «Доказанная идемпотентность pipeline»
  • Commit/PR: ветка solution/bvt2304-koshelev, PR в mtusi2026lab5 (main)
  • Использованные источники, библиотеки и помощь ИИ: код перенесён из собственной lab4 (FastAPI, uvicorn, pydantic, asyncpg, redis-py, argon2-cffi, boto3, Pillow). Новое: RabbitMQ 4.1 (quorum queues, publisher confirms, dead-lettering, x-delivery-limit), aio-pika 9.5.8, PostgreSQL FOR UPDATE SKIP LOCKED и LISTEN/NOTIFY, Pillow (ImageOps.exif_transpose, Image.draft, WebP). Документация: RabbitMQ Reliability / Confirms / Quorum Queues, transactional outbox (microservices.io), Pillow handbook. При реализации, тестах и отчёте использовался ИИ-ассистент Claude (Anthropic); решения проверены и объяснимы автором.

Запуск из чистого clone

Требования: Docker Engine + Compose v2 (проверено: Docker Desktop 28.0.1, Compose 2.33.1), Python 3.9+ для тестов (проверено 3.14, только stdlib), make. Стенд: Apple M3, 8 CPU, 16 GiB, Docker VM 8 CPU / 7.6 GiB.

Секреты создаются в ./secrets/ (в .gitignore): пароли PG/Valkey/RabbitMQ, S3-ключи, broker_url, rabbitmq.conf. Для тестов отказов в .env поставьте FAULT_INJECTION=1. Порядок старта: postgres, valkey, s3, rabbitmq → migrate, s3-init → api ×2, relay, worker, sweeper, ops → lb.

./scripts/init-secrets.sh
cp .env.example .env
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait
make check && make test
python3 student-tests/pipeline_test.py
python3 student-tests/faults_test.py --output evidence/faults.json
python3 student-tests/limits_test.py
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && ./scripts/restore.sh

pipeline_test.py — варианты, EXIF, alpha, лимиты, invalid_image; faults_test.py — 14 сценариев отказов (нужен FAULT_INJECTION=1); limits_test.py — лимиты времени и памяти worker (пересоздаёт контейнер worker). Сценарий защиты по шагам — DEMO.md.

  • Операторские действия: ./scripts/stop-worker.sh, ./scripts/start-worker.sh, CLI docker compose exec ops python -m app.ops <failed|replay|reprocess|inspect|stats|fault|republish|dlq-peek>. RabbitMQ management UI — только http://127.0.0.1:15672 (логин messenger, пароль в secrets/rabbitmq_password).
  • Bootstrap идемпотентен: migrate применяет только новые файлы под advisory lock; s3-init — «bucket already exists»; топологию брокера (exchange/queues/bindings) объявляют relay/worker/ops при каждом старте (declare идемпотентен).
  • Безопасная остановка: docker compose stop / docker compose down (volumes сохраняются). Намеренное удаление учебных данных: docker compose down -v (удаляет pgdata, s3data, rabbitmqdata).
Роль Service Образ Health/readiness Volume Сеть / порт Credentials
LB lb haproxy:3.2.4-alpine /lb-health; backend по /health/ready — edge, единственный публичный порт 127.0.0.1:8080 —
API ×2 api mtusi-messenger:lab5 (build) /health/ready (PostgreSQL) — (stateless) edge + data database_url, cache_url, S3-ключи API; нет broker_url
Outbox relay relay mtusi-messenger:lab5 heartbeat-файл < 30 с — data database_url, broker_url
Worker worker mtusi-messenger:lab5 heartbeat reaper-цикла < 30 с — data database_url, broker_url, S3-ключи
Брокер rabbitmq rabbitmq:4.1.4-management-alpine rabbitmq-diagnostics check_port_connectivity rabbitmqdata data; UI только 127.0.0.1:15672 (сеть mgmt) rabbitmq.conf как secret в conf.d
S3 s3 chrislusf/seaweedfs:4.51 /healthz + data node в топологии s3data data seaweedfs_s3_config
PostgreSQL postgres postgres:17.6-alpine3.22 pg_isready pgdata data postgres_password
Кэш сессий valkey valkey/valkey:8.1.4-alpine3.22 ping — data valkey_conf
Очистка sweeper mtusi-messenger:lab5 heartbeat — data database_url, S3-ключи
Оператор ops mtusi-messenger:lab5 — (idle) — data database_url, broker_url, S3-ключи
One-shot migrate, s3-init mtusi-messenger:lab5 exit 0 — data database_url / s3_admin_*

Критичные зависимости /health/ready: только PostgreSQL (синхронный путь сообщений/сессий). Недоступность брокера, worker или relay не делает API неготовым: upload продолжает отвечать 202 (outbox копится), сообщения работают. Недоступность S3 даёт 503 только на upload/download.

Соответствие .env.example: BROKER_URL_FILE → secret broker_url (relay/worker/ops); WORKER_CONCURRENCY=2 → prefetch AMQP = число параллельных дочерних процессов; JOB_MAX_ATTEMPTS=5; JOB_TIMEOUT_SECONDS=60 → жёсткий лимит одного преобразования (kill дочернего процесса); STAGING_RETENTION_SECONDS=86400 → хранение staging failed-вложений для replay; MAX_UPLOAD_BYTES, MAX_IMAGE_PIXELS → API и worker. Дополнительно: WORKER_REPLICAS=1, LEASE_SECONDS=20, HEARTBEAT_SECONDS=5, RETRY_BASE_SECONDS=2, RETRY_MAX_SECONDS=60, WORKER_MEMORY_LIMIT_MB=768 (RLIMIT_AS дочернего процесса), STUCK_QUEUED_SECONDS=300, PIPELINE_VERSION=1, ORPHAN_GRACE_SECONDS=900, FAULT_INJECTION=0|1. Остальные — как в lab4.

Архитектура и решения

client ─► lb ─► api-1/api-2 ── (1) PUT staging/<id> ──────────────────────────────► S3 (private bucket)
                    │           (2) ONE tx: attachments(queued)+jobs+outbox ─┐        ▲   ▲
                    └─ 202 queued only after COMMIT                          ▼        │   │
                                                       PostgreSQL (источник истины)   │   │
             relay: outbox ─SKIP LOCKED─► publish ─confirm─► RabbitMQ quorum queue    │   │
                                                              attachments.process     │   │
                                                                │ prefetch=2          │   │
                                worker: claim(lease) → GET staging → child process ───┘   │
                                        (decode/resize, RLIMIT_AS, timeout) → PUT final ──┘
                                        → fenced COMMIT(variants+ready+job done) → ack → delete staging
                                reaper (в worker): истёкший lease → retry/failed; «потерянное» сообщение → re-enqueue
                                poison message → reject → attachments.dlx → attachments.dlq

Перенесено из lab4 без изменений: пользователи, сессии (PostgreSQL + кэш Valkey), чаты, сообщения, keyset-пагинация, идемпотентность сообщений, балансировка, X-Instance-Id, потоковый приём файла в spool, проверки filename/Content-Type/сигнатуры/пикселей до декодирования, приватный bucket, ограниченные S3-ключи.

Изменено в lab5 (объявленный переход 201 → 202):

  1. Приём (API, app/main.py). После синхронных дешёвых проверок (сигнатура, размеры из заголовка, лимит пикселей, CRC чанков PNG) оригинал целиком кладётся в staging/<attachment_id> с x-amz-checksum-sha256 (S3 отвергает искажённые байты). Затем одна транзакция PostgreSQL: attachments(status=queued, staging_key, object_key) + jobs(queued, attempt=0) + outbox(payload) + job_events(accepted) + pg_notify. Только после COMMIT — 202 queued. Что сохранено в момент 202: полный проверенный оригинал в S3 (staging), метаданные с SHA-256 и намерение обработки (job + outbox) в PostgreSQL. Полное декодирование и resize в API больше не выполняются: файл, прошедший синхронные проверки, но не декодируемый, становится failed / invalid_image. API не знает адрес брокера.
  2. Outbox relay (app/relay.py). SELECT … WHERE published_at IS NULL AND available_at <= now() FOR UPDATE SKIP LOCKED → publish с ожиданием publisher confirm (mandatory=True, persistent) → UPDATE published_at → COMMIT. Пробуждение — LISTEN outbox (задержка ~10 мс), отложенные строки (backoff) — опрос раз в секунду. Падение после confirm, но до COMMIT — повторная публикация (дубль), что безопасно (см. трек).
  3. Брокер. Quorum queue attachments.process (Raft-лог на диске, durable), сообщения persistent, consumer ack ручной, prefetch = WORKER_CONCURRENCY. Сообщение строго по contracts/jobs.schema.json: schema_version, job_id, type, attachment_id, pipeline_version, attempt, created_at — без байтов, URL и credentials; worker берёт ключи S3/размер/SHA-256 из БД. Невалидное сообщение → reject(requeue=false) → attachments.dlx → attachments.dlq; x-delivery-limit=10 защищает от бесконечного цикла redelivery.
  4. Worker (app/worker.py, app/imaging.py). Захват: в транзакции jobs FOR UPDATE; стартует попытку только если status=queued и message.attempt == jobs.attempt + 1, иначе ack как no-op с событием (duplicate_noop, stale_attempt_noop, lease_held_noop, superseded_noop …). Захват ставит processing, attempt+1, lease_owner, lease_until = now()+20s; heartbeat продлевает lease каждые 5 с. Преобразование — в отдельном процессе (forkserver) с RLIMIT_AS=768 MiB и жёстким таймаутом 60 с (kill). Запись в S3 по детерминированным ключам эффекта attachments/<id>/original, attachments/<id>/v<N>/{thumbnail.jpg,crop.jpg,optimized.webp}. Фиксация — fenced COMMIT: результат принимается, только если job всё ещё processing с тем же (lease_owner, attempt); версия не ниже опубликованной; затем attachment_variants (PK (attachment_id, pipeline_version, name)), attachments.status=ready, jobs.status=done. Ack — только после COMMIT. Затем удаление staging (сбой здесь чинит sweeper).
  5. Варианты (pipeline v1). thumbnail: JPEG q85, вписан в 256×256 без увеличения, округление вниз, ≥1 px (320×200 → 256×160); crop: JPEG q85, центрированный квадрат 128×128 (ImageOps.fit, маленькие увеличиваются); optimized: WebP q80 method 4, вписан в 1280×1280 без увеличения, alpha сохраняется. Для всех: EXIF-ориентация применяется к пикселям (exif_transpose), alpha у JPEG компонуется на белый, EXIF/XMP/ICC/комментарии не записываются (Pillow пишет их только при явной передаче; проверяется тестом — в вариантах нет APP1 Exif). Оригинал — побайтно исходный (со своим EXIF). JPEG декодируется с DCT-масштабированием (draft) — память пропорциональна целевому, а не исходному размеру; целевые размеры считаются от исходных, поэтому результат точный.
  6. Ошибки и повторы (app/jobs.py). Постоянные (без повторов): invalid_image, image_too_large (MemoryError под RLIMIT_AS / превышение пикселей), staging_missing, staging_corrupt (байты не совпали с SHA-256 из БД), unsupported_pipeline. Временные: s3_unavailable, processing_timeout, worker_process_died:*, lease_expired, неожиданные исключения. Временная ошибка → queued с next_attempt_at = now() + backoff и outbox-строкой с тем же available_at (отложенная публикация без плагинов брокера). Backoff экспоненциальный с «equal jitter»: d = min(60, 2·2^(n-1)), задержка d/2 + U(0, d/2) → окна [1,2], [2,4], [4,8], [8,16] с. После 5 попыток — failed / retry_exhausted.
  7. Реестр failed и replay. Реестр — jobs WHERE status='failed' (python -m app.ops failed), DLQ брокера — для невалидных сообщений. python -m app.ops replay <id> --actor <кто> в одной транзакции: только для failed (для done — отказ с кодом 3 и событием replay_refused), max_attempts += 5, attachments → queued, outbox, событие replay с автором (audit). Тот же job_id и тот же ключ эффекта — повтор не создаёт второго набора.
  8. Lease / зависание (reaper в каждом worker, SKIP LOCKED). processing с lease_until < now() → lease_expired → retry (или failed, если попытки исчерпаны). Долго работающий worker продлевает lease heartbeat'ом и не теряет его; зависший преобразователь убивается по JOB_TIMEOUT_SECONDS (процесс worker жив, но попытка завершается processing_timeout); умерший worker перестаёт продлевать lease. Дубли исключены fencing'ом: даже если старый владелец «оживёт» после истечения lease, его COMMIT отклоняется (fenced_out). Страховка: job queued дольше STUCK_QUEUED_SECONDS без неопубликованной/свежей outbox-строки переотправляется (republished_stuck) — на случай потери сообщения в брокере.
  9. Staging и retention (app/sweeper.py). staging удаляется только после COMMIT ready; failed-staging хранится STAGING_RETENTION_SECONDS (сутки) для replay; staging без строки (сбой между PUT и COMMIT, 202 не отправлялся) и объекты attachments/…, на которые не ссылается ни одна зафиксированная строка (вытесненная версия, fenced попытка), удаляются после ORPHAN_GRACE_SECONDS, только если у вложения нет активной job. queued/processing не трогаются никогда.
  10. API-семантика. GET /attachments/{id} показывает queued/processing/ready/failed, variants только у ready, error_code только у failed. /content для не-ready → 409, отсутствующий вариант ready → 404. В сообщение можно прикрепить queued/processing/ready; failed → 409; чужое/неизвестное → 404.

Схема (migrations/0004_jobs_outbox.sql): jobs (UNIQUE (attachment_id, pipeline_version), CHECK согласованности lease и статуса), outbox, attachment_variants, job_events (audit), fault_injections.

Доказательства критериев

Все файлы — в evidence/. Дата прогона 2026-11-10, ветка solution/bvt2304-koshelev.

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: 202 → ready, оригинал и настоящий JPEG 256×160 smoke.txt
3: минимум lab4 сохранён, upload 201 → 202 smoke + persistence + failover PASS (данные и сессия после рестарта всех stores; отказ реплики API) smoke.txt, persistence.txt, failover.txt, load.json
3: 202 только после устойчивого приёма; остановка API не теряет работу faults_test.py worker_down после 202 API перезапущен — attachment queued, затем ready faults.txt
3: отдельные broker и worker; durable; ack после эффекта; без синхронного resize compose; worker_down при остановленном worker upload 202, content 409, другие сообщения 201; ack после COMMIT (worker.py) faults.txt
3: состояния queued/processing/ready/failed; original + thumbnail pipeline_test.py 7/7 PASS; оригинал побайтно, thumbnail 256×160 pipeline.txt
3: ограниченный retry, failed с error_code; повтор не создаёт второго набора exhausted_then_replay, duplicate 5 попыток → retry_exhausted; дубли → duplicate_noop, 3 строки вариантов faults.txt
3: демонстрация worker stop → upload → message → restart API → start worker → ready; рестарт broker с volume worker_down очередь до/после рестарта RabbitMQ: queue_ready_messages=1; после старта worker ready, thumbnail 256×160 faults.txt, faults.json
4: crop 128×128, WebP; параметры качества/метаданных pipeline_test.py crop 128×128; WebP 320×200 / 1280×320 / 200×300 (EXIF); EXIF в вариантах отсутствует; alpha → белый pipeline.txt
4: лимиты bytes / пикселей / времени / памяти worker pipeline_test.py, limits_test.py 413/415 до 202; 36 Мп ready за ~1 с; RLIMIT_AS 160 MiB → image_too_large за 1 попытку; таймаут 0.3 с → kill, 4 retry, retry_exhausted pipeline.txt, limits.txt
4: transactional outbox; crash между COMMIT и publish outbox_gap, relay_crash_after_confirm relay остановлен: outbox-строка published=false, вложение queued → relay старт → ready; crash после confirm → повторная публикация → duplicate_noop faults.txt
4: backoff + jitter; постоянные/временные; DLQ/реестр; безопасный replay transient_backoff, pipeline_test corrupt, exhausted_then_replay, poison_message задержки 1.66 с и 2.77 с в окнах [1,2]/[2,4]; invalid_image без повторов; реестр failed; replay → ready; replay ready → отказ; невалидное сообщение → DLQ 0→1 faults.txt, pipeline.txt
4: остановка worker после записи объекта до ack; lease; prefetch; очистка staging crash_after_s3, crash_after_commit, crash_after_claim, long_running_not_hung, sweeper.txt crash после S3 → lease истёк → попытка 2 перезаписала те же 4 ключа; crash после COMMIT → no-op; 30 с работы при lease 20 с → 1 попытка; staging пуст после ready (I5); sweeper удалил 6 неиспользуемых объектов, повтор — 0 faults.txt, sweeper.txt
5, трек 2 faults_test.py (14 сценариев + инварианты I1–I5) 14/14 PASS, итог: outbox_unpublished=0, processing=0 faults.txt, faults.json

Эксперименты и отказы — трек 2: доказанная идемпотентность pipeline

Гипотеза. При доставке at-least-once (дубли, переупорядочивание, падение процесса в любой точке, устаревшая работа старой версии) комбинация (а) состояния job в PostgreSQL как единственного арбитра, (б) fencing-токена (job_id, attempt) + lease, (в) детерминированных ключей эффекта (attachment_id, pipeline_version, variant) и (г) монотонного правила версий даёт идемпотентный эффект: ни одна подтверждённая (202) задача не теряется, у вложения ровно один набор вариантов опубликованной версии, и результат старой версии никогда не перезаписывает новый.

Versioned pipeline. PIPELINES = {1: …, 2: …} (app/imaging.py): v2 отличается параметрами качества (JPEG q90, WebP q72 method 6) и пишет в свои ключи v2/…. python -m app.ops reprocess <id> --pipeline-version 2 создаёт отдельную job (UNIQUE (attachment, version)); вложение во время перерасчёта остаётся ready со старыми вариантами, переключение — атомарный COMMIT. Даунгрейд отклоняется.

Инварианты (проверяются после каждого сценария функцией check_invariants, через API и CLI):

Инвариант Как проверяется
I1 Подтверждённая задача не теряется каждый 202 доходит до ожидаемого финального статуса
I2 Один результат ровно 3 строки вариантов для опубликованной версии; метаданные API = строки БД; SHA-256 отдаваемых API байтов = опубликованному; оригинал не изменился
I3 Нет дублей эффектов множество ключей attachments/<id>/… в S3 = original + ключи зафиксированных строк (+ явно ожидаемые остатки вытесненной версии)
I4 Версии монотонны последовательность событий ready по версиям неубывающая, опубликована максимальная
I5 Ничего не зависло нет processing, outbox полностью опубликован, staging удалён

Методика. Стенд из compose.yaml с FAULT_INJECTION=1, 1 worker × concurrency 2, lease 20 с. Fault points (app/faults.py) взводятся строкой в fault_injections и срабатывают ровно один раз (атомарный UPDATE … SKIP LOCKED); crash = os._exit(137) (как SIGKILL, Docker перезапускает контейнер). Дубли и переупорядочивание создаются сырой публикацией в брокер в обход outbox (ops republish --attempt N --pipeline-version V). Всё автоматизировано: python3 student-tests/faults_test.py (повторяемо, каждый запуск создаёт новых пользователей/вложения; ~5 минут).

Результаты (evidence/faults.txt, evidence/faults.json):

Воздействие (окно отказа) Что ожидаем Что наблюдали (события job_events) Восстановление / потеря
worker остановлен; рестарт API и RabbitMQ с volume сообщение и работа сохраняются очередь 1 сообщение до и после рестарта брокера → claimed, ready после старта worker ~1 с; потерь нет
после COMMIT до publish (relay остановлен) outbox держит намерение published=false → после старта relay claimed, ready ~1 с после старта relay; потерь нет
после publish/confirm до отметки в outbox (crash relay) дубль сообщения безопасен claimed, ready, duplicate_noop дубль = no-op, 1 попытка
после claim до side effect (crash worker) lease истекает, повтор claimed, lease_held_noop, lease_expired, retry_scheduled, claimed, ready ~25 с (lease 20 с + backoff); варианты от попытки 2
после записи S3 до COMMIT (crash worker) повтор перезаписывает те же ключи то же; ключей в S3 ровно 4 ~24 с; второго набора нет
после COMMIT до ack (crash worker) redelivery — no-op ready, duplicate_noop ~1.5 с; 1 попытка
3 дубля завершённой job no-op 3× duplicate_noop, updated_at не изменился —
reorder: попытка 1 повторно и «будущая» 4 до настоящей 2; затем поздняя копия 1 из outbox stale отбрасываются 3× stale_attempt_noop, ровно 2 claimed —
устаревшая job после новой версии (v1-сообщение после ready v2) v2 сохраняется duplicate_noop, опубликована v2 —
гонка версий: v1 медленная (delay 8 с перед COMMIT), v2 фиксируется первой v1 не перезаписывает v2 порядок ready v2 → superseded v1; строк v1 нет; объекты v1 — неиспользуемые остатки, удалены sweeper'ом —
2 временные ошибки backoff+jitter задержки 1.66 с, 2.77 с; ready с попытки 3 ~5 с
5 временных ошибок + replay failed → явный replay retry_exhausted → replay (audit, автор) → ready; повторный replay ready отклонён —
30 с работы при lease 20 с долгий ≠ зависший 1 попытка, нет lease_expired —
невалидное сообщение не зациклить DLQ 0 → 1 —

Итог полного прогона: 14/14 PASS, финальное состояние {"outbox_unpublished": 0, "processing": 0}, в DLQ — только намеренно отправленные невалидные сообщения.

Почему это не exactly-once доставка. Брокер доставляет сообщение at least once: дубли реально возникали (crash relay после confirm, crash worker после COMMIT до ack, ручные republish). Exactly-once достигается не для доставки, а для наблюдаемого эффекта: побочные эффекты идемпотентны (те же ключи, те же байты) или отвергаются (fencing, проверка версии), а решение «эффект зафиксирован» принимается одной транзакцией PostgreSQL. Publisher confirm лишь означает, что брокер принял ответственность за сообщение (граница producer → broker); consumer ack — что worker надёжно зафиксировал результат (граница broker → consumer); между ними неизбежно окно, где один из участников может упасть, и система обязана терпеть повтор.

Ограничения измерения и решения.

  • Детерминизм кодирования (повтор пишет те же байты по тому же ключу) верен для одной сборки Pillow/libjpeg/libwebp. При смене образа повтор незавершённой попытки может записать другие байты по тому же ключу — но строка БД всегда фиксируется вместе с SHA-256 записанных этой попыткой байтов, а fencing гарантирует, что фиксирует только владелец lease. Окно «старый владелец перезаписал объект уже после COMMIT нового» (процесс замёрз дольше lease, затем проснулся и сделал PUT) теоретически возможно при недетерминированном кодировании; полностью закрывается ключами, включающими номер попытки, ценой мусора до sweeper — сознательно не выбрано, т.к. контракт задаёт ключ эффекта (attachment, version, variant).
  • Восстановление после смерти worker занимает lease (20 с) + backoff; уменьшение lease ускоряет восстановление, но повышает риск ложного «зависания» при GC/IO-паузах (heartbeat каждые 5 с даёт запас ×4).
  • Тест проверяет 1 экземпляр worker с concurrency 2; конкуренцию двух worker за один lease покрывает fencing-логика (fenced_out), но отдельного стохастического стресс-теста нет.
  • Fault injection включается переменной окружения и отключён по умолчанию (FAULT_INJECTION=0); таблица fault_injections без включённого флага не читается.

Ограничения и следующие шаги

  • Выдерживается: остановка/рестарт API, worker, relay, RabbitMQ, PostgreSQL, S3 и Valkey с volumes (persistence-тест), падение процесса в любом окне из attachment-states.md, дубли и переупорядочивание сообщений, потеря сообщения после публикации (страховка STUCK_QUEUED_SECONDS).
  • Не выдерживается: потеря volume PostgreSQL (источник истины) или S3; одиночные узлы RabbitMQ/PostgreSQL/S3 (quorum queue на одном узле даёт durability, но не HA).
  • Учебные упрощения: reaper встроен в worker (при нуле worker задачи с истёкшим lease ждут первого запуска worker — что и нужно, обрабатывать всё равно некому); API не проверяет полную декодируемость (это работа worker → invalid_image); ICC-профиль не переносится и цвета не конвертируются в sRGB.
  • Нагрузочное исследование очереди (трек 1) не проводилось; load.json — только регресс синхронного пути сообщений: tests/load.py --base-url http://127.0.0.1:8080 --duration 15 --concurrency 4 → 262 успешных RPS, p50/p95/p99 = 3.3/6.9/60 мс, 4 ошибки из ~3950. Ошибки — клиентские URLError (сбой установки TCP-соединения): в логе HAProxy за тот же интервал все 3955 POST сообщений получили 201 при server-side Ta p50 2 мс, p99 13 мс, max 86 мс, ни одного 5xx. То есть секундные задержки и обрывы возникают на участке macOS → проброс порта Docker Desktop (клиент открывает новое соединение на каждый запрос), а не в приложении. В lab4 на свежем демоне было 471 RPS без ошибок; разница RPS объясняется теми же редкими многосекундными задержками соединения в closed-loop генераторе, поэтому как сравнение производительности эти числа не используются.