Files
mtusi2026lab5/REPORT.md

38 KiB
Raw Permalink Blame History

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

  • Автор, группа: Кораблев Петр, БВТ2304
  • Целевая оценка: 5 (уровень 3 + уровень 4 + трек 1 «Очередь под перегрузкой»)
  • Commit/PR: ветка solution/BVT2304-korablev
  • Использованные источники, библиотеки и помощь ИИ: Go 1.23.4, pgx/v5 5.7.2, go-redis/v9 9.7.0, minio-go/v7 7.0.82 (из lab4); новые: github.com/rabbitmq/amqp091-go 1.10.0 (AMQP-клиент), golang.org/x/image 0.23.0 (draw.CatmullRom для ресайза), github.com/gen2brain/webp 0.5.2 (libwebp, скомпилированный в WebAssembly и исполняемый через wazero 1.8.1 — кодирование WebP без cgo). Образы: PostgreSQL 17.2-alpine3.21, Valkey 8.0.2-alpine3.21, HAProxy 3.0.5-alpine, SeaweedFS 3.80, RabbitMQ 4.0.5-management-alpine, golang:1.23.4-alpine3.21 → alpine:3.21.2, для служебных проверок python:3.12.8-alpine3.21. Документация: RabbitMQ Reliability / Confirms / Quorum queues, EXIF 2.32 (тег Orientation 0x0112). Помощь ИИ использовалась при написании отчёта.

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

Prerequisites: Docker 29.x + Compose v2 (Docker Desktop/WSL2), Python 3.9+, Git. Go и make локально не нужны (сборка в Docker; без make команды ниже выполняются через python). На Windows тесты запускать с PYTHONUTF8=1.

python3 scripts/init_secrets.py                       # = make secrets: secrets/* + .env из .env.example
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait   # = make up; ждёт healthy и завершения migrate/s3-init
make check && make test                               # smoke через LB http://localhost:8080
make unit                                             # Go unit-тесты imaging (размеры, EXIF, alpha, лимиты)
make test-persistence ACTION_SCRIPT=scripts/restart.sh   # Windows: scripts/restart.cmd
make test-failover    ACTION_SCRIPT=scripts/stop-one.sh  # Windows: scripts/stop-one.cmd
docker compose up -d --no-recreate --wait api            # вернуть остановленную реплику
make ops                                              # сценарии отказов уровней 3/4 -> evidence/*.json
make track1                                           # трек 1 -> evidence/track1/*.json (~15 мин)
  • init_secrets.py дополнительно к lab4 создаёт secrets/rabbitmq_auth.conf (пользователь messenger со случайным паролем; монтируется как Compose secret в /etc/rabbitmq/conf.d/20-auth.conf, гостевой пользователь не создаётся) и secrets/broker_url (AMQP URL для API/worker через BROKER_URL_FILE). Всё в secrets/ (в .gitignore/.dockerignore).
  • Порядок старта (depends_on): postgres/valkey/s3/rabbitmq healthy → migrate (миграции под advisory lock, теперь 0001–0004) → s3-init → api ×2 и worker → lb.
  • FAULT_INJECTION=1 в .env включает учебные триггеры сбоев по имени файла fault-* (см. ниже). Вне стенда выставить 0.
  • Остановка worker для демонстрации: scripts/stop-worker.sh / .cmd (= docker compose stop worker), запуск — scripts/start-worker.sh / .cmd.
  • Безопасная остановка: docker compose stop (make down), volumes pgdata, s3data, mqdata сохраняются. Намеренное удаление учебных данных: docker compose down -v (необратимо).

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

client → HAProxy (lb, 127.0.0.1:8080) → api ×2 ──┬─ PostgreSQL: attachments, attachment_jobs, job_outbox,
                                                  │              job_events, attachment_variants (+ всё из lab4)
                                                  ├─ S3 staging/<att_id>          (оригинал до обработки)
                                                  └─ outbox relay ──publish+confirm──► RabbitMQ
                                                                                        exchange attachments
                                                                                        quorum queue attachment.process.v1
                                                                                        DLX → attachment.process.dlq
worker (отдельный процесс/контейнер) ◄──prefetch=N, manual ack──┘
   ├─ claim/lease в PostgreSQL → читает staging → пишет в S3 attachments/<chat>/<att> (оригинал)
   │   и variants/<chat>/<att>/v1/{thumbnail.jpg,crop.jpg,optimized.webp} → COMMIT результата → удаляет staging → ack
   ├─ outbox relay (тот же код, что в API; SKIP LOCKED — несколько relay безопасны)
   └─ sweeper: истёкшие lease → queued; retention staging; зависшие pending-загрузки

