Files
mtusi2026lab5/REPORT.md
T
alenchha 633fb96920 ЛР 5 — БВТ2301 — Курлова — на 5
RabbitMQ + transactional outbox, отдельный worker (thumbnail/crop/WebP), lease и heartbeat, retry с backoff+jitter, DLQ и replay, admission control; тесты отказов, трек 1 и отчёт.
2026-11-06 12:10:16 +03:00

39 KiB
Raw Blame History

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

  • Автор, группа: Алёна Курлова, БВТ2301
  • Целевая оценка; выбранный трек 5: 5, трек 1 «Очередь под перегрузкой»
  • Commit/PR: TODO после публикации (ветка solution/bvt2301-kurlova)
  • Источники, библиотеки, помощь ИИ: FastAPI, psycopg 3, boto3, Pillow 11, aio-pika 9.5 (RabbitMQ 4.0), MinIO; документация RabbitMQ reliability, confirms, quorum queues. Код lab4 перенесён и расширен. Реализацию, тесты и черновик отчёта выполнял Claude Code (ИИ) под руководством автора; все результаты ниже получены на локальном стенде и сохранены в evidence/.

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

Prerequisites: Docker Desktop (Compose v2.20+, нужен --wait), Python 3.9+ (только stdlib для тестов). Проверено на macOS arm64, Docker 29.7, 10 CPU / 8 GiB у Docker VM.

cp .env.example .env            # те же значения, что использовались для evidence/
mkdir -p secrets
printf 'messenger'          > secrets/postgres_password
printf 'postgresql://messenger:messenger@postgres:5432/messenger' > secrets/database_url
printf 'valkey://valkey:6379/0' > secrets/cache_url
printf 'messenger_root'     > secrets/minio_root_user
python3 -c "import secrets;print(secrets.token_urlsafe(24),end='')" > secrets/minio_root_password
printf 'messenger_app'      > secrets/s3_access_key_id
python3 -c "import secrets;print(secrets.token_urlsafe(24),end='')" > secrets/s3_secret_access_key
python3 -c "import secrets;print(secrets.token_urlsafe(24),end='')" > secrets/rabbitmq_password
printf 'amqp://messenger:%s@rabbitmq:5672/messenger' "$(cat secrets/rabbitmq_password)" > secrets/broker_url
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait   # postgres, valkey, minio(+init), rabbitmq, migrate, api-1/2, nginx, worker x2
make check && make test

Bootstrap выполняется автоматически при каждом up и безопасен при повторе: migrate (версионированные SQL, checksum, advisory lock; lab5 добавляет 0006_async_processing.sql), minio-init (bucket, приватность, пользователь приложения), топология RabbitMQ объявляется кодом идемпотентно. Действий оператора не требуется.

Безопасная остановка с сохранением данных: docker compose stop (worker получает SIGTERM, перестаёт брать сообщения и ждёт до 25 с текущие задачи; неподтверждённые сообщения брокер вернёт в очередь). Намеренное удаление учебных данных: docker compose down -v. secrets/ и .env в git не попадают.

Собственные проверки (стенд должен быть запущен; FAULT_INJECTION=1 только на учебном стенде):

python3 student-tests/test_worker_down.py          # уровень 3: демонстрация из README + повторная доставка
python3 student-tests/test_failure_windows.py      # уровень 4: сценарии A–I (окна отказа, retry, DLQ, replay, lease)
docker compose exec -T --index 1 worker python - < student-tests/variants_check.py   # правила вариантов и лимиты worker
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh   # затем docker compose start api-1 api-2 и повтор
./student-tests/track1_matrix.sh && python3 student-tests/track1_summary.py   # трек 1, ~25 минут

Операторский CLI: docker compose exec api-1 python scripts/jobs.py failed | stats | show <attachment_id> | replay <attachment_id> --actor <имя>.

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

client ──HTTP──▶ nginx ──▶ api-1 / api-2 ──(1) PUT staging/<id>──────────────▶ MinIO (приватный bucket)
                              │  (2) COMMIT: attachment=queued + job + outbox        ▲      ▲
                              ▼                                                      │      │
                          PostgreSQL ◀── relay (в каждой API, SKIP LOCKED) ──(3) publish+confirm──▶ RabbitMQ
                              ▲                                                               │ quorum queue
                              │ claim/lease/heartbeat, (6) COMMIT результата                  ▼
                              └──────────────────────────── worker x2 ◀──(4) deliver, prefetch─┘
                                          (5) child process: resize; copy original, PUT variants ──▶ MinIO
                                          (7) delete staging, ack
Роль Сервис Версия Health Volume Сеть / порт Credentials
LB nginx 1.27.3-alpine /health/live; скрипт опрашивает /health/ready реплик — 127.0.0.1:8080 —
API ×2 api-1, api-2 из исходников, python 3.12.8-slim@sha256 /health/ready нет внутренняя Docker secrets
Worker ×2 worker (replicas) тот же образ, python -m app.worker mtime heartbeat-файла < 15 с нет внутренняя, портов нет secrets: БД, S3, broker
Брокер rabbitmq 4.0.5-alpine@sha256:e045b516… rabbitmq-diagnostics check_port_connectivity rabbitmqdata внутренняя, порты не опубликованы пароль из secret → conf.d при старте
БД postgres 17.7-alpine@sha256 pg_isready pgdata внутренняя secret
Кэш сессий valkey 8.1-alpine@sha256 valkey-cli ping — внутренняя —
S3 minio (+minio-init) madlabcg/minio@sha256:ad134b2d… mc ready local miniodata внутренняя root только у minio/minio-init

Источник истины. PostgreSQL: attachments, attachment_jobs (состояние задания, попытки, lease), attachment_variants (результат), outbox, job_audit. Брокер — только транспорт ссылки на задание; если сообщение потеряно или продублировано, правильное состояние восстанавливается из БД. Байты — только в S3.

Что сохранено в момент 202 (ответ на вопрос защиты): (а) все байты оригинала, проверенные по размеру/MIME/целостности/пикселям (lab4-проверки сохранены), лежат в staging/<id> в MinIO с persistent volume; (б) одним COMMIT записаны attachments.status='queued', строка attachment_jobs и строка outbox с сообщением. Публикация в брокер происходит после 202 асинхронно; её надёжность обеспечивает outbox, а не HTTP-запрос. Граница честно такая: staging уже в S3, worker делает server-side copy в attachments/<id>/original и создаёт варианты в attachments/<id>/v1/.

Состояния (contracts/attachment-states.md): uploading (внутреннее, клиенту не видно, как в lab4) → queued → processing → ready | failed; processing → queued при временной ошибке или истёкшем lease; failed → queued только явным replay. Повторная доставка ready-задания — no-op с ack (дочищает staging, если worker упал до этого).

Сообщение соответствует contracts/jobs.schema.json (поля schema_version, job_id, type, attachment_id, pipeline_version, attempt, created_at); message_id = job_id, header attempt дублирует поле. Никаких байтов, URL, ключей S3, filename и credentials. Worker берёт staging_key/object_key/sha256 из БД и сверяет SHA-256 и размер скачанного staging перед обработкой. Невалидное сообщение → reject(requeue=false) → DLX attachments.dlx → attachments.dlq.

Брокер. RabbitMQ 4.0, quorum-очередь attachments.process (Raft-лог на диске, durable), persistent-сообщения, publisher confirms + mandatory (relay помечает outbox-строку опубликованной только после confirm), ручной ack, prefetch = WORKER_PREFETCH, x-delivery-limit=20 (защита от сообщения, которое валит consumer), consumer_timeout=10 мин как последняя страховка брокера. Publisher confirm означает «брокер принял ответственность за сообщение»; consumer ack — «эффект обработки устойчиво зафиксирован в БД». Это разные границы, и мы ждём обе.

Transactional outbox (app/outbox.py). Relay работает в каждой API-реплике: SELECT … FOR UPDATE SKIP LOCKED → publish с confirm → published_at в той же транзакции. Будится сразу после upload и каждые 1 с. Crash после confirm, но до COMMIT — повторная публикация (дубль безвреден). Недоступный брокер не влияет на /health/ready и приём файлов: задания копятся в outbox (сценарий I). Опубликованные строки удаляются через 24 ч.

Идемпотентность и ключ эффекта. Ключ эффекта — (attachment_id, pipeline_version, variant): PK attachment_variants, детерминированные S3-ключи attachments/<id>/v1/{thumbnail.jpg,crop.jpg,optimized.webp}. Повтор перезаписывает те же ключи теми же байтами и вставляет варианты ON CONFLICT DO NOTHING, второго набора не возникает. job_id один на (attachment_id, pipeline_version) и не меняется при redelivery/retry; attempt растёт только при управляемой новой попытке (retry, истёкший lease, replay). Сообщение со старым attempt — no-op (stale). COMMIT результата фенсится условием state='processing' AND lease_owner=<этот worker>; attachments.status меняется на ready только если ещё не ready и pipeline_version не новее.

Lease, heartbeat, зависший worker. Claim ставит lease_until = now()+20 с; пока задача жива, heartbeat продлевает lease каждые ~7 с. Зависший worker (заблокирован event loop, сеть до БД) перестаёт продлевать lease. Sweeper любого worker раз в 5 с переводит такие задания в queued с новой попыткой (или в failed/retry_exhausted). Если «зависший» потом проснётся, его heartbeat/COMMIT не пройдут фенсинг, и он сделает ack без записи (сценарий G). Долго работающий worker отличается от зависшего именно heartbeat'ом. Жёсткий потолок одной попытки — JOB_TIMEOUT_SECONDS=60 (wall clock дочернего процесса) и 2× на весь job.

Retry. JOB_MAX_ATTEMPTS=5. Backoff экспоненциальный с equal jitter: d = min(30, 2·2^(n-1)), задержка d/2 + U(0, d/2). Отложенная попытка — строка outbox с available_at в будущем, без плагинов брокера. Классификация ошибок:

Код Тип Причина
invalid_image постоянная дочерний процесс не смог декодировать (exit 3)
image_too_large постоянная > 40 Мпикс по заголовку, до декодирования (exit 4)
image_too_complex постоянная MemoryError при RLIMIT_AS (exit 5) или SIGXCPU при RLIMIT_CPU
staging_missing, checksum_mismatch постоянная исходник пропал или не совпадает с принятым
processing_timeout временная превышен wall-clock 60 с (вероятна перегрузка)
worker_resource_exhausted временная дочерний процесс убит SIGKILL (OOM контейнера)
dependency_unavailable временная ошибки S3/БД/сети
lease_expired временная worker умер/завис
retry_exhausted финальная временные ошибки на всех 5 попытках

DLQ / реестр failed / replay. Бизнес-отказы — это attachment_jobs.state='failed' (scripts/jobs.py failed) с error_code, last_error и полным job_audit. Ядовитые сообщения попадают в attachments.dlq. Replay (scripts/jobs.py replay <id> --actor <кто>) в одной транзакции под FOR UPDATE проверяет, что задание и вложение именно failed, а staging ещё существует. Затем ставит queued, attempt+1, новый бюджет из 5 попыток, пишет outbox и audit replayed. Для ready/queued/processing replay отказывает (audit replay_refused, код выхода 3), поэтому «повторить» никогда не исполняет дубль успешной job.

Варианты (app/imageproc.py), выполняются в дочернем процессе с RLIMIT_AS=1024 MiB, RLIMIT_CPU=60 с, nice 5, wall-timeout 60 с:

  • thumbnail — JPEG q=85, вписан в 256×256, без увеличения, floor, минимум 1 px; 320×200 → 256×160;
  • crop — JPEG q=85, центральный квадрат → 128×128 (маленькие увеличиваются);
  • optimized — WebP q=80, method=4, вписан в 1280×1280 без увеличения, alpha сохраняется.

EXIF orientation применяется до расчёта размеров. Alpha композитится на белый для JPEG. 16-бит PNG сводится к 8 бит, CMYK → RGB. EXIF/XMP/ICC в варианты не копируются (пиксели трактуются как sRGB). Уменьшение каждого маленького файла не обещаем. Для JPEG используется DCT-scaling (draft) до ≥ нужного размера: декодирование 40-Мпикс JPEG занимает 0,3 с, а не секунды. Лимит пикселей проверяется по заголовку до декодирования (и в API, и в worker).

Ограничения работы, принятой системой. Bytes: 10 MiB (nginx и API). Pixels: 40 Мпикс (API и worker). Время и память: rlimits дочернего процесса, WORKER_CONCURRENCY, prefetch. Количество: admission control MAX_PENDING_JOBS=200 — ранняя проверка до чтения тела и строгая в транзакции постановки в очередь, превышение → 503 + Retry-After: 5 (трек 1).

Staging cleanup. Worker удаляет staging/<id> сразу после COMMIT результата (и при повторной доставке завершённой задачи). Reconciler из lab4 (app/reconcile.py, раз в 5 мин, advisory lock) расширен: удаляет staging у ready, staging failed-вложений старше STAGING_RETENTION_SECONDS=86400 (после этого replay отказывает), orphan-объекты в staging/ и attachments/ старше grace 15 мин, stale uploading. Текущую работу (queued/processing) он не трогает.

Что перенесено из lab4 и что изменено. Весь API lab1–4 сохранён. Upload теперь 202 queued вместо 201 ready. GET метаданных возвращает варианты только у ready. content?variant= поддерживает thumbnail|crop|optimized: неизвестное имя — 400, queued/processing/failed — 409, отсутствующий вариант ready-объекта — 404. Прикрепить queued/processing к сообщению можно, failed — 409. Ключи S3: staging/<id>, attachments/<id>/original, attachments/<id>/v1/*; политика пользователя приложения расширена на staging/*.

Критичные зависимости /health/ready: PostgreSQL и S3 (как в lab4). RabbitMQ не критичен для API: благодаря outbox приём файлов продолжается и при недоступном брокере.

Переменные .env.example → реальная конфигурация. Все ключи .env.example читаются app/config.py с теми же именами. BROKER_URL_FILE → secret broker_url. WORKER_CONCURRENCY — семафор параллельных задач на процесс. WORKER_PREFETCH — basic.qos. JOB_MAX_ATTEMPTS, JOB_TIMEOUT_SECONDS (wall/CPU лимит попытки), JOB_LEASE_SECONDS, JOB_BACKOFF_*, STAGING_RETENTION_SECONDS — как описано выше. API_REPLICAS информационный (реплики заданы сервисами api-1/api-2). FAULT_INJECTION=1 только для учебного стенда.

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

Дата прогона: 2026-11-06, macOS arm64, Docker 29.7 (10 CPU / 8 GiB VM), рабочее дерево поверх skeleton-коммита 276dbda.

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make check && make test PASS: lab5 public API scenario: 202 queued → ready, original побайтно, JPEG thumbnail 256×160 по реальному SOF evidence/smoke.txt
3: минимум lab4 сохранён, 201 → 202 make test, make test-persistence, make test-failover ×2 все PASS; failover: 0 неудачных записей, восстановление 0,8–1,0 с smoke, persistence, failover
3: 202 только после staging + job; рестарт API не теряет работу test_worker_down.py, сценарий A upload при остановленных worker → 202; после рестарта api-1/api-2/rabbitmq (StartedAt изменился) запись queued, сообщение в очереди; API, убитый сразу после COMMIT, не теряет задание worker_down, failure_windows
3: отдельные broker и worker, durable, at-least-once, ack после эффекта compose.yaml; test_worker_down.py; сценарии B, C quorum-очередь пережила рестарт брокера (messages=1 до и после); crash до COMMIT → повтор; crash после COMMIT до ack → redelivery decision=done worker_down, failure_windows
3: worker недоступен → API не делает resize синхронно test_worker_down.py при остановленных worker статус остаётся queued, content → 409, другие сообщения работают worker_down
3: queued/processing/ready/failed, thumbnail по контракту, original неизменен сценарии B/E, variants_check.py наблюдались queued → processing → queued → processing → ready и failed; 320×200 → 256×160; SHA-256 original совпадает failure_windows, variants_limits
3: ограниченный retry, failed с безопасным error_code, повтор не создаёт второго набора сценарии D, E, F; повторная доставка ровно 5 попыток → retry_exhausted; invalid_image без повторов; после дубля по-прежнему 3 строки вариантов, 1 success, 4 объекта failure_windows, worker_down
3: демонстрация из README test_worker_down.py worker stop → 202 → сообщение с вложением → restart API+broker → worker start → ready + thumbnail worker_down
4: crop 128×128 и optimized WebP, параметры variants_check.py crop 128×128 (с увеличением маленьких); WebP q=80 вписан в 1280 без увеличения; EXIF удалён; alpha на белый / сохранена в WebP; 16-bit, CMYK, palette variants_limits
4: лимиты bytes/pixels/время/память worker variants_check.py pixels → exit 4 до декодирования; битый PNG → exit 3; RLIMIT_AS → exit 5 (image_too_complex); RLIMIT_CPU → SIGXCPU; 39,5 Мпикс PNG за 0,9 с, ≈322 MiB RSS дочернего процесса variants_limits
4: outbox, crash между COMMIT и publish сценарии A и I API os._exit после COMMIT → relay другой реплики публикует ровно один раз → ready; брокер остановлен → upload 202, задание ждёт в outbox, после старта брокера → ready failure_windows
4: backoff с jitter, постоянные/временные ошибки, DLQ/реестр, безопасный replay сценарии D, E, F, H задержки 1,7 / 3,1 / 7,8 с в границах [1–2], [2–4], [4–8]; invalid_image без повторов; jobs.py failed содержит job; replay → ready; повторный replay готовой job отклонён; poison → attachments.dlq failure_windows
4: остановка worker после записи объекта до ack сценарий B crash после PUT → lease истёк (sweeper) → попытка 2 записала те же ключи; 1 набор вариантов, staging удалён failure_windows
4: timeout/lease зависшего processing, prefetch, очистка staging сценарий G; WORKER_PREFETCH; сценарии B/C зависший worker без heartbeat → другой worker забрал задание, проснувшийся отфенсен (lease lost); prefetch = 2; staging удаляется после COMMIT и при повторной доставке failure_windows
5, трек 1 student-tests/track1_matrix.sh, track1_summary.py см. «Эксперименты»; строгий admission limit держит очередь ровно на 30 summary.md, results.jsonl, matrix.log

Проверка hook: evidence/persistence.txt содержит State.StartedAt всех 9 контейнеров до и после scripts/restart.sh. Перезапущены postgres, valkey, minio, rabbitmq, оба worker, обе API и nginx; volumes pgdata, miniodata, rabbitmqdata сохранены.

Эксперименты и отказы

Трек 1. Очередь под перегрузкой

Гипотеза. Обработка CPU-bound, поэтому пропускная способность растёт с concurrency до числа доступных CPU и дальше не растёт. Каждый лишний слот concurrency только увеличивает пиковую память, примерно на размер декодированного изображения. Prefetch больше concurrency не ускоряет, а только переносит ожидание из брокера в буфер одного worker. Без ограничения приёма очередь и время до ready растут неограниченно, пока нагрузка выше ёмкости. Со строгим лимитом очередь ограничена, лишняя работа получает 503 + Retry-After, а восстановление после нагрузки занимает время разбора ограниченной очереди.

Методика (queue_load.py, track1_matrix.sh):

  • Один worker-контейнер с лимитом 2 CPU / 1,5 GiB; API ×2 по 0,5 CPU.
  • Open-loop нагрузка: запрос i отправляется в момент t0 + i/rate независимо от ответов, без повторов. 30 с на прогон, затем ожидание полного разбора очереди.
  • Размеры: small — JPEG 640×400, 80 KiB, 10/с; medium — JPEG 4000×3000 (12 Мпикс), 3,9 MiB, 5/с; large — PNG 6000×4000 (24 Мпикс, без DCT-scaling), 0,4 MiB, 3/с.
  • Настройки worker concurrency/prefetch: 1/1, 2/2, 4/4, 2/16. По 2 повтора каждой.
  • Метрики из attachment_jobs: queue lag = first_started_at − created_at; time to ready (ttr) = finished_at − attachment.created_at; throughput = готовые / (последний finish − первое поступление). Раз в секунду: docker stats worker (память без page cache, CPU) и число незавершённых заданий.
  • Калибровка при c=1 и низкой нагрузке, время обработки одной задачи: small 0,2 с, medium 0,34 с, large 0,53 с.

Результаты (среднее по 2 повторам, в скобках min–max; полный вывод — summary.md):

size rate/s c/p throughput jobs/s lag p95 s ttr p50 s ttr p95 s pending max worker mem peak MiB cpu peak %
small 10 1/1 5.53 (4.98–6.08) 23.70 (18.39–29.00) 12.11 23.86 (18.55–29.18) 131 (117–145) 90 96
small 10 2/2 8.28 (6.58–9.98) 7.35 (0.03–14.68) 4.13 7.59 (0.22–14.96) 50 (3–96) 99 192
small 10 2/16 8.40 (6.83–9.98) 6.72 (0.01–13.43) 4.02 6.96 (0.19–13.72) 50 (2–97) 101 179
small 10 4/4 7.78 (5.58–9.98) 11.58 (0.01–23.15) 5.76 11.92 (0.19–23.65) 68 (2–134) 108 192
medium 5 1/1 2.80 (2.48–3.12) 23.42 (17.32–29.51) 14.22 23.73 (17.62–29.83) 70 (58–83) 110 97
medium 5 2/2 4.58 (4.27–4.90) 2.64 (0.58–4.70) 1.65 3.05 (0.97–5.13) 14 (5–23) 142 190
medium 5 2/16 4.30 (3.70–4.90) 4.79 (0.60–8.97) 2.34 5.26 (1.00–9.52) 20 (5–35) 164 190
medium 5 4/4 4.50 (4.04–4.96) 2.74 (0.08–5.39) 1.71 3.53 (0.49–6.57) 13 (2–24) 166 (126–205) 200
large 3 1/1 1.73 (1.59–1.87) 21.01 (17.21–24.82) 10.85 21.59 (17.73–25.45) 38 (34–41) 197 100
large 3 2/2 2.44 (1.96–2.91) 6.77 (0.24–13.31) 3.94 7.65 (0.85–14.45) 14 (3–25) 294 (267–322) 197
large 3 2/16 2.32 (2.31–2.33) 7.19 (6.33–8.04) 2.00 8.11 (7.38–8.84) 16 (13–20) 280 197
large 3 4/4 2.44 (2.05–2.84) 5.65 (0.89–10.40) 3.92 7.50 (2.29–12.71) 15 (7–23) 517 (485–549) 203

Перегрузка: large, 8/с (≈3× ёмкости), c=2/p=2, MAX_PENDING_JOBS=30, 240 запросов, после разбора очереди — проба одной маленькой загрузки:

вариант admission принято 503 прочие ошибки pending max (лимит) throughput ttr p95 s разбор после нагрузки s проба ready s
мягкий, r1 128 112 0 74 (30) 2.24 32.7 28.4 0.23
мягкий, r2 143 97 0 81 (30) 2.38 34.1 30.7 0.51
строгий, r1 108 132 0 30 (30) 2.38 18.9 12.5 0.23
строгий, r2 100 140 0 30 (30) 2.21 16.4 15.2 0.24

«Мягкий» — первая версия, где admission проверялся только до чтения тела по счётчику, обновляемому раз в секунду: загрузки, уже прошедшие проверку и ещё передающие/валидирующие байты, не учитывались. «Строгий» — исправленная версия: тот же лимит проверяется ещё и в транзакции перевода в queued под pg_advisory_xact_lock (app/repo.py queue_attachment). Ранняя дешёвая проверка оставлена, чтобы не принимать тело зря.

Выводы.

  • Ёмкость ограничена CPU, а не concurrency. При c=1 worker держит ~1 CPU (96–100%) и не успевает ни на одном размере: очередь растёт до 38–131 задания, ttr p95 — 18–30 с. При c=2 используются оба CPU (~190%) и нагрузка в основном выдерживается. При c=4 CPU тот же (~200%), throughput не растёт (medium 4,50 против 4,58/с; large 2,44 против 2,44/с), а пиковая память для 24 Мпикс PNG растёт с 294 до 517 MiB. Это и есть компромисс latency/ресурсы: concurrency выше числа CPU почти не уменьшает задержку, но требует почти вдвое больше памяти. Рабочая настройка — concurrency = число CPU worker-контейнера.
  • Prefetch 16 при concurrency 2 не помогает и ухудшает хвост: medium ttr p95 5,3 против 3,1 с, large 8,1 против 7,7 с, при этом памяти больше. Сообщения, взятые одним worker «про запас», не может забрать другой освободившийся worker. Поэтому prefetch = concurrency.
  • Backpressure работает только со строгой проверкой. Мягкая проверка при лимите 30 пропустила 74–81 задание в очередь, ttr p95 — 33–34 с. Со строгой проверкой pending max ровно 30 в обоих повторах; 132–140 из 240 запросов получили 503 с Retry-After: 5; ttr p95 принятых снизился до 16–19 с, разбор после нагрузки — с 28–31 до 12–15 с. Принятая работа не терялась: все принятые задания дошли до ready, other_errors = 0. Время до ready для принятого ограничено сверху ≈ лимит / ёмкость (30 / 2,3 ≈ 13 с + обработка).
  • Восстановление: после разбора очереди новая загрузка становится ready за 0,23–0,51 с, то есть как без нагрузки.

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

  • Между повторами большой разброс, во втором повторе всё медленнее (small c=2: 9,98 против 6,58/с при том же ~190% CPU). Значит, на хосте выросла стоимость CPU-секунды: ноутбук, троттлинг, общие ядра Docker VM. Сравнивать конфигурации корректно внутри одного повтора, абсолютные числа — не SLA.
  • Два повтора — мало для доверительных интервалов.
  • Один worker-контейнер; генератор нагрузки и стенд на одной машине.
  • Память по docker stats снимается раз в секунду, короткий пик дочернего процесса может не попасть в выборку (отдельно измерено ≈322–335 MiB на один 40-Мпикс файл, variants_limits).
  • Queue lag и ttr используют часы PostgreSQL (одни для всех событий).
  • Сырые данные: results.jsonl, лог прогона: matrix.log. Тестовые изображения генерируются заново (evidence/track1/fixture-* не в git, шум JPEG случайный).

Отказы

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
Остановлены все worker, upload, рестарт API и RabbitMQ 202, задание в durable-очереди, после старта worker → ready messages=1 до и после рестарта брокера, затем queued → ready ~4 с после старта worker; потерь нет
API падает сразу после COMMIT, до publish (A) relay любой реплики опубликует из outbox клиент получил 502 от LB; запись есть; опубликована 1 раз; ready ~1 с; потерь нет
RabbitMQ остановлен (I) upload всё равно 202, задание ждёт в outbox 202, outbox: 1 неопубликованная строка; после старта брокера → ready ~10 с (старт брокера + reconnect); потерь нет
Worker падает после PUT, до COMMIT (B) lease истекает, попытка 2 перезаписывает те же ключи lease_expired → attempt 2 succeeded; 3 варианта, 4 объекта ~25 с (lease 20 с + sweep 5 с); дублей нет
Worker падает после COMMIT, до ack (C) redelivery → no-op, staging дочищен decision=done, 1 success, staging удалён мгновенно; дублей нет
Worker завис (G) другой worker забирает задание, зависший отфенсен lease_expired → другой owner → ready; проснувшийся: lease lost ~25 с; дублей нет
Временные ошибки ×3 (D) / ×6 (F) backoff с jitter; при исчерпании failed, replay → ready D: ready с 4-й попытки; F: retry_exhausted после 5, replay → ready, повторный replay отклонён D ~14 с, F ~52 с
Ядовитое сообщение (H) в DLQ, без бесконечных повторов attachments.dlq 0 → 1 —
Отказ одной API-реплики (failover ×2) LB уводит трафик 0 неудачных записей, первая успешная запись через 0,8–1,0 с без потерь и дублей

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

  • Брокер — один узел RabbitMQ. Quorum-очередь даёт durability на диске, но не HA: при недоступном брокере приём продолжается через outbox, а обработка ждёт.
  • Задание, у которого outbox-строка опубликована, но сообщение потом потеряно вне контракта брокера (например, удалён volume RabbitMQ), само не восстановится. Нужен «reaper», переиздающий давно queued задания. Не сделан, потому что при штатной работе он плодит дубли в длинной очереди. Обходной путь — повторный INSERT в outbox, как в тесте redelivery.
  • Fault injection включается по имени файла и только при FAULT_INJECTION=1; в production-конфигурации флаг должен быть 0.
  • Строгий admission limit сериализует COMMIT загрузок одним advisory lock: при наших скоростях (≤10 upload/с) это незаметно, но при сотнях загрузок в секунду станет узким местом. Тогда нужен счётчик-токен вместо count(*). Загрузка, отклонённая на этом шаге, уже передала все байты (пропускная способность потрачена), поэтому дешёвая ранняя проверка до чтения тела оставлена.
  • Exactly-once нет: at-least-once доставка + идемпотентный эффект. Дубли сообщений штатны и видны в логах как noop decision=done|stale|busy.
  • ICC-профиль удаляется: изображения в Adobe RGB/Display P3 в вариантах будут чуть менее насыщенными.
  • Один пользователь S3 для API и worker. Следующий шаг — раздельные политики (API: put staging / get final; worker: get staging / put final / delete staging).