Files
mtusi2026lab5/REPORT.md
T
zemiles 13bec4ab8b ЛР 5 — БПИ2303 — Лазарев — на 4
Асинхронная обработка вложений: RabbitMQ 4.1 (quorum-очереди, publisher
confirms, manual ack, DLQ), transactional outbox, отдельный worker.

- upload: оригинал в staging S3, затем одной транзакцией queued + jobs +
  outbox -> 202; API к брокеру не подключается
- relay: публикация outbox с confirm, reaper истёкших аренд, redrive
- worker: claim по строке jobs, аренда с heartbeat и fencing по
  lease_token, transform в подпроцессе с RLIMIT_AS/RLIMIT_CPU/таймаутом,
  thumbnail 256, crop 128, WebP 1280 по детерминированным ключам
- retry с backoff и jitter, постоянные/временные ошибки, реестр failed,
  ops replay (ready не повторяется), DLQ для невалидных сообщений
- janitor: очистка staging и сирот; миграция 004 с backfill вложений lab4
- тесты отказов: окна COMMIT/publish, крахи worker до/после S3 и ack,
  заморозка worker, всплеск загрузок, права брокера; evidence/ и REPORT.md
2026-11-13 16:28:18 +03:00

54 KiB
Raw Blame History

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

  • Автор, группа: Лазарев Юрий Сергеевич, БПИ2303
  • Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не заявлен
  • Commit/PR: ветка solution/bpi2303-lazarev; ссылка на PR — после публикации в fork.
  • Использованные источники, библиотеки и помощь ИИ: Python 3.12 (стандартная библиотека), psycopg[binary]==3.2.3, psycopg-pool==3.2.4, minio==7.2.15, urllib3==2.3.0, Pillow==11.1.0 (проверка JPEG и варианты: JPEG, WebP), pika==1.3.2 (AMQP 0-9-1). Образы: python:3.12.7-slim@sha256:60d9996b…b50d, postgres:16.4-alpine@sha256:5660c2cb…e64c, haproxy:3.0.5-alpine@sha256:43a2591a…e949, chrislusf/seaweedfs:4.50@sha256:c2658820…4860, rabbitmq:4.1.4-alpine@sha256:b736d649…63f2 (полные digest — в compose.yaml и Dockerfile). Документация: RabbitMQ (Reliability, Publisher Confirms and Consumer Acknowledgements, Quorum Queues, Dead Letter Exchanges, Definitions, Access Control), Pillow (Image.draft, ImageOps.exif_transpose/fit, WebP/JPEG plugins), PostgreSQL (FOR UPDATE SKIP LOCKED, LISTEN/NOTIFY, advisory locks), AWS Architecture Blog «Exponential Backoff and Jitter», шаблон transactional outbox. Код lab4 перенесён и доработан с помощью ИИ-ассистента (Claude); решения, запуск и проверки — автор.

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

Проверено: MacBook Air M3, 16 GB RAM, macOS 26.4.1; Docker Desktop 28.0.4 (VM 8 vCPU, 7.7 GiB), Compose v2.34.0; Python 3.12 на хосте только для тестов (стандартная библиотека). Порты 127.0.0.1:8080 (LB) и 127.0.0.1:8404 (статистика HAProxy) должны быть свободны — стенд lab4 остановить (docker compose stop в его каталоге).

# 0. Локальные секреты и .env (не коммитятся; значения не печатаются; повтор ничего не перезаписывает).
#    Пароль БД; ключи S3 admin/api/worker/janitor и s3_identities.json; пароли и URL пользователей
#    RabbitMQ relay/worker/ops и rabbitmq_definitions.json (пользователи с хешами, vhost, права, топология).
./scripts/init-secrets.sh

# 1. Проверка конфигурации, сборка, запуск, ожидание готовности (~30–40 с)
docker compose --env-file .env config --quiet
docker compose --env-file .env build
docker compose --env-file .env up -d --wait
#    порядок: db, s3, broker (healthy) -> migrate, s3-init (exit 0) -> api x2, relay, worker x2, janitor -> lb
docker compose ps                    # migrate и s3-init Exited (0); порты только у lb

# 2. Обязательные проверки
make check && make test
make test-persistence ACTION_SCRIPT=scripts/restart.sh       # рестарт db, s3, broker, api, relay, worker, janitor, lb
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && ./scripts/start-all.sh

# 3. Сценарий защиты уровня 3 (worker остановлен -> 202 -> рестарт API и брокера -> worker -> ready -> дубль)
python3 student-tests/worker_outage.py --output evidence/worker-outage.json
#    вручную то же: ./scripts/stop-worker.sh ; upload ; docker compose restart api broker ; ./scripts/start-worker.sh

# 4. Проверки уровня 4 (каждая сама включает/выключает учебные инъекции отказов и возвращает .env-конфигурацию)
docker compose --profile tools run --rm checks /app/student-tests/variants_check.py --base-url http://lb:8080 --output /app/evidence/variants-check.json
docker compose --profile tools run --rm checks /app/student-tests/transform_limits.py --output /app/evidence/transform-limits.json
python3 student-tests/worker_faults.py   --output evidence/worker-faults.json
python3 student-tests/outbox_gap.py      --output evidence/outbox-gap.json
python3 student-tests/lease_takeover.py  --output evidence/lease-takeover.json
python3 student-tests/burst.py --count 24 --output evidence/burst.json
python3 student-tests/broker_permissions.py --output evidence/broker-permissions.json
python3 student-tests/attachments_negative.py --output evidence/attachments-negative.json   # регрессия lab4
python3 student-tests/attachment_failover.py  --output evidence/attachment-failover.json && ./scripts/start-all.sh
docker compose --profile tools run --rm checks /app/student-tests/s3_private_check.py

# 5. Оператор
docker compose --profile tools run --rm ops failed                      # реестр failed
docker compose --profile tools run --rm ops inspect <attachment_id>     # job, события, outbox, варианты, объекты S3
docker compose --profile tools run --rm ops replay <attachment_id> --dry-run
docker compose --profile tools run --rm ops replay <attachment_id> --reason "S3 восстановлен"
docker compose --profile tools run --rm ops dlq [--replay] [--purge-invalid]
docker compose exec broker rabbitmqctl -p messenger list_queues name type messages messages_ready messages_unacknowledged consumers
docker compose run --rm --no-deps janitor python /app/src/janitor.py --once --dry-run

# 6. Безопасная остановка (данные остаются в volumes pgdata, s3data, brokerdata)
docker compose stop                  # или docker compose down (контейнеры удаляются, volumes остаются)

# 7. Намеренное удаление учебных данных (НЕОБРАТИМО: БД, объекты S3, очереди)
docker compose down -v

Один образ mtusi-messenger:lab5 используется восемью сервисами; собирает его только migrate (у остальных pull_policy: never). Раньше build стоял у всех, и на пустом Docker параллельная сборка одного тега упала с image ... already exists. Можно и одной командой up -d --build --wait. Во время работы Docker Desktop дважды аварийно останавливался и один раз завис (сборка висела на «load metadata»); после docker desktop restart всё собралось за секунды, а стенд поднялся сам (restart: unless-stopped) с сохранёнными данными. Миграции, bucket и топология брокера создаются автоматически (job migrate, job s3-init, definitions при старте RabbitMQ) и безопасно повторяются: миграции учитываются в schema_migrations, bucket создаётся только если его нет, definitions импортируются идемпотентно.

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

клиент ─HTTP─> lb (HAProxy) ─> api × 2 ──(1) PUT staging/<uuid>──────────────> s3 (SeaweedFS, s3data)
                                  │      (2) ОДНА транзакция: attachments queued + jobs + outbox
                                  └──────────────────────────────────────────> db (PostgreSQL, pgdata)
                                                      LISTEN/NOTIFY, SKIP LOCKED │
                      relay ─────── publish + confirm ─────> broker (RabbitMQ, quorum, brokerdata)
                      (reaper аренд, redrive)                    │ prefetch 1, manual ack
                                                     worker × 2 (по 2 потребителя)
                                  staging ──> transform.py (подпроцесс, RLIMIT) ──> attachments/<id>/v1/* ──> s3
                                  COMMIT ready + attachment_variants (fencing по lease_token) ──> db, затем ack
                      janitor: сверка БД <-> S3, очистка staging/сирот; ops: inspect/failed/replay/dlq
Роль Service Образ Health/readiness Volume Сеть / порт Credentials
LB lb haproxy:3.0.5-alpine проверка конфигурации; сам проверяет /health/ready API — frontend+backend; 127.0.0.1:8080, :8404 нет
API api ×2 mtusi-messenger:lab5 /health/live, /health/ready (только БД) — backend, 8080 внутри postgres_password, s3_api_*; брокера нет
Брокер broker rabbitmq:4.1.4-alpine check_running, check_local_alarms, очередь объявлена brokerdata backend, 5672 внутри rabbitmq_definitions.json (хеши паролей)
Relay relay mtusi-messenger:lab5 heartbeat-файл ≤ 30 с — backend postgres_password, broker_relay_url
Worker worker ×2 тот же heartbeat-файл ≤ 30 с, только если все потребители живы — (временные файлы в слое контейнера) backend postgres_password, broker_worker_url, s3_worker_*
БД db postgres:16.4-alpine pg_isready pgdata backend postgres_password
S3 s3 chrislusf/seaweedfs:4.50 /healthz и запись в filer s3data backend, только :8333 s3_identities.json
Миграции / bucket migrate, s3-init тот же exit 0 — backend postgres_password / s3_admin_*
Сверка janitor тот же heartbeat ≤ 90 с — backend postgres_password, s3_janitor_*
Оператор, проверки ops, checks (profile tools) тот же — checks: bind student-tests, evidence backend ops: broker_ops_url, s3_janitor_*, БД

Выбор брокера: RabbitMQ 4.1, quorum-очередь

Нужны persistence и подтверждения в обе стороны. У RabbitMQ это штатно: publisher confirm (брокер записал сообщение в quorum-очередь — Raft-журнал на диске — и только после этого присылает ack издателю) и manual consumer ack (сообщение остаётся у брокера, пока потребитель не подтвердит обработку; при обрыве соединения возвращается в очередь). Quorum-очередь durable по определению, переживает рестарт с volume. Дополнительно используются её x-delivery-limit (защита от crash-loop) и dead-lettering at-least-once.

Топология (secrets/rabbitmq_definitions.json, генерирует init-secrets.sh, импортируется при старте):

  • exchange attachments (direct) → очередь attachments.process.v1 (quorum; x-delivery-limit=10, x-dead-letter-exchange=attachments.dlx, x-dead-letter-strategy=at-least-once, x-overflow=reject-publish, x-max-length=100000);
  • exchange attachments.dlx (fanout) → очередь attachments.dlq (quorum);
  • vhost messenger; hostname: broker (имя узла rabbit@broker неизменно, данные volume находятся после пересоздания контейнера).
Пользователь Где configure write read
relay relay — attachments —
worker worker — — attachments.process.v1
ops ops-CLI — attachments attachments.dlq
guest не создаётся

Права проверены broker_permissions.py (см. «Доказательства»). API к брокеру не подключается вовсе: недоступность RabbitMQ не влияет на приём файлов — задания копятся в outbox.

Что сохранено в момент 202

POST /chats/{id}/attachments (src/server.py):

  1. проверки lab4 без изменений: сессия, членство, filename, Content-Type, Content-Length ≤ 10 MiB, потоковый приём во временный безымянный файл с SHA-256, сигнатура, пиксели до распаковки, полный валидатор PNG/JPEG;
  2. INSERT attachments … status='pending' (скрыто от API, как pending в lab4) — БД знает о будущем объекте до записи в S3;
  3. полный проверенный оригинал → staging staging/<случайный uuid> в приватном bucket (S3 — устойчивый staging: SeaweedFS подтверждает PUT после записи на volume);
  4. одна транзакция: attachments.status='queued' + строка jobs + строка outbox (сообщение по jobs.schema.json) + событие job_events. COMMIT;
  5. ответ 202 со снимком status=queued, variants=[], error_code=null.

Значит, к 202 устойчиво сохранены: полный оригинал (staging, S3), метаданные (размер, SHA-256, тип, размеры), задание и намерение его опубликовать (outbox) — всё в PostgreSQL. Сам брокер к этому моменту может ещё ничего не знать: это нормально, outbox будет опубликован relay. Остановка API после ответа ничего не теряет (проверено outbox_gap.py, случай D: API убит после COMMIT, но до отправки 202 — работа всё равно выполнена).

Если шаги 3–4 не удались: PUT неудачен → удаляем объект, затем pending-строку (как в lab4); ошибка на шаге 4 → staging не удаляем (COMMIT мог пройти при обрыве соединения на COMMIT; удалить оригинал принятой работы нельзя), отвечаем 503, pending-остаток уберёт janitor после grace. Ключ конечного оригинала назначается сразу и детерминирован: attachments/<attachment_id>/v<pipeline_version>/original.

Состояния и модель данных (migrations/004_async_processing.sql)

  • attachments.status: pending (внутреннее) → queued → processing → ready | failed; новые колонки staging_key, error_code, pipeline_version.
  • jobs — источник истины по заданию: (attachment_id, pipeline_version) уникально (одна логическая работа = один job_id, не меняется при redelivery/retry/replay), attempt (растёт при каждом захвате), max_attempts, next_attempt_at, аренда lease_owner (hostname:boot_id), lease_token (fencing), lease_until, error_code, last_error, replay_count; CHECK ((status='processing') = (lease_token IS NOT NULL)).
  • attachment_variants — ключ эффекта (attachment_id, pipeline_version, name) = PRIMARY KEY: второго набора вариантов быть не может.
  • outbox — payload jsonb, available_at (отложенная публикация для retry), published_at, publish_count; триггер NOTIFY outbox после вставки.
  • job_events — audit всех переходов (кто, когда, попытка, причина; без секретов и bytes).
  • Переход lab4 → lab5: готовые вложения lab4 не имеют вариантов. Миграция делает их оригинал staging-объектом, вложение — queued, создаёт задание и outbox (готовность не заявляется без вариантов). Проверено на данных формы lab4: evidence/migration-backfill.txt.

Публичный API: GET метаданных показывает queued|processing|ready|failed; variants — только у ready, error_code — только у failed. content для queued/processing → 409 (+Retry-After: 1), для failed → 409; variant=thumbnail|crop|optimized у ready — байты варианта, неизвестный variant → 400, отсутствующий у ready → 404. Сообщение можно отправить с queued/processing/ready вложением, с failed → 409, с pending/чужим → 404.

Outbox relay (src/relay.py)

Цикл: SELECT … FROM outbox WHERE published_at IS NULL AND available_at <= now() ORDER BY available_at, id LIMIT 100 FOR UPDATE SKIP LOCKED → для каждой строки basic_publish(persistent, mandatory) на канале с confirm_delivery() (вызов возвращается после ack брокера, при nack/unroutable — исключение) → UPDATE outbox SET published_at=now() → COMMIT. Ошибка брокера — откат транзакции, строки остаются, переподключение с паузой до 5 с. Будит relay NOTIFY (задержка публикации — миллисекунды), без уведомления — опрос раз в секунду. Несколько relay безопасны (SKIP LOCKED).

Окна отказа: крах между COMMIT API и publish, между publish и confirm, между confirm и UPDATE outbox → строка не помечена → будет опубликована ещё раз. Последнее даёт дубль сообщения — это нормальный at-least-once, его гасит worker (см. ниже).

Reaper (в relay, раз в 5 с, pg_try_advisory_xact_lock — один на всех):

  • processing с истёкшей арендой → queued с backoff и новой строкой outbox (или failed/retry_exhausted, если попытки кончились);
  • queued без движения дольше JOB_REDRIVE_AFTER_SECONDS=900 и без неопубликованного outbox → повторная публикация (если сообщение потеряно вместе с volume брокера);
  • опубликованные строки outbox старше суток удаляются.

Worker (src/worker.py, src/jobs.py, src/transform.py)

  • WORKER_CONCURRENCY=2 потока-потребителя на контейнер, у каждого своё AMQP-соединение и basic.qos(prefetch_count=1); реплик 2 → одновременно не больше 4 заданий. Задание выполняется в отдельном потоке, а поток потребителя продолжает process_data_events — AMQP heartbeat (20 с) не рвётся на долгой обработке.
  • Claim (транзакция, SELECT … FOR UPDATE строки jobs). Решение принимается по БД, а не по факту доставки:
    • ready / failed → no-op, ack (duplicate_ignored);
    • processing с живой арендой другого процесса → ack (busy_ignored): если владелец умер, задание вернёт reaper;
    • processing с живой арендой предыдущего процесса этого же контейнера (тот же hostname, другой boot id) → перехват сразу (lease_taken_over): два процесса одного контейнера одновременно не живут;
    • processing с истёкшей арендой → перехват;
    • queued, но next_attempt_at ещё не наступил → старый дубль, ack (запланированное сообщение relay опубликует в срок);
    • иначе processing, attempt+1, новый lease_token, lease_until=now()+30 с. COMMIT.
  • Аренда и зависание. Отдельный поток продлевает аренду раз в JOB_LEASE_SECONDS/3 (10 с), но не дольше JOB_TIMEOUT_SECONDS+30 от начала. Долгий, но живой worker аренду держит — второй её не трогает; замороженный/зависший процесс продлевать перестаёт, аренда истекает, reaper возвращает задание в очередь. Опоздавший процесс узнаёт о потере аренды (heartbeat вернул 0 строк) и прекращает работу, а complete записывает результат только при совпадении lease_token (fencing). Так два «неконтролируемых» дубля исключены: побочные эффекты в S3 идемпотентны (те же ключи), а публикация результата в БД — только у владельца аренды.
  • Обработка: staging → временный файл (не больше size_bytes из БД; размер и SHA-256 должны совпасть с принятым upload, иначе staging_corrupted) → transform.py в подпроцессе с RLIMIT_AS=768 MiB, RLIMIT_CPU=30 с и wall-clock таймаутом JOB_TIMEOUT_SECONDS=60 → PUT оригинала и вариантов по детерминированным ключам attachments/<id>/v1/{original,thumbnail.jpg,crop.jpg,optimized.webp} → complete (одна транзакция: jobs ready + 3 строки attachment_variants + attachments ready) → удаление staging → ack.
  • Сначала все объекты, потом COMMIT ready: ready никогда не ссылается на отсутствующий объект. Повтор после краха перезаписывает те же 4 объекта: второго набора нет ни в S3, ни в БД.

Варианты (src/transform.py)

Вариант Формат Размер Параметры
thumbnail JPEG вписан в 256×256, без увеличения; целочисленно, вниз, минимум 1 px (320×200 → 256×160) quality 85, optimize
crop JPEG центрированный квадрат 128×128 (ImageOps.fit; маленькие исходники увеличиваются) quality 85
optimized WebP вписан в 1280×1280 без увеличения quality 80, method 4; alpha сохраняется

Общее: EXIF orientation применяется (exif_transpose, размеры считаются после поворота); alpha (RGBA, LA, палитра с прозрачностью) для JPEG компонуется на белый; EXIF, XMP, ICC и комментарии не переносятся (Pillow пишет их, только если передать явно). Цвет считается sRGB: профиль ICC широкого охвата теряется — учебное упрощение. Уменьшение каждого маленького файла не обещается. JPEG декодируется в режиме draft (сразу в 2/4/8 раз меньше, но не меньше 1280 по обеим сторонам) — для 36 Мпикс нужно в разы меньше памяти; все варианты делаются из промежуточной копии ≤ 1280.

Лимиты «плохих» входов: API (lab4) отклоняет > 10 MiB (413), > 40 Мпикс по заголовку (413), битые и чужие форматы (415) ещё до очереди. Worker — вторая линия: лимит байт из метаданных, Image.MAX_IMAGE_PIXELS=40M (превышение — ошибка, а не предупреждение), RLIMIT_AS, RLIMIT_CPU, таймаут, контейнер 1 CPU / 1 GiB. Бомба убивает только подпроцесс, а не worker с его соединениями и арендами.

Retry, ошибки, DLQ, replay

Класс error_code Поведение
постоянные invalid_image, image_too_large, staging_corrupted, staging_missing, resource_limit сразу failed, без повторов
временные storage_unavailable, processing_timeout, processing_failed, lease_expired queued + backoff, пока attempt < JOB_MAX_ATTEMPTS=5; затем failed/retry_exhausted
нет БД — результат записать нельзя: nack(requeue) после паузы 2 с; аренда истечёт, reaper вернёт задание
невалидное сообщение / неизвестный job — basic.reject(requeue=False) → DLX → attachments.dlq
crash-loop (10 доставок без ack) — quorum x-delivery-limit → DLQ; задание в БД остаётся и будет redrive

Backoff: d = min(60, 2·2^(attempt−1)) с, задержка равномерно в [d/2, d] (equal jitter: пауза гарантирована, повторы многих заданий разнесены во времени). Отложенная попытка — строка outbox с available_at = now()+delay; relay публикует её в срок. Отдельной retry-очереди с TTL не нужно.

Реестр failed — сами строки jobs со status='failed' (ops failed: код, попытки, причина, можно ли повторить). DLQ брокера — для сообщений, которые нельзя связать с заданием. Replay (ops replay) — транзакция над строкой jobs: только failed → queued, max_attempts = attempt + 5, replay_count+1, audit replayed, новая строка outbox, тот же job_id и ключ эффекта. ready, queued, processing не трогаются (refused_status_ready…): «повторить» не означает исполнить дубль успешной работы. Replay невозможен после удаления staging по retention (refused_staging_expired). ops dlq --replay разбирает сообщения DLQ по состоянию jobs: failed → replay, остальные → отбросить с audit; --purge-invalid удаляет мусор.

Staging: retention и cleanup

  • ready → worker удаляет staging сразу после COMMIT; не вышло (крах, S3) — janitor (staging_ready_cleaned);
  • failed → staging хранится STAGING_RETENTION_SECONDS=86400 (для replay), затем janitor удаляет;
  • pending старше grace (1 ч; API упал до COMMIT, 202 не было) → janitor удаляет staging и строку;
  • объекты staging/, originals/, attachments/ без ссылки из БД старше grace → удаляются; объекты вложений в queued/processing не трогаются никогда;
  • ready без объекта оригинала или варианта → только отчёт (missing_objects).

Health, лимиты, таймауты (новое относительно lab4)

Параметр Значение Почему
/health/ready API только PostgreSQL брокер и worker не нужны синхронному пути: без них upload → 202, задания ждут
healthcheck broker check_running + check_local_alarms + очередь объявлена relay/worker стартуют после импорта definitions
Worker 2 × 2 потребителя, prefetch 1; 1 CPU / 1 GiB; stop_grace_period 75s (SIGTERM: текущее задание дорабатывается) ограниченная конкуренция; память подпроцессов (замер ниже)
Подпроцесс transform RLIMIT_AS 768 MiB, RLIMIT_CPU 30 с, таймаут 60 с 36 Мпикс PNG — 0,7 с; бомбы ограничены
Аренда 30 с, продление каждые 10 с, предел JOB_TIMEOUT+30 зависший теряет аренду ≤ 30 с + 5 с reaper
Relay / reaper NOTIFY + опрос 1 с; reaper 5 с; redrive 900 с
RabbitMQ vm_memory_high_watermark 0.6, disk_free_limit 256MB, 1 CPU / 512 MiB; x-max-length 100000 + reject-publish при переполнении relay получает nack, задания остаются в outbox
S3 у worker read timeout 10 с; ключ worker: Read+Write без List

Что перенесено из lab4 и что изменено

Перенесены без изменения поведения: весь REST API, сессии, идемпотентность сообщений, X-Instance-Id, graceful shutdown, HAProxy, потоковый upload и валидаторы PNG/JPEG, S3Health, janitor-подход, скрипты stop-one.sh, failover-each.sh, rolling-update.sh. Изменено (объявленный переход 4 → 5): upload 201 ready → 202 queued; оригинал идёт в staging; GET показывает асинхронные состояния и варианты; content у неготовых → 409; queued-вложение можно прикрепить, failed → 409. restart.sh перезапускает и брокер, relay, worker; start-all.sh поднимает и worker; новые stop-worker.sh/start-worker.sh. Тесты lab4 attachments_negative.py, attachment_failover.py, upload_memory.py переведены на 202 + ожидание ready; s3-check стал сервисом checks и проверяет ещё ключ worker.

Соответствие .env.example

Переменная skeleton Реализация
APP_*, SESSION_*, IDEMPOTENCY_TTL_SECONDS, API_REPLICAS, S3_*, MAX_UPLOAD_BYTES, MAX_IMAGE_PIXELS как в lab4 (S3_ENDPOINT=http://s3:8333)
DATABASE_URL_FILE поддерживается; в compose — POSTGRES_* + POSTGRES_PASSWORD_FILE
CACHE_URL_FILE не используется (Redis/Valkey нет)
BROKER_URL_FILE у каждого сервиса свой файл: /run/secrets/broker_relay_url, broker_worker_url, broker_ops_url
WORKER_CONCURRENCY=2 потоков-потребителей на контейнер (prefetch 1 каждый), реплик — WORKER_REPLICAS=2
JOB_MAX_ATTEMPTS=5, JOB_TIMEOUT_SECONDS=60 как есть
STAGING_RETENTION_SECONDS=86400 retention staging failed-заданий (janitor)
добавлены WORKER_REPLICAS, WORKER_PREFETCH, JOB_LEASE_SECONDS, JOB_RETRY_BASE_SECONDS, JOB_RETRY_MAX_SECONDS, PIPELINE_VERSION, TRANSFORM_MEMORY_LIMIT_MB, TRANSFORM_CPU_SECONDS, RELAY_POLL_SECONDS, REAPER_INTERVAL_SECONDS, JOB_REDRIVE_AFTER_SECONDS, OUTBOX_RETENTION_SECONDS; учебные RELAY_FAULT, WORKER_FAULT_INJECTION, FAULT_SLOW_SECONDS (по умолчанию выключены)

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

Все прогоны — 13.11.2026 на итоговом коде одной командой ./student-tests/run_all.sh (результат overall=0, 18/18). Машина и лимиты — как выше. Лог каждой команды — evidence/<имя>.txt, подробности — evidence/<имя>.json.

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make check, make test PASS: 202 → ready, оригинал побайтно, настоящий JPEG thumbnail 256×160 evidence/check.txt, evidence/smoke.txt
3: минимум lab4 сохранён (201 → 202), restart с volumes make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS, тот же токен и тот же файл; StartedAt изменился у всех 10 контейнеров (db, s3, broker, api×2, relay, worker×2, janitor, lb) evidence/persistence.txt, evidence/containers-{before,after}-restart.txt
3: failover API (lab3) make test-failover ACTION_SCRIPT=scripts/stop-one.sh PASS: 2 реплики, 131 запись, 0 неуспешных, восстановление 3,7 с evidence/failover.txt
3: регрессия вложений lab4 attachments_negative.py, attachment_failover.py 60/60, 0 ответов 5xx; download через другую реплику 2/2 раунда evidence/attachments-negative.json, evidence/attachment-failover.json
3: 202 только после устойчивого приёма; остановка API после ответа не теряет работу outbox_gap.py D API убит (os._exit) после COMMIT до отправки 202: клиент получил 502 от LB, задание дошло до ready evidence/outbox-gap.json
3: отдельные broker и worker, durable, at-least-once, ack после эффекта compose.yaml; worker_outage.py; rabbitmqctl list_queues quorum-очереди durable; при остановленных worker сообщение лежит messages_ready=1, consumers=0 evidence/worker-outage.json, evidence/queues.txt
3: недоступность worker не делает resize в API worker_outage.py при остановленных worker upload 202 queued; content и thumbnail 409; сообщение с queued-вложением и обычное — 201 evidence/worker-outage.json
3: queued/processing/ready/failed в API; оригинал + thumbnail по контракту make test, variants_check.py, worker_faults.py все 4 состояния наблюдаются; 7 входов: размеры, формат, SHA-256 совпадают; оригинал неизменен evidence/variants-check.json, evidence/worker-faults.json
3: ограниченный retry, финальное failed с error_code; повтор не создаёт второй набор worker_faults.py transient-always, повторная доставка в worker_outage.py 5 попыток → failed/retry_exhausted; дубль job → duplicate_ignored, 3 варианта, 4 объекта. Во всём bucket 436 объектов attachments/ = 109 ready × 4 evidence/worker-faults.json, evidence/janitor-dry-run.txt
3: демонстрация worker stop → 202 → API restart → worker start → ready; рестарт broker с volume worker_outage.py 202 на 2,7 с; рестарт API (16 с), рестарт брокера (21 с) — сообщение на месте; worker запущен — ready через 0,03 с evidence/worker-outage.json
4: crop 128×128 и WebP по контракту, параметры качества и метаданные variants_check.py crop 128×128 JPEG, optimized WebP ≤ 1280 без увеличения; EXIF orientation применена; прозрачное → белое; EXIF/ICC в вариантах нет evidence/variants-check.json
4: лимиты bytes / пикселей / времени / памяти worker transform_limits.py (+ лимиты API lab4) 49 Мпикс → image_too_large; память 160 MiB → resource_limit; CPU 1 с → убит SIGXCPU; таймаут 0,5 с → processing_timeout; битые → invalid_image. 9/9 evidence/transform-limits.json
4: outbox; crash между COMMIT и publish → ready без нового задания outbox_gap.py A, B, C A: relay остановлен — outbox не опубликован, очередь пуста; после запуска — ready, одно задание. B: relay умер посреди батча (RestartCount 0 → 1) — ready. C: дубль публикации → duplicate_ignored evidence/outbox-gap.json
4: backoff + jitter, постоянные ≠ временные, DLQ/реестр, безопасный replay worker_faults.py задержки 0,95 / 1,51 с в границах [0,5; 1] и [1; 2]; подмена staging → staging_corrupted с 1-й попытки; ops failed; replay → ready; replay ready → refused_status_ready; мусор → DLQ → --purge-invalid evidence/worker-faults.json, evidence/failed-registry.txt
4: остановка worker после записи объекта до ack worker_faults.py crash-after-s3-put, crash-after-commit после S3 до COMMIT: аренда истекла, попытка 2 записала те же 4 объекта; после COMMIT до ack: redelivery → no-op evidence/worker-faults.json
4: timeout/lease для зависшего processing lease_takeover.py долгий worker держит аренду (heartbeat); замороженный (docker pause) теряет: задание завершено другим worker через 25,1 с; после разморозки — aborted_lease_lost, результат не изменён evidence/lease-takeover.json
4: ограниченная конкуренция/prefetch burst.py --count 24, rabbitmqctl list_consumers 4 потребителя, prefetch 1; одновременно в обработке максимум 4; 24 файла по 6,75 MB — все ready за 7,2 с evidence/burst.json
4: очистка staging после безопасной фиксации ops inspect, burst.py, janitor staging_deleted после ready во всех сценариях; staging остался только у 3 failed (retention для replay); crash-after-commit — staging убрал janitor evidence/burst.json, evidence/janitor-dry-run.txt
Минимальные права брокера и S3 broker_permissions.py, s3_private_check.py матрица relay/worker/ops как в таблице, configure — ни у кого, guest нет, 5672 на хост не опубликован; S3: 26/26 (новый ключ worker: Get/Put/Delete да, List/CreateBucket нет) evidence/broker-permissions.json, evidence/s3-private-check.txt
Переход lab4 → lab5 миграция 004 на данных lab4 ready-вложение lab4 → queued + задание + outbox по схеме evidence/migration-backfill.txt

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

Окна отказа (сводка; методика — учебные инъекции, включаемые только тестами)

Инъекции: у API — заголовок X-Fault-Inject при FAULT_INJECTION=1 (из lab4); у relay — RELAY_FAULT=<точка> (один раз за жизнь контейнера); у worker — имя файла fault-<точка>.png при WORKER_FAULT_INJECTION=1, крах — os._exit(86) один раз на задание (как SIGKILL, без finally). Каждый тест возвращает сервисы к конфигурации .env.

Воздействие (окно из attachment-states.md) Что ожидаем Что наблюдали Время восстановления / потеря данных
API умер после staging до записи задания 202 нет, работа не принята; остаток убирается pending-строка без задания, GET 404; janitor (grace 2 с в тесте): dry-run нашёл, боевой удалил строку и объект grace (1 ч по умолчанию) / 0 принятых
API умер после COMMIT до 202 работа принята, хотя клиент не узнал клиент: 502 от LB; задание ready секунды / 0
Relay остановлен (COMMIT есть, publish нет) outbox ждёт published_at=null, очередь 0; после старта — ready, одно задание до запуска relay / 0
Relay умер между COMMIT и publish повтор публикации RestartCount 0 → 1, ready ~1 с (рестарт контейнера) / 0
Relay умер после confirm до published_at дубль сообщения вторая доставка → duplicate_ignored, 3 варианта 0 / 0, дубль погашен
Worker умер после claim аренда истекает, задание повторяется busy_ignored → lease_expired → попытка 2 → ready ~33 с (аренда 30 с + reaper) / 0
Worker умер после записи S3 до COMMIT повтор перезаписывает те же ключи попытка 2, ровно 4 объекта и 3 строки вариантов ~35 с / 0
Worker умер после COMMIT до ack redelivery — no-op duplicate_ignored; staging убрал janitor секунды / 0
Временная ошибка ×2 backoff с jitter, ready задержки 0,95 и 1,51 с, ready на 3-й попытке ~3 с / 0
Временная ошибка всегда 5 попыток, failed, replay retry_exhausted; content 409, прикрепление 409; replay → ready (attempt 6, replay_count 1) по решению оператора / 0
Подмена staging постоянная ошибка, без повторов staging_corrupted с 1-й попытки — (нужен человек)
Мусорное сообщение DLQ reject → DLQ → ops dlq --purge-invalid —
Worker заморожен (docker pause) аренда истекает, другой worker завершает, опоздавший не пишет ready через 25,1 с после паузы; разморозка → aborted_lease_lost, метаданные те же 25 с / 0
Рестарт брокера с volume при остановленных worker сообщение сохраняется messages_ready=1 до и после — / 0
Рестарт всего стенда (persistence hook) и двукратный аварийный рестарт Docker Desktop данные, сессии, очередь целы PASS; после аварий стенд поднялся сам, данные на месте ~40 с / 0

Почему восстановление после краха worker ~33 с, а не мгновенно. После os._exit контейнер перезапускается, но redelivered-сообщение брокер чаще отдаёт потребителю другого контейнера. Тот видит чужую живую аренду и не трогает задание (busy_ignored): отличить мёртвого владельца от долгого он не может. Ждём истечения аренды (30 с) + проход reaper (≤ 5 с). Мгновенный перехват срабатывает, только когда сообщение получил перезапущенный контейнер-владелец (тот же hostname, новый boot id). Компромисс: меньший JOB_LEASE_SECONDS ускоряет восстановление, но чаще ложно отбирает задания у живых worker при паузах GC или БД.

Эксперимент: замороженный worker и fencing (lease_takeover.py)

Гипотеза: аренда с heartbeat отличает долгий процесс от зависшего, а lease_token не даёт опоздавшему перезаписать результат. Методика: аренда 10 с, fault-slow (25 с работы после claim), docker pause владельца через 9 с.

Первый прогон нашёл два недостатка:

  1. Сообщение, выданное по prefetch второму (свободному) потребителю замороженного контейнера, висело ~35 с — до таймаута AMQP heartbeat (20 с), только потом брокер вернул его в очередь. Исправлено: heartbeat 10 с.
  2. Опоздавший worker после разморозки успевал сделать шаг: он читал staging (уже удалённый победителем). Флаг потери аренды выставлял фоновый поток раз в 10 с. Запись результата всё равно отклонилась по lease_token (error_ignored_lease_lost), но правильнее не делать побочных эффектов вовсе. Исправлено: перед чтением staging, перед записью в конечный prefix и перед COMMIT аренда синхронно продлевается/проверяется в БД.

После исправлений: ready через 25,1 с после паузы (было ~55 с), опоздавший — aborted_lease_lost до записи в S3, вариантов 3, объектов 4.

Всплеск загрузок (burst.py)

24 несжимаемых PNG 1500×1500 (6,75 MB), 8 параллельных загрузок через LB; стенд с лимитами выше, клиент на той же машине, один прогон — иллюстрация.

Метрика Значение
приём 24 × 202 2,3 с
все ready 7,2 с от начала (3,3 задания/с)
потребителей × prefetch 4 × 1
одновременно в обработке (по job_events) max 4
задержка очереди (enqueued → claimed) p50 2,4 с, p95 4,1 с
enqueued → ready p50 2,9 с, p95 4,9 с
обработка одного задания p50 0,77 с, max 1,65 с
пик памяти контейнера worker (docker stats, шаг 1 с) 42 / 100 MiB при лимите 1 GiB
staging после всех ready 0

Вывод: конкуренция ограничена именно числом потребителей × prefetch, лишняя работа ждёт в очереди (растёт задержка, а не память). Пиковая память — грубая оценка: выборка раз в секунду пропускает короткие пики подпроцесса; верхнюю границу задают RLIMIT_AS 768 MiB × 2 потока и лимит контейнера 1 GiB. Худший допустимый вход (36 Мпикс PNG) проходит transform за 0,7 с (transform_limits.py).

Вопросы защиты

  • Publisher confirm vs consumer ack. Confirm — граница «брокер принял»: RabbitMQ записал сообщение в quorum-очередь и отвечает ack издателю (relay); только после него relay ставит published_at. Ack потребителя — граница «работа устойчиво выполнена»: worker подтверждает брокеру только после COMMIT ready (или записи failed/retry) в PostgreSQL; до этого сообщение у брокера и вернётся при обрыве. Это разные стороны и разные события; ни одно не заменяет другое.
  • Что сохранено в момент 202: полный проверенный оригинал в staging/ S3, метаданные вложения, строка jobs и строка outbox — одним COMMIT. Брокер может ещё не знать о задании (публикует relay).
  • Почему повторная доставка нормальна и где ключ идемпотентности. At-least-once: дубль возникает при крахе между publish и отметкой outbox, между COMMIT и ack worker, при redrive, при replay DLQ. Ключ — job_id (строка jobs, решение по её состоянию под FOR UPDATE) и ключ эффекта (attachment_id, pipeline_version, variant) (PK attachment_variants и детерминированные ключи S3). Это не exactly-once доставка: эффект однократен за счёт идемпотентности, а не брокера.
  • Зависший vs долго работающий. Долго работающий продлевает аренду heartbeat-ом (каждые 10 с) — второй worker видит живую аренду и не трогает задание. Зависший (замороженный, мёртвый) продлевать перестаёт — аренда истекает, reaper возвращает задание. Продление ограничено JOB_TIMEOUT+30 с, а transform убивается таймаутом, поэтому «живой, но бесконечный» процесс тоже теряет аренду. Опоздавший процесс не может опубликовать результат: complete требует его lease_token (fencing).

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

  • Выдерживается: остановка или падение API-реплики (в том числе после COMMIT до ответа), relay (в любом окне), worker (в любом окне), зависание или заморозка worker, рестарт брокера, БД, S3 и всего стенда с volumes, дубли и переупорядочивание сообщений (решение — по строке jobs), временные ошибки S3 (retry), невалидные изображения и сообщения.
  • Не выдерживается: потеря volume pgdata (источник истины: задания и outbox) или s3data; отказ единственного PostgreSQL, S3, брокера или LB (работа ждёт, но не теряется, пока целы volumes); потеря Docker-host. RabbitMQ — один узел: quorum-очередь здесь даёт durability на диске, но не репликацию.
  • Потеря volume брокера не теряет принятые задания: они в PostgreSQL. Reaper повторно публикует queued-задания без движения через JOB_REDRIVE_AFTER_SECONDS=900. Это не проверялось экспериментом (down -v только для брокера не выполнялся) — гипотеза по коду.
  • Восстановление после краха worker — до ~35 с (аренда 30 с + reaper 5 с), если redelivery достался другому контейнеру; см. «Эксперименты».
  • Это не exactly-once доставка. Сообщения могут приходить повторно и не по порядку. Однократен эффект: решение принимается по строке jobs, ключ эффекта — PK вариантов и детерминированные ключи S3. Опоздавший worker теоретически может перезаписать объект S3 теми же байтами в окне между последней проверкой аренды и PUT. Байты детерминированы (тот же вход, те же параметры, тот же Pillow), а метаданные он не публикует. При смене версии Pillow байты могут отличаться — тогда это задача versioned pipeline (трек 2), здесь не реализовано.
  • Один pipeline_version=1. Колонки и проверки для нескольких версий есть (superseded, pipeline_version <=), но сценарии нескольких версий не проверялись.
  • NOTIFY не гарантирует доставку — relay дополнительно опрашивает outbox раз в секунду.
  • Учебные упрощения: ICC-профили в вариантах теряются (sRGB предполагается); docker stats раз в секунду — грубая оценка памяти; хуки отказов (FAULT_INJECTION, RELAY_FAULT, WORKER_FAULT_INJECTION) в обычной конфигурации выключены, но в lab7 их код стоит удалить.
  • Права SeaweedFS грубее IAM: у worker Write = Put + Delete на весь bucket (нужен для удаления staging), разделения по prefix нет.
  • Следующие шаги: трек 1 (нагрузка с разными concurrency/prefetch и backpressure) или трек 2 (versioned pipeline и автоматический fault-injection); метрики очереди, outbox lag и аренд для lab6; ускорение восстановления (короче аренда, basic.nack на чужой живой аренде с задержкой).