Источник истины — PostgreSQL: строка attachment_jobs определяет, нужно ли что-то делать; сообщение брокера — только «разбудить worker» с job_id/attempt (contracts/jobs.schema.json, без байтов, ключей и URL). Worker берёт доверенные метаданные (ключи, тип, sha256) из БД.

Upload, транзакционные границы (src/internal/api/attachments.go, src/internal/store/jobs.go):

  1. аутентификация → членство (чужой — 404) → filename → Content-Type → Content-Length ≤ 10 MiB → дешёвая предпроверка размера очереди (MAX_ACTIVE_JOBS, иначе 503 + Retry-After: 5) → тело через MaxBytesReader → magic bytes + image.DecodeConfig (только заголовок: >40 Мпикс → 413). Полное декодирование и ресайз API больше не делает — только worker, даже если worker недоступен.
  2. INSERT attachments status='pending' (невидима в API) → PUT staging/<att_id> (приватный prefix того же bucket, persistent volume S3).
  3. Одна транзакция: pg_advisory_xact_lock + повторный подсчёт активных jobs (строгая граница), pending→queued, INSERT attachment_jobs, INSERT job_outbox, INSERT job_events('queued') → COMMIT → 202 queued. Значит, в момент 202 устойчиво сохранены: полный проверенный оригинал в S3 staging, метаданные, job и намерение публикации (outbox). Сообщения в брокере в этот момент может ещё не быть — это нормально.
  4. Ошибка на 2/3 → 503 и компенсация (удаляем pending-строку, затем staging-объект). Оставшееся (БД недоступна) убирает sweeper через PENDING_UPLOAD_GRACE=15m.

Transactional outbox (src/internal/relay): relay берёт job_outbox WHERE published_at IS NULL AND available_at<=now() FOR UPDATE SKIP LOCKED, публикует persistent-сообщение и ждёт publisher confirm, только потом ставит published_at в той же транзакции. Relay работает в каждом API (сразу после COMMIT его «пинают») и в worker, плюс опрос раз в секунду. Падение между COMMIT и publish → строку опубликует любой живой relay. Падение после publish до отметки → повторная публикация, т.е. дубль сообщения, который worker обезвреживает (ниже). Недоступность RabbitMQ не ломает upload: 202 продолжает отдаваться, строки копятся в outbox.

Broker — RabbitMQ 4.0.5, quorum-очередь (реплицируемый журнал на volume mqdata, durable), x-delivery-limit=20 и DLX → attachment.process.dlq для poison/malformed сообщений. Publisher confirms на стороне relay, manual ack на стороне worker, prefetch = WORKER_CONCURRENCY.

Worker (src/internal/worker/worker.go), на каждую доставку:

  1. Проверка схемы сообщения; некорректное → nack(requeue=false) → DLQ.
  2. ClaimJob(job_id, attempt) под SELECT … FOR UPDATE: ready/failed → no-op ack; attempt в сообщении ≠ текущему → устаревший дубль, ack; processing с живым lease → ack (работу держит другой); retry ещё не наступил → ack. Иначе processing, lease_owner, lease_until=now()+JOB_LEASE_SECONDS. Redelivery (флаг redelivered от RabbitMQ) разрешает перехват lease немедленно: брокер переотдаёт сообщение только после закрытия канала прежнего держателя (crash/kill), поэтому ждать истечения lease не нужно.
  3. Чтение оригинала из staging (если staging уже удалён — из конечного ключа), сверка sha256/size с БД, обработка с ограничениями (ниже), запись оригинала и вариантов по детерминированным ключам ((attachment_id, pipeline_version, variant) → один ключ S3) — повтор перезаписывает те же байты, второго набора не появляется.
  4. CompleteJob — одна транзакция: UPDATE job SET ready WHERE job_id AND attempt AND status='processing', INSERT attachment_variants … ON CONFLICT DO NOTHING, attachment → ready. Устаревшая попытка получает 0 строк и ничего не меняет: ready никогда не откатывается.
  5. Удаление staging (после COMMIT), staging_key=NULL → ack.

Ошибки и повторы: imaging.PermanentError (invalid_image, image_too_large, checksum mismatch) → сразу failed. Временные (storage_unavailable, processing_timeout, lease_expired, injected_transient) → queued, attempt+1, новая outbox-строка с available_at = now() + backoff, backoff экспоненциальный с jitter «equal jitter»: d = JOB_BACKOFF_BASE·2^(attempt-1) (cap JOB_BACKOFF_MAX=60s), ожидание равномерно в [d/2, d]. После JOB_MAX_ATTEMPTS=5 → failed / retry_exhausted. Отложенный повтор реализован через outbox, поэтому не нужен delayed-плагин RabbitMQ и повтор переживает рестарт брокера. Если сама БД недоступна при фиксации — nack(requeue=true).

Реестр failed и replay: attachment_jobs WHERE status='failed' + аудит job_events (каждая попытка, причина, кто сделал replay). Явный операторский replay: docker compose exec worker /app/server replay <attachment_id> --actor <name> — только failed → queued, тот же job_id (тот же логический эффект), новый бюджет попыток, запись в аудит. Для ready replay отказывает (noop), для queued/processing — тоже; если staging уже удалён retention-ом — refused. DLQ брокера содержит только сообщения, которые нельзя разобрать (по ним нет job).

Lease / зависший vs долгий worker: живой worker продлевает lease (heartbeat каждые lease/3), но не дольше JOB_TIMEOUT_SECONDS=60 — потом сам прерывает попытку как processing_timeout. Зависший (нет heartbeat) теряет lease через JOB_LEASE_SECONDS=30, sweeper (каждые 5 с) переводит job в queued с attempt+1. Если «оживший» старый worker всё же досчитает, его CompleteJob с прежним attempt ничего не изменит. Два одновременных исполнителя возможны только в окне сетевого разрыва; они пишут одинаковые байты по одинаковым ключам, а результат фиксирует ровно один.

Варианты (pipeline_version=1), src/internal/imaging/imaging.go: EXIF Orientation (1–8) применяется до ресайза, alpha компонуется на белый, метаданные не копируются ни в один вариант (энкодерам передаются только пиксели).

  • thumbnail: JPEG q=85, вписан в 256×256 без увеличения, размеры округляются вниз целочисленно (320×200 → 256×160), минимум 1 px.
  • crop: JPEG q=85, центральный квадрат исходника → 128×128 (маленькие увеличиваются).
  • optimized: WebP lossy q=80, method=4, вписан в 1280×1280 без увеличения, без EXIF/ICC/XMP. Уменьшение размера маленьких файлов не обещается.
  • Ресайз — Catmull-Rom (x/image/draw).

Лимиты worker: ≤10 MiB bytes (повторная проверка), ≤40 Мпикс по заголовку до декодирования, общий бюджет памяти декодирования WORKER_DECODE_BUDGET_BYTES=384 MiB (взвешенный семафор по оценке пиксели·8 + 6.5 MiB; таймаутнувшая попытка держит свою долю до реального завершения декодера), время JOB_TIMEOUT_SECONDS, контейнер 768M/2 CPU, GOMEMLIMIT=600MiB, prefetch=concurrency.

Staging cleanup: удаляется сразу после COMMIT ready; у failed хранится STAGING_RETENTION_SECONDS=86400 (для replay), потом sweeper удаляет; брошенные pending — через 15 мин. Текущую работу (queued/processing) sweeper не выбирает.

API-переход 4 → 5: upload 201 ready → 202 queued; GET /attachments/{id} показывает queued/processing/ready/failed, variants только у ready, error_code только у failed; content (любой variant) для не-ready → 409, отсутствующий variant у ready → 404, неизвестный → 400; к сообщению можно прикрепить queued/processing/ready, failed → 409.

Что перенесено из lab4 и что изменено. Перенесены без изменений пользователи, сессии (Argon2id, Valkey-кэш), чаты, сообщения, идемпотентность, keyset-пагинация, X-Instance-Id, HAProxy, S3 (SeaweedFS), privacy bucket, хуки restart/stop-one. Изменено: upload (staging + outbox вместо прямого PUT в конечный ключ), из API убрано полное декодирование, restart.* теперь перезапускает и RabbitMQ/worker. Удалён reconciler lab4 (трек 2 lab4): он считал «осиротевшими» все объекты вне attachments/, т.е. удалил бы staging и варианты; его функции по staging/pending взял sweeper worker. Сверка S3↔БД для вариантов в этой работе не реализована (см. ограничения).

Соответствие .env.example: BROKER_URL_FILE, WORKER_CONCURRENCY (= prefetch), JOB_MAX_ATTEMPTS, JOB_TIMEOUT_SECONDS, STAGING_RETENTION_SECONDS, S3_*, MAX_UPLOAD_BYTES, MAX_IMAGE_PIXELS используются как есть; добавлены MAX_ACTIVE_JOBS, JOB_LEASE_SECONDS, JOB_BACKOFF_BASE/MAX, WORKER_DECODE_BUDGET_BYTES, WORKER_MEMORY/CPUS/GOMEMLIMIT, PENDING_UPLOAD_GRACE, FAULT_INJECTION. S3_ENDPOINT в примере исправлен на http://s3:8333 (SeaweedFS).

Роль Service Образ Health Volume Сеть / порт Credentials
LB lb haproxy:3.0.5-alpine :8404/healthz — app; 127.0.0.1:8080 —
API ×2 api mtusi-messenger:lab5 /health/ready (только PostgreSQL) нет (read-only rootfs) app, data database_url, cache_url, broker_url, s3_*
Worker worker mtusi-messenger:lab5 (worker) — (restart unless-stopped) нет (read-only rootfs) data database_url, broker_url, s3_*
Broker rabbitmq rabbitmq:4.0.5-management-alpine check_port_connectivity mqdata data, не публикуется rabbitmq_auth.conf
БД postgres postgres:17.2-alpine3.21 pg_isready pgdata data pg_password
Сессии valkey valkey/valkey:8.0.2-alpine3.21 ping — data valkey_auth
S3 s3 chrislusf/seaweedfs:3.80 :8333/healthz s3data data s3_identities.json
Bootstrap migrate, s3-init mtusi-messenger:lab5 one-shot — data database_url / s3_admin_*

/health/ready зависит только от PostgreSQL: недоступность брокера/worker/S3 не снимает API с балансировки (текстовый мессенджер работает, upload при живом S3 продолжает отдавать 202 через outbox).

Учебные триггеры сбоев (FAULT_INJECTION=1, срабатывают один раз на файл по префиксу имени): fault-api-after-commit (API os.Exit после COMMIT до publish/ответа), fault-worker-after-effect (после записи S3 до COMMIT), fault-worker-before-ack (после COMMIT до ack), fault-transient (попытки 1–2 падают), fault-flaky (падают все попытки до replay), fault-hang (попытка 1 «замерзает» на 3×lease без heartbeat).

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

Окружение: Windows 11, Docker Desktop 29.7.2 (WSL2); лимиты: API 1 CPU/512M ×2, worker 2 CPU/768M (GOMEMLIMIT=600MiB), RabbitMQ 1 CPU/512M, S3 1 CPU/1G, PostgreSQL 2 CPU/1G. Дата прогона — 2026-11-11/12.

Уровень 3

Критерий README Команда/сценарий Наблюдаемый результат Файл
Публичный smoke (202 → ready, оригинал, JPEG thumbnail 256×160) make test PASS: lab5 public API scenario evidence/smoke.txt
Минимум lab4 сохранён, сохранность после рестарта всех хранилищ make test-persistence ACTION_SCRIPT=scripts/restart.cmd (stop api/worker/lb, restart postgres/valkey/s3/rabbitmq) PASS: persistence preserved confirmed data and existing session evidence/persistence.txt
Отказ одной API-реплики make test-failover ACTION_SCRIPT=scripts/stop-one.cmd 117 записей, 0 ошибок, восстановление 3.97 с, PASS evidence/failover.txt
202 только после устойчивого приёма; остановка API после ответа не теряет работу lab5ops.py worker-down: worker остановлен → upload → restart api + restart rabbitmq → start worker 202 queued; сообщение с queued-вложением 201; content 409; текстовые сообщения 201; в очереди 1 сообщение до и после рестарта API+broker; после старта worker ready за 0.34 с evidence/worker-down.json
Отдельные broker и worker, durable + at-least-once, ack после эффекта compose.yaml (rabbitmq quorum, worker), сценарии effect-crash/ack-crash Сообщение пережило рестарт брокера с volume; повтор доставки после убийства worker завершил ту же job evidence/worker-down.json, evidence/effect-crash.json
Недоступность worker не вызывает синхронный resize API не декодирует изображения вообще (inspectImage читает только заголовок) upload при остановленном worker 202, статус queued до запуска worker evidence/worker-down.json
Состояния queued/processing/ready/failed; thumbnail по контракту; original неизменен worker-down, invalid, replay seen processing→ready, failed (invalid_image / retry_exhausted); thumbnail реальный JPEG 256×160; sha256 оригинала совпадает evidence/*.json (ready_check)
Ограниченный retry + финальный failed с безопасным кодом lab5ops.py replay (JOB_MAX_ATTEMPTS=5) 5 попыток → failed, error_code=retry_exhausted, без stack trace evidence/replay.json
Повтор одной job не создаёт второго набора effect-crash, ack-crash, hang везде variant_rows=3, в S3 variants/<chat>/<att>/ ровно 3 объекта evidence/effect-crash.json, ack-crash.json, hang.json

Уровень 4

Критерий README Команда/сценарий Наблюдаемый результат Файл
crop 128×128 и optimized WebP; параметры описаны любой ready (worker-down), make unit thumbnail image/jpeg 256x160, crop image/jpeg 128x128, optimized image/webp 320x200; unit-тесты: Fit, EXIF orientation 6 (320×200 → thumbnail 160×256), alpha → белый evidence/worker-down.json, src/internal/imaging/imaging_test.go
Невалидные/огромные изображения ограничены по bytes, пикселям, времени, памяти lab5ops.py invalid, lab5ops.py limits битый PNG с верным заголовком: 202 → failed invalid_image за 1 попытку (постоянная ошибка не ретраится); API: pixel bomb 20000×20000 → 413, не-изображение → 415, >10 MiB → 413, ../ в имени → 400; 6000×6000 (36 Мпикс) → ready за 5.2 с, пик памяти worker 491 MiB при лимите 768 MiB evidence/invalid.json, evidence/limits.json
Разрыв PostgreSQL ↔ broker закрыт outbox; crash между COMMIT и publish lab5ops.py api-crash (fault-api-after-commit) клиент получил 502 (API-процесс умер после COMMIT), API-контейнер перезапущен (RestartCount 0→1), строку outbox опубликовал другой relay, job ready без ручных действий; события queued → started → ready evidence/api-crash.json
Backoff с jitter, постоянные vs временные, DLQ/реестр failed, безопасный replay lab5ops.py retry, replay, dlq паузы перед попытками 2 и 3: 0.94 с и 1.81 с (диапазоны [0.5,1] и [1,2]); fault-flaky: 5 попыток → failed retry_exhausted; content 409, прикрепление к сообщению 409; replay → {"result":"replayed","attempt":6} → ready; повторный replay → noop: job already ready; malformed сообщение → attachment.process.dlq 0→1 evidence/retry.json, replay.json, dlq.json
Остановка worker после записи объекта, до ack — повтор завершает тот же результат lab5ops.py effect-crash (после S3 до COMMIT), ack-crash (после COMMIT до ack) effect-crash: события started → taken_over → ready, worker RestartCount 0→1, 3 варианта; ack-crash: ready один раз, после рестарта redelivery → лог job delivery is a no-op result=done redelivered=true evidence/effect-crash.json, evidence/ack-crash.json
Timeout/lease для зависшего processing lab5ops.py hang попытка 1 зависла без heartbeat → через 31 с sweeper: retry_scheduled lease_expired → попытка 2 → ready; «оживший» старый исполнитель: stale attempt finished after takeover; result already owned by newer attempt, вариантов по-прежнему 3 evidence/hang.json
Ограниченная конкуренция/prefetch WORKER_CONCURRENCY = число goroutine = basic.qos prefetch; бюджет декодирования; MAX_ACTIVE_JOBS см. трек 1: при MAX_ACTIVE_JOBS=20 принято ровно 20 из 80 evidence/track1/*.json
Очистка staging после безопасной фиксации все сценарии ready staging_removed=true, в S3 staging/<id> 0 объектов, конечный оригинал 1; у failed staging сохраняется для replay evidence/worker-down.json (s3)

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

Гипотеза. Pipeline изображений CPU-bound: увеличение WORKER_CONCURRENCY (= prefetch) повышает throughput почти линейно, пока число параллельных задач не упрётся в CPU-лимит worker (2 CPU), а для больших изображений — в бюджет памяти декодирования (384 MiB ≈ 2 задачи по 20 Мпикс). Дальше рост concurrency не даёт throughput, но увеличивает RSS. Без ограничения принятой работы очередь и время до ready растут неограниченно; с MAX_ACTIVE_JOBS лишняя работа отклоняется сразу (503 + Retry-After), а принятая гарантированно дренируется.

Методика (scripts/track1/run_track1.py, make track1). Для каждой настройки worker пересоздаётся с WORKER_CONCURRENCY ∈ {1,2,4} (те же лимиты 2 CPU / 768M / GOMEMLIMIT=600MiB, бюджет декодирования 384 MiB), для каждого размера — новый чат и открытый burst N загрузок 8 клиентскими потоками без ожидания обработки:

  • S = tests/fixtures/sample.png 320×200 (112 КБ), N=120;
  • M = 2000×1500 PNG с шумовыми строками (1.17 МБ), N=40;
  • L = 5000×4000 PNG-градиент (66 КБ на диске, 20 Мпикс после декодирования), N=16.

Метрики: время до ready каждой job = finished_at − created_at строки attachment_jobs (часы сервера, без клиентского polling); throughput = ready / (последний finished − первый created); queue lag — выборка каждые 0.5 с: активные jobs (queued+processing), messages_ready в RabbitMQ (rabbitmqctl list_queues), возраст самой старой незавершённой job; RSS — пик docker stats контейнера worker. Прогрев: стенд уже работал, по одному прогону на ячейку (ограничение — см. ниже). Raw: evidence/track1/matrix.json (с таймлайном lag), evidence/track1/backpressure.json.

Размер conc/prefetch принято / ready / failed throughput, job/s p50 / p95 до ready, с max queue (DB / MQ ready) max возраст старейшей job, с пик RSS worker, MiB
S 320×200 1 120 / 120 / 0 9.38 6.3 / 11.3 51 / 112 10.9 59
S 320×200 2 120 / 120 / 0 16.25 3.6 / 6.2 63 / 64 6.4 23
S 320×200 4 120 / 120 / 0 23.27 2.3 / 3.9 61 / 32 0.5 29
M 2000×1500 1 40 / 40 / 0 0.56 36.8 / 68.1 36 / 38 69.3 165
M 2000×1500 2 40 / 40 / 0 1.11 19.2 / 35.0 36 / 34 33.8 328
M 2000×1500 4 40 / 40 / 0 1.09 21.1 / 35.8 36 / 36 32.1 513
L 5000×4000 1 16 / 16 / 0 0.37 24.2 / 42.8 16 / 14 38.3 601
L 5000×4000 2 16 / 16 / 0 0.72 13.6 / 22.0 16 / 14 21.5 585
L 5000×4000 4 16 / 16 / 0 0.73 13.7 / 21.7 16 / 12 19.6 593

Backpressure и восстановление (backpressure): API с MAX_ACTIVE_JOBS=20, worker concurrency 1, burst 80 M-изображений за 1.1 с → принято ровно 20, 60 × 503 unavailable с Retry-After: 5, ни одного другого кода; максимум активных jobs по выборкам 18 ≤ 20. Все 20 принятых дошли до ready (0 failed, 0 retry), очередь опустела за 37.5 с (throughput 0.56 job/s — как в матрице для conc=1), и сразу после перегрузки новый upload стал ready за 0.34 с — система вернулась к idle-латентности без ручных действий. Первая версия ограничения (только предпроверка до чтения тела) пропустила 25 из 80 при пределе 20 (гонка check-then-insert между параллельными загрузками) — после этого добавлена повторная проверка в транзакции под pg_advisory_xact_lock, граница стала строгой.

Выводы.

  1. Для мелких изображений накладные расходы (БД-транзакции, S3 PUT ×4, ack) доминируют, а не CPU: throughput растёт 9.4 → 16.3 → 23.3 job/s (×2.5 при ×4 concurrency), p95 падает 11.3 → 3.9 с, RSS остаётся < 60 MiB. Здесь concurrency 4 однозначно лучше.
  2. Для M и L рост останавливается на concurrency 2 (= 2 CPU лимита): 1→2 даёт ×2 throughput и ×2 меньше p95, 2→4 — 0 % (1.11 → 1.09 и 0.72 → 0.73), зато RSS для M растёт 328 → 513 MiB. Для L concurrency 4 фактически не включается: бюджет декодирования 384 MiB пропускает только 2 задачи по 20 Мпикс одновременно, поэтому RSS держится ~590 MiB (у потолка GOMEMLIMIT), а OOM нет ни в одном прогоне. Гипотеза подтверждена: оптимум concurrency ≈ число CPU для тяжёлых изображений, больше — только трата памяти.
  3. Компромисс latency/ресурсы: при фиксированном CPU latency в очереди определяется законом Литтла — время до ready ≈ длина очереди / throughput; при неограниченном приёме p95 растёт линейно с burst (M, conc=1: 68 с для 40 файлов). Ограничение принятой работы делает худшую задержку предсказуемой (≈ MAX_ACTIVE_JOBS / throughput: 20 / 0.56 ≈ 36 с, наблюдали max 35 с) ценой явного 503 для клиента.
  4. Выбранная конфигурация по умолчанию: WORKER_CONCURRENCY=2 (=CPU), бюджет 384 MiB как предохранитель памяти, MAX_ACTIVE_JOBS=500 (для демонстрации backpressure — 20).

Ограничения измерения. По одному прогону на ячейку (разброс не оценён, повтор — make track1); один хост Windows/WSL2, клиент и стенд делят CPU; RSS — выборки docker stats раз в ~1–2 с, кратковременные пики могут быть пропущены; L-изображение синтетическое и хорошо сжимается (нагрузка — декодирование/ресайз, а не передача байтов); размер M-файлов искусственный (шум каждые 8 строк). Выводы относятся к этим лимитам и профилю, а не к production.

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

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
worker остановлен, upload, рестарт API и RabbitMQ (volumes сохранены) 202, задача не теряется 202 queued; сообщение в quorum-очереди до и после рестарта; ready через 0.34 с после старта worker потерь нет
API умирает между COMMIT и publish outbox опубликует клиент 502, job ready через ~0.2 с (relay другой реплики/worker) потерь нет; клиент не знает id — повтор upload создаст второе вложение (контракт это допускает)
worker умирает после записи S3 до COMMIT redelivery, перехват lease, тот же результат taken_over → ready, 3 варианта ~1 с (рестарт контейнера), дублей нет
worker умирает после COMMIT до ack redelivery — no-op result=done redelivered=true, ack дублей нет
worker «завис» lease истекает, новая попытка ready через 31 с (lease 30 с) старая попытка не перезаписала результат
временные ошибки backoff с jitter 0.94 с, 1.81 с ready на 3-й попытке
постоянная ошибка (битый PNG) failed без ретраев invalid_image за 1 попытку —
malformed сообщение в брокере DLQ DLQ 0→1 —
перегрузка (80 загрузок при лимите 20) 503 + Retry-After, работа ограничена 20 принято, 60 × 503 Retry-After: 5, после дренажа новый файл ready за 0.34 с принятые 20 все ready
рестарт всех хранилищ (restart.cmd) данные, сессия, файл сохранены make test-persistence PASS —
остановка одной API-реплики запись продолжается 0 ошибок, 3.97 с до первой записи после hook —

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

  • Один Docker-host: RabbitMQ — одна нода (quorum-очередь из одного члена), PostgreSQL и S3 — по одному экземпляру. Выдерживаются рестарты процессов с сохранёнными volumes, а не потеря диска/хоста.
  • At-least-once + идемпотентный эффект ≠ exactly-once: один и тот же S3-ключ может быть записан несколько раз (одинаковыми байтами), а дубль сообщения — получен; «ровно один раз» гарантируется только для зафиксированного результата в PostgreSQL.
  • При crash между COMMIT и ответом клиент не узнаёт attachment_id; без расширения контракта (Idempotency-Key для upload) повтор создаст второе вложение.
  • Таймаут не прерывает декодер Go насильно: зависшая попытка освобождает свою долю бюджета памяти только по фактическому завершению декодирования; защиту от бесконечного декодера даёт лимит контейнера.
  • Сверка S3 ↔ БД для вариантов (reconciler lab4) не перенесена; объекты от устаревших попыток всегда совпадают с зафиксированными по ключу, но «сиротские» объекты удалённых вложений не собираются.
  • Fault injection по имени файла — учебный механизм, выключается FAULT_INJECTION=0.
  • Worker использует ту же S3-идентичность, что и API; следующий шаг — отдельная идентичность с правами только на нужные prefix-ы.