Асинхронная обработка вложений: 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
54 KiB
Отчёт — лабораторная 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):
- проверки lab4 без изменений: сессия, членство, filename, Content-Type, Content-Length ≤ 10 MiB, потоковый приём во временный безымянный файл с SHA-256, сигнатура, пиксели до распаковки, полный валидатор PNG/JPEG;
INSERT attachments … status='pending'(скрыто от API, как pending в lab4) — БД знает о будущем объекте до записи в S3;- полный проверенный оригинал → staging
staging/<случайный uuid>в приватном bucket (S3 — устойчивый staging: SeaweedFS подтверждает PUT после записи на volume); - одна транзакция:
attachments.status='queued'+ строкаjobs+ строкаoutbox(сообщение поjobs.schema.json) + событиеjob_events. COMMIT; - ответ 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 с.
Первый прогон нашёл два недостатка:
- Сообщение, выданное по prefetch второму (свободному) потребителю замороженного контейнера, висело ~35 с — до таймаута AMQP heartbeat (20 с), только потом брокер вернул его в очередь. Исправлено: heartbeat 10 с.
- Опоздавший 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)(PKattachment_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на чужой живой аренде с задержкой).