Files
mtusi2026lab5/REPORT.md
T
ricoromaandClaude Opus 5.5 1373e7ddec docs: record exclusion evidence and move one-off probes into the driver
Adds worker-memory, freeze-sessions and freeze-lb driver commands, retakes
the evidence they produce, and fills the report header. src/ and bench/
are unchanged.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-01 13:53:53 +03:00

150 KiB
Raw Blame History

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

  • Автор, группа: Сафронов Роман Николаевич, БВТ2301
  • Целевая оценка; выбранный трек 5: оценка 5, трек 1 «Очередь под перегрузкой»
  • Состояние отчёта: закрыты уровень 3 (change async-attachments) и уровень 4 (change pipeline-reliability); уровень 5, трек 1 — change track1-queue-overload, раздел «Очередь под перегрузкой». Все доказательства исключений сверки покрытия сняты на стенде этой лабы
  • Ветка решения: solution/bvt2301-safronov, в неё по очереди вливаются feat/async-attachments, feat/pipeline-reliability, feat/unit-of-work, feat/track1-queue-overload
  • Commit: итоговый <commit после метки baseline3>; трек 1 — код и метка в разделе «Очередь под перегрузкой»; уровни 3 и 4 — d8fe2e8 (ветка feat/unit-of-work, перенос на единицу работы и правки verify); снятое на 9639aa1, 6ba74b1, 399da05, e2a6427 и ff1a83b названо в разделе доказательств
  • PR: по шаблону .github/pull_request_template.md, заголовок ЛР 5 — БВТ2301 — Сафронов — на 5; номер — после публикации
  • Согласования с преподавателем: три договорённости лаб 1–4 действуют, новых в лабе 5 нет (раздел «Согласования с преподавателем»). Открытые вопросы преподавателю — 12, раздел «Открытые вопросы преподавателю»; решения без пользователя — QUESTIONS.md
  • Источники, библиотеки и помощь ИИ — последний раздел

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

Версии. Образ API: python:3.12.14-slim-trixie, uv 0.12.17. LB: haproxy:3.4.6-trixie. PostgreSQL: postgres:18.6-trixie. Valkey: valkey/valkey:9.1.2-trixie. S3: chrislusf/seaweedfs:4.48. Брокер: rabbitmq:4.3.7. Все закреплены тегом и digest в Dockerfile и docker-compose.yml. Приложение: Python 3.12, FastAPI, aio-pika 10.2.1 (aiormq 7.2.4), Pillow 13.0.0, aiobotocore; остальное строго по uv.lock. Проверено на Docker 29.9.2, Compose 5.6.1, macOS на Apple M3 Pro.

Нужно на машине: Docker с BuildKit и Compose v2, make, openssl, curl, python3 3.9+ (публичные проверки и драйвер скилла), uv (make validate, make student_test, make test_isolated, make failure_checks, make bench*, make run_dev). Свободные порты 127.0.0.1: 8080 (LB), 5433 (PostgreSQL), 6380 (Valkey), 8334 (S3), 5673 (AMQP), 18088 (make test_isolated).

Действий оператора нет. make env_setup создаёт .env и config.toml из шаблонов, подставляет случайные пароли и ключи и печатает только имена. В существующий .env он дописывает недостающие переменные (секреты брокера и ключи worker при переходе с лабы 4), прежние строки не меняет. Пароль брокера, как и пароль PostgreSQL, задаётся при первом создании volume.

Способ 1: всё в compose — make run_docker

git clone <fork> && cd <каталог clone> && git checkout solution/bvt2301-safronov
make run_docker       # env_setup + build + up -d: postgres, valkey, s3, rabbitmq → migrate, s3-bootstrap → api × 2, relay, worker, cleaner → haproxy
make replicas         # дождаться healthy реплик; готовность стенда — haproxy (healthy) и /health/ready через LB
make check
uv sync && make validate PYTHON=.venv/bin/python
make test             # публичный smoke: 202, опрос до ready, оригинал и настоящий JPEG thumbnail
make instances        # ≥2 X-Instance-Id одной сессии через LB
make s3_check         # приватность bucket: права ключей API, уборщика и worker
make student_test
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh && make replicas
python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 defense-scenario
python3 .claude/skills/run-mtusi-messenger/driver.py --port 8080 defense-faults   # шаг 4 защиты, ~2–4 мин
make replay           # реестр failed, только показ; APPLY=1 ATTACHMENT=<id> — вернуть в работу
make failure_checks   # отдельный стенд <проект>-failures, ~40 мин; рабочий стенд не трогается

Миграции применяет одноразовый сервис migrate, bucket и пользователей S3 — s3-bootstrap; реплики, relay, уборщик и worker их ждут. Очередь объявляют relay и worker при подключении: отдельного bootstrap брокера нет, реплики API к брокеру не обращаются.

Способ 2: сервис на хосте — make run_dev, make run_worker, make run_relay

make run_dev          # терминал 1: Postgres и миграции с хоста, Valkey, S3 с bootstrap, брокер в compose; API на 127.0.0.1:8080 с reload
make run_worker       # терминал 2: worker на хосте; ключи worker — из .env в окружение процесса, значения не печатаются
make run_relay        # терминал 3: relay на хосте; без него задания ждут в PostgreSQL
curl -s http://127.0.0.1:8080/health/ready
make test
EXPECT_REPLICAS=1 make student_test

Ожидание готовности — /health/ready отвечает 200. Остановка процессов — Ctrl+C.

Вариант README без make: make env_setup, docker compose --env-file .env config --quiet, docker compose --env-file .env up -d --build.

Остановка и удаление данных

  • make stop — остановить контейнеры; make down — удалить контейнеры. Volumes postgres_data, s3_data, rabbitmq_data остаются.
  • make wipe_data — намеренное удаление учебных данных и volumes (спрашивает yes).

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

клиент → HAProxy (127.0.0.1:8080) → api × 2 ──┬─ PostgreSQL (источник истины: метаданные, задания = outbox, варианты)
                                              ├─ Valkey (кэш карточек чатов)
                                              └─ S3: <база>/staging/<id>/original
relay → PostgreSQL: state = 'queued' AND published_at IS NULL, срок наступил; истёкшие аренды
      → RabbitMQ: durable-очередь <база>.attachment.process.v1, publisher confirm, затем отметка published_at
                    │ job_id, attachment_id, pipeline_version, attempt…
                    ▼
worker → PostgreSQL: claim с арендой и номером попытки → render: отдельный процесс на задание, лимиты, без секретов
       → S3: <база>/attachments/<id>/original, …/v1-thumbnail, v1-crop, v1-optimized
       → PostgreSQL: ready или failed с fencing, затем ack
cleaner → PostgreSQL + S3 (pending, staging у ready и по сроку у failed, сверка bucket и БД)
make replay → relay replay: реестр failed и возврат работы с аудитом

Перенесено из лаб 2–4 без изменения поведения (подробности — REPORT.md репозитория mtusi2026lab4-safronov): вход Basic → Bearer-сессия в PostgreSQL, пароль — Argon2id (RFC_9106_LOW_MEMORY: t=3, m=64 MiB, p=4), SHA-256 токена в БД; кэш карточек; реплики без состояния за HAProxy, идемпотентность сообщений, make rolling_update; приватный S3 с тремя пользователями, места загрузки, уборщик и сверка.

Изменено на уровне 3 (design change async-attachments):

  • POST …/attachments — 202 со снимком queued;
  • worker: claim задания под FOR UPDATE, чтение staging и сверка размера и SHA-256 со строкой, PUT оригинала в конечный ключ, варианты, фиксация ready вместе с вариантами и заданием одной транзакцией, ack;
  • состояния queued, processing, ready, failed в API; pending наружу не виден (404);
  • скачивание не готового вложения — 409, отсутствующий вариант готового — 404; failed в сообщении — 409, а повтор отправленного сообщения с тем же ключом — тот же 201;
  • схема только расширена: attachment_jobs, attachment_variants, attachments.staging_key и error_code, более широкий CHECK статуса (NOT VALID).

Изменено на уровне 4 (design change pipeline-reliability):

  • порядок приёма: строка pending с ключами → PUT в staging → queued с заданием одной транзакцией → 202. Брокера в пути запроса нет, у реплик ни клиента, ни пароля;
  • outbox — те же строки attachment_jobs (state = 'queued' AND published_at IS NULL); relay публикует с подтверждением под FOR UPDATE SKIP LOCKED, отмечает только подтверждённые, возвращает истёкшие аренды и потерянные сообщения;
  • сообщение — подсказка, истина в строке задания: дубль при живой аренде и сообщение раньше срока подтверждаются без эффекта; аренда job_timeout + lease_margin без пульса, номер попытки — fencing;
  • варианты crop и optimized; декодирует только отдельный процесс на задание с лимитами;
  • backoff с jitter, постоянные и временные ошибки, реестр failed в PostgreSQL и make replay с аудитом (attachment_job_replays, attempt_base);
  • prefetch отдельно от concurrency; очистка staging уборщиком, класс сверки orphan_staging;
  • схема только расширена: ревизии c7e2f1a04b56 и d3f9a6b2c1e7.

Единица работы (design change unit-of-work, Cosmic Python, главы 2 и 6). С PostgreSQL сервисы всех процессов работают только через абстракции src/core/ports/: AbstractUnitOfWork и абстрактные repo; реализации на SQLAlchemy выбирают точки входа (src/api/dependencies.py, src/worker/main.py, src/relay/main.py, src/cleaner/main.py). Остальные зависимости конкретные и названы: Cache, ObjectStorage, JobPublisher, ImageRenderer сервис импортирует как типы и получает конструктором (сигнатуры фейков сверяет тест, design.md, решение 8), а src.infra.password и логгер вызывает прямо из модуля (уточнение 20). Граница транзакции одна и видна в сервисе: async with self.uow: — один блок, одна транзакция; явный await self.uow.commit(), выход без него — откат. Вложенный блок и repo вне блока или после фиксации — ошибка, в том числе на фейке. Доменной модели, агрегатов и message bus нет: логика и так в сервисах, а границы транзакций заданы контрактом. Кэш Valkey и S3 в единицу работы не входят: фиксация и откат на них не действуют. Соединение занято на шаг: JSON-ручка получает его на вход и на операцию отдельно, а на хэш пароля, между шагами и на передачу ответа оно в пуле. [database] request_timeout_seconds — срок блока вместе с откатом при выходе; на JSON-ручках та же настройка ещё и общий срок запроса (request_deadline), иначе два шага дали бы до 12 с при timeout server 10 с, а очередь хэшей шла бы без срока. Поведение API, контракт, схема и настройки те же.

Схема слоёв и поток отправки сообщения (каждая связь сверена с импортами и вызовами кода; поиском по связям помогал граф кода graphify, он только подсказка: схема написана руками):

flowchart TD
    subgraph entry["Точки сборки"]
        deps["src/api/dependencies.py"]
        procs["src/worker, src/relay, src/cleaner (main.py)"]
    end
    subgraph api["API"]
        routers["src/api/routers/v1/*"]
    end
    subgraph core["Домен"]
        services["src/core/services/*"]
        ports["src/core/ports/*: AbstractUnitOfWork, Abstract*Repository"]
        clientrepos["src/core/repos: chat_cache, attachment_object"]
    end
    subgraph infra["Реализации"]
        uow["src/infra/db/uow.py: SqlAlchemyUnitOfWork"]
        scope["src/infra/db/scope.py: session_scope, deadline_scope"]
        sqlrepos["src/core/repos/*: SqlAlchemy*Repository"]
        clients["src/infra: Cache, ObjectStorage, JobPublisher, ImageRenderer"]
        password["src/infra/password.py"]
    end
    pg[("PostgreSQL")]
    routers --> deps
    deps --> services
    procs --> services
    deps --> uow
    procs --> uow
    deps --> scope
    services --> ports
    services --> clientrepos
    services -- "тип клиента, вызовы издателя и процесса обработки" --> clients
    services -- "хэш пароля" --> password
    clientrepos --> clients
    uow -. реализует .-> ports
    sqlrepos -. реализует .-> ports
    uow --> scope
    uow --> sqlrepos
    sqlrepos --> pg
sequenceDiagram
    participant R as message router
    participant D as request_deadline, get_current_session
    participant S as MessageService.send_message
    participant U as SqlAlchemyUnitOfWork
    participant P as PostgreSQL
    participant C as chat_cache
    D->>U: блок входа: sessions.get_current_session
    U->>P: проверка соединения, SELECT, ROLLBACK
    R->>S: chat_id, sender_id, text, idempotency_key
    S->>U: async with self.uow
    S->>C: require_member: карточка из кэша
    C-->>S: промах
    S->>U: chats.get_chat
    S->>U: attachments.get_attachments, если есть вложения
    S->>U: idempotency.claim_key
    S->>U: messages.insert_message, связи
    S->>U: commit
    U->>P: проверка соединения, BEGIN, выражения, COMMIT
    S-->>R: MessageFullDTO

Быстрые тесты сервисов — каталог service-tests/ вне образа и вне student-tests/: make service_test гоняет ветки всех сервисов на фейках без хранилищ и docker, make service_test_db на временной базе проверяет настоящую единицу работы, общий срок запроса и тот же набор условий repo, что и на фейке (service-tests/repo_contract.py). Блокировки и поведение под конкуренцией фейк не воспроизводит: это по-прежнему make failure_checks.

Цена шага — вторая выдача соединения на двухшаговой ручке, новых соединений нет. Её снижает проверка соединения при выдаче одним запросом ; вместо трёх (_ping_once, опирается на внутренние имена адаптера, смену имён ловит make service_test_db). Осталось то, что в таблицах ниже: цену приняли, готовые меры (чтение без транзакции, соединение Core вместо сессии) не применялись (design.md, решение 7).

Обмены с PostgreSQL на запрос (журнал log_statement = all, проба до кода, design.md, Context; на commit не переснимались: выражения те же):

Ручка До На шаг без меры С мерой (_ping_once)
GET /users/me 6 6 4
GET …/messages 7 12 8
POST …/messages 8 13 9

Потолок и CPU реплики до и после, закрытая модель, 1 реплика 1 CPU, один повтор на ячейку: caffeinate -isu uv run python bench/run.py --profile quick --label unit-of-work-before и unit-of-work-aa на b2fb88f (src как на 9efab79, временный git worktree), --label unit-of-work-after на 6ba74b1; make bench_compare BEFORE=unit-of-work-before AFTER=unit-of-work-after AA=unit-of-work-aa и make bench_compare BEFORE=unit-of-work-aa AFTER=unit-of-work-after AA=unit-of-work-before. Метки — evidence/bench/unit-of-work-*/, сравнения — evidence/compare/unit-of-work-before__unit-of-work-after.md и evidence/compare/unit-of-work-aa__unit-of-work-after.md. Метки сняты до правок verify (BoundedCloseConnection, таймер блока при общем сроке): на пути без отказа те правки убирают один таймер блока и не добавляют обменов; метки не переснимались. У всех трёх git.dirty false, host_warnings пусты, swapouts_delta 0; посторонние контейнеры на хосте — domains-api-1, domains-bot-1, domains-postgres-1 (названы в паспортах). Первая съёмка unit-of-work-before дала предупреждение о выгрузке 27708 страниц в swap и переснята (bench.md): порядок меток — aa, after, rollout, затем before, в той же сессии хоста; отброшенная метка в git не идёт.

Порядок съёмки: aa 20:19, after 20:23, затем rollout, before 20:32 UTC. Код aa и before один, поэтому обе метки — «до», и каждая служит уровнем шума для другой (bench_compare считает шум от своего «до»: одна пара меток даёт 14,8 и 17,4 %, 34,8 и 53,4 %).

Сценарий «До» Шум A/A, наибольшее Δ RPS Δ RPS по 9 ячейкам: медиана (мин…макс) Ячеек ниже «до» Вывод bench_compare p50 при 1 клиенте, мс (1k, 5k, 10k)
история aa, сразу перед after 17,4 % (5k × 1) −14,1 % (−21,1…−6,3) 9 из 9 эффект — 1k × 1 (−21,1 %) и 5k × 1 (−17,5 %), остальные в пределах шума 1,78 → 2,22; 1,79 → 2,16; 1,83 → 2,22
история before, после rollout 14,8 % (5k × 1) −6,6 % (−18,8…−3,2) 9 из 9 эффект — 1k × 1 (−16,2 %) и 1k × 16 (−18,8 %), остальные в пределах шума 1,86 → 2,22; 1,95 → 2,16; 1,85 → 2,22
отправка aa, сразу перед after 53,4 % (5k × 16) −12,6 % (−18,7…−2,1) 9 из 9 всё в пределах шума 2,01 → 2,40; 2,06 → 2,33; 2,06 → 2,41
отправка before, после rollout 34,8 % (5k × 16) −4,3 % (−23,5…+37,5) 7 из 9 в пределах шума, кроме 5k × 16: +37,5 % — выброс ячейки «до» 2,05 → 2,40; 2,07 → 2,33; 1,89 → 2,41

Шум отправки задан одним выбросом: 5k × 16 в before — 383 RPS при 588 в aa. Без этой ячейки наибольшее расхождение A/A — 14,2 % (10k × 1, 433 и 495 RPS; считано не командой, а по evidence/bench/unit-of-work-{aa,before}/runs.csv), и −23,5 % той же ячейки от before выходит за него; от aa она даёт −12,6 %.

CPU реплики на запрос от aa: выше в 18 ячейках из 18, история +116…+266 мкс, отправка +26…+332 мкс. От before: выше в 15 из 18, исключения — 5k × 1 истории (−99), 5k × 1 и 5k × 16 отправки (−3 и −681, та же ячейка-выброс). p95 и все ячейки — в evidence/compare/.

Что показывают данные. Соединение на шаг снижает потолок реплики на этой закрытой модели: от метки того же кода, снятой прямо перед after, ниже все 18 ячеек, медианы −14,1 % на истории и −12,6 % на отправке, и в тех же 18 ячейках выше CPU реплики на запрос. От метки, снятой позже, медианы −6,6 и −4,3 %, ниже 16 ячеек из 18.

Чего данные не показывают. Точной величины: на ячейку один повтор, две метки одного кода расходятся до 14–17 % даже без выброса, а по правилу bench_compare эффектом названы только 2 ячейки истории из 9 в каждом сравнении. Ячейки одной метки сняты подряд и независимыми не считаются: 18 из 18 говорит об устойчивости знака, а не о размере. before ниже aa в 13 ячейках из 18 при том же коде; если хост за эти 13 минут замедлялся, ближнее сравнение цену завышает, а дальнее занижает, и данные этого не различают. Поэтому цена — снижение потолка примерно от 4–7 до 13–14 % по медианам, а не одно число.

С оценкой design.md (потолок −1…−22 %, p50 при 150/с +0,2…0,5 мс) цена не расходится: от aa все 18 ячеек внутри (−2,1…−21,1 %), от before вне её три ячейки: +0,4 %, +37,5 % и −23,5 %. p50 здесь при 1 клиенте закрытой модели, а не при 150/с, прирост +0,21…+0,52 мс.

CPU на успешный запрос при постоянных 200 запросах в секунду (100 записей, 100 чтений; две реплики разных версий в одном прогоне): bench/run.py --profile rollout --from b2fb88f --label unit-of-work-previous на 6ba74b1, evidence/rollout/unit-of-work-previous/summary.md, git.dirty false, host_warnings пусты:

Компонент До замены, мкс После замены, мкс
API всего 3066 3398
PostgreSQL 478 560

Уровень шума — два прогона замены на один и тот же новый код: evidence/rollout/unit-of-work/summary.md даёт после замены API 3113 мкс и PostgreSQL 524 мкс, этот прогон — 3398 и 560. Расхождение одного кода (отношение чисел двух summary.md, считано вручную): API 285 мкс, 9,2 %; PostgreSQL 36 мкс, 6,9 %. Рост в прогоне выше: API на 332 мкс, 10,8 %, — того же порядка, поэтому отличить его от шума нельзя; PostgreSQL на 82 мкс, 17,2 %, — вдвое больше расхождения, но пара прогонов одна, и этого мало для вывода. Значения «до» двух прогонов для шума не годятся: там разный прежний код.

Замена с b2fb88f на 6ba74b1: 10,2 с, ошибок 0 / 0 / 0, 12001 сообщение = 12001 ключ. Удержание соединения на запрос по пробе design.md (Context) ниже на 20–36 %; на commit отдельно не измерялось.

Транзакционные границы. Ключ эффекта — первичный ключ attachment_variants (attachment_id, pipeline_version, variant), логическая работа — UNIQUE (attachment_id, pipeline_version) в attachment_jobs. Вызовов S3 и брокера внутри блоков единицы работы нет, кроме двух осознанных исключений с коротким сроком: публикация relay (2 с < срока блока 6 с < простоя транзакции 10 с: блокировка строки и есть признак «публикует другой relay») и DELETE уборщика под блокировкой строки. Намеренные особенности перенесены без изменения порядка: уборка зависшей загрузки — два блока (пометка, затем объект и строка), вход закрывает блок чтения до KDF, занятый ключ идемпотентности снимает блокировку фиксацией до ответа, а компенсация загрузки различает сбой выражения и сбой на самой фиксации флагом перед явным commit(): автокоммит при выходе этого бы не дал (design.md, решение 10).

Варианты и лимиты обработки

Вариант Формат Размер Параметры Метаданные
thumbnail JPEG вписан в 256 × 256, вниз, без увеличения quality=85 EXIF и ICC не пишутся
crop JPEG 128 × 128, центр, маленькие растягиваются quality=85, альфа на белый то же
optimized WebP вписан в 1280 × 1280, без увеличения quality=80, method=4 (method=6 на пробе в 3,5 раза дольше без выигрыша) EXIF, XMP, ICC нет; ориентация применена; прозрачность сохранена

Все три — из одного декодирования, результат детерминирован (design, таблица «Пробы»). Pillow нет ни в репликах, ни в процессе 1 worker (evidence/worker/process.md).

Лимит Механизм Значение Превышение
байты размер объекта против строки до чтения тела; CHECK контракта 10 MiB source_corrupted, processing_failed, постоянная
пиксели width × height до декодирования 40 млн limit_pixels, invalid_image, постоянная
память RLIMIT_AS процесса обработки 450 МиБ limit_memory, invalid_image, постоянная
CPU RLIMIT_CPU, RLIMIT_CORE = 0 15 с limit_cpu, invalid_image, постоянная
время родитель убивает процесс 40 с, меньше срока попытки 60 с timeout, временная

Настоящий случай «дорогого» файла — прогрессивный JPEG в пределах контракта, один скан повторён 445 227 раз: test_limit_cpu_scan_bomb.

Бюджет памяти контейнера worker (1 ГБ). Замер двух файлов разом, команда driver.py --port 8080 worker-memory, два прогона на 9639aa1 (evidence/worker/memory.md): пик процесса обработки на 40 Мпкс (render_peak_kib, лимит 450 МиБ) зависит от типа файла: PNG RGBA и всё, что переводится в RGBA (серый с альфой, RGB с tRNS, палитра с tRNS), — 357 МиБ, серый 16 бит — 404 МиБ, а на обеих границах контракта сразу, 40 Мпкс и ~10 MiB файла, — 367 и 414 МиБ. VmHWM процесса 1 при двух телах ~10 MiB — до 159 МиБ. Самый дорогой случай, два серых 16 бит на обеих границах: memory.peak контейнера 926 и 705 МиБ в двух прогонах (пик зависит от совпадения пиков двух процессов), oom_kill 0; у двух PNG 10 MiB из шума — 262 МиБ. Опора — верхняя оценка суммой пиков: 159 + 2 × 414 = 987 МиБ < 1 ГБ. Если памяти всё же не хватит, ядро убьёт самый большой процесс обработки, а не worker (проба), это временная ошибка.

Сервисы стенда и лимиты

Сервис Роль CPU Память Порт на хосте
haproxy LB, единственная публичная точка 1 256 МБ 127.0.0.1:8080
api × 2 приём, без состояния 1 на реплику 512 МБ на реплику нет
relay публикация намерений, истёкшие аренды, python -m src.relay, без healthcheck 0,25 256 МБ нет
worker обработка, python -m src.worker, без healthcheck 1 1 ГБ нет
cleaner незавершённые загрузки, очистка staging, сверка 0,25 256 МБ нет
postgres источник истины, volume 2 1 ГБ loopback 5433
valkey кэш, без persistence 0,5 128 МБ loopback 6380
s3 SeaweedFS, volume 1 512 МБ loopback 8334
rabbitmq брокер, volume, предел памяти 400 МиБ 1 512 МБ loopback 5673
migrate (разовый) миграции 0,5 256 МБ нет
s3-bootstrap (разовый) bucket, политики, пользователи 0,5 128 МБ нет

Сумма постоянных сервисов: 9,0 CPU, 4992 МБ при двух репликах; вместе с разовыми — 10,0 CPU, 5376 МБ.

Соединения PostgreSQL: API_REPLICAS × 10 + migrate 1 + cleaner 1 + worker 2 + relay 1. При двух репликах 25; во время поочерёдной замены (третья реплика) 35; max_connections 100. Переполнения пула нет (max_overflow 0).

Лимит worker 1 ГБ: расчёт — раздел «Варианты и лимиты обработки», проверяет test_max_pixels_fit_worker_memory. На метке baseline при конкуренции 2 memory.peak до 838 МиБ на самом дорогом классе; конкуренция 4 в этот лимит на нём не помещается (раздел «Очередь под перегрузкой»).

Предел принятой работы: [uploads] max_unfinished_jobs 250 незавершённых заданий на стенд, 0 — без предела. Обоснование по измеренному потолку — там же.

Соответствие переменных .env.example

Имена лаб 1–4 — без изменений, таблицы в отчёте лабы 4 («Соответствие переменных», «Соответствие имён skeleton S3_*»). Новые имена лабы 5:

Имя skeleton Где у нас Почему так
BROKER_URL_FILE [broker] мостами из RABBITMQ_* (BROKER__HOST, BROKER__PORT, BROKER__USER, BROKER__PASSWORD) значения, а не файл, как DATABASE_URL_FILE: пароль нужен и контейнеру брокера, строка URL с паролем не собирается
WORKER_CONCURRENCY [worker] concurrency (2) читает только worker
JOB_MAX_ATTEMPTS [worker] max_attempts (5) то же
JOB_TIMEOUT_SECONDS [worker] job_timeout_seconds (60) то же
STAGING_RETENTION_SECONDS [cleaner] staging_retention_seconds (86400) читает только уборщик; значение из .env.example skeleton

Новые настройки уровня 4 (значения по умолчанию, вывод записи о старте — evidence/worker/process.md, evidence/relay/process.md):

  • [worker]: prefetch 2, lease_margin_seconds 10, retry_base_delay_seconds 5, retry_max_delay_seconds 300, render_timeout_seconds 40, render_cpu_limit_seconds 15, render_memory_limit_mib 450, graceful_shutdown_seconds 8 (не больше 8);
  • [relay]: poll_interval_seconds 0,25, batch_size 100, max_published_backlog 1000 (0 — без предела), republish_after_seconds 300, failure_pause_seconds 2.

Секреты по сервисам: пароль брокера — только rabbitmq, relay, worker, у api настроек брокера нет; ключи S3_WORKER_* — только s3-bootstrap и worker; у worker нет пароля Valkey и ключей API и уборщика; у relay нет S3 и Valkey; в окружении процесса обработки секретов нет.

Критичные и некритичные зависимости /health/ready

Зависимость В готовности Причина и поведение при отказе
PostgreSQL да без него не работают сессии и данные: обязательный путь стоит, 503
Valkey нет кэш: отказ — обход, чтение из PostgreSQL
S3 нет нужен только путям байтов вложений: они отвечают 503, текст и история работают
Брокер нет брокера в пути запроса нет: загрузка отвечает 202, намерение ждёт в PostgreSQL
Relay нет без него задания ждут в PostgreSQL, приём не страдает
Worker нет к синхронному пути не относится

Отказ брокера. Загрузка — 202, а не 503 (на уровне 3 было 503): намерение уже в PostgreSQL, relay пишет «Broker is unavailable» и опубликует после возврата; 503 на загрузке теперь только от S3 и PostgreSQL. Проверки: test_upload_with_broker_stopped, test_upload_with_broker_paused. Отказ relay. Загрузка — 202, задание queued с пустой отметкой, следующий запуск публикует (test_relay_killed_before_publish). Отказ worker. API принимает, relay публикует; resize синхронно не делается: Pillow в процессе API не загружен (_imaging нет в /proc/1/maps, evidence/worker/process.md).

Разрыв COMMIT и publish и окна отказа

Разрыв закрыт transactional outbox на тех же строках: намерение и queued — одна транзакция, публикует отдельный relay по этим строкам, а не процесс запроса. Отдельной таблицы нет: это было бы второе состояние той же работы. LISTEN/NOTIFY отвергнут: опрос всё равно нужен для сроков, а пустая выборка стоит 0,05 мс.

Окно Что происходит Что видит клиент
после staging до записи задания pending и объект staging; их убирает уборщик 503 или обрыв
после COMMIT queued до ответа работа идёт: relay опубликует обрыв; вложение станет ready, клиент о нём не знает, как и в лабе 4
после COMMIT до publish (relay упал) намерение в БД, следующий проход публикует 202 уже получен
после publish до confirm исход неизвестен: новая публикация, возможен дубль опрос queued
после confirm до отметки published_at откат отметки, новая публикация, дубль — no-op опрос queued или processing
после записи S3 до COMMIT результата аренда истекает, новая попытка пишет те же ключи опрос processing, затем queued
после COMMIT результата до ack повторная доставка — no-op с ack опрос ready

Сбои внедрены снаружи, без точек сбоя в коде (триггер на filename прогона, docker kill): driver.py defense-faults на рабочем стенде → evidence/attachments/defense-faults.md, те же окна — test_defense_faults. Запись «Разрыв COMMIT и publish» из KNOWN_ISSUES.md удалена.

Смесь версий и порядок обновления (design, Migration Plan). Шага оператора нет: секретов не прибавилось. Без простоя: docker compose up -d s3-bootstrap, make rolling_update (две ревизии, затем реплики), docker compose up -d --no-deps worker cleaner, затем docker compose up -d --no-deps relay; до запуска relay загрузки отвечают 202 и ждут. Worker обновляется раньше relay: прежний worker делает только thumbnail. Откат: make rolling_update COMMIT=<прежний> MIGRATE=0 COMPOSE_FILE=docker-compose.yml:infra/rollback/broker.compose.yml (прежним репликам нужен пароль брокера, только на время отката), прежние worker и уборщик, relay останавливается, схема остаётся. Новых статусов и error_code нет, поэтому 500 на чтении, как при переходе 201 → 202, здесь нет; проба — evidence/migrations/pipeline-reliability.md.

Согласования с преподавателем

Дата Договорённость Где учтено
2026-09-26 Лабы можно делать на FastAPI, несмотря на расхождения с контрактом (лишний 422, другой порядок кодов ошибок). Публичный smoke при этом должен проходить .claude/rules/api-contract.md, раздел «FastAPI»
2026-09-29 Конфиг через pydantic-settings: окружение → .env → config.toml → дефолты. config.toml не в git и не в образе, монтируется read-only при запуске. Это подходит под «конфигурация приходит из окружения» (README лабы 1, п. 3) и п. 6 Dockerfile.example. Требование «только env» — упрощение курса, config.toml можно использовать .claude/rules/settings.md, .claude/rules/docker.md
2026-10-20 Лаба 4: «пустой текст» сообщения — это и "", и текст только из пробельных символов. Допустимы: вложение + непустой текст, без вложения + непустой текст, вложение + пустой текст. Значит, " " с хотя бы одним вложением — 201, без вложений — 400 спек messages (change attachments, сценарий «Пробелы с вложением»), design attachments, решение 8; .claude/rules/api-contract.md

Расхождения FastAPI, разрешённые согласованием: 422 переведён в 400; битый JSON — 400 раньше 401, остальная валидация — после зависимостей.

Открытые вопросы преподавателю

Контракт допускает несколько трактовок, ответа пока нет. Взята самая строгая, проходящая публичные тесты. Подход от ответа не зависит. Вопросы 1 и 2 перенесены из лабы 4, полный разбор — в её отчёте.

  1. Все места загрузки реплики заняты: 429 или 503? Сделано: 429 rate_limited с Retry-After: 1.
  2. Что отвечает API на вложение, чей оригинал по сверке потерян? Сделано: метаданные — 200, байты — 404, ссылка в новом сообщении — 201; до пометки сверкой байты — 500.
  3. Failed-вложение прикреплять нельзя (409), а повтор с тем же Idempotency-Key обязан вернуть тот же 201. Что отвечать на повтор сообщения, чьё вложение стало failed уже после отправки? Сделано: новое сообщение — 409, повтор с ключом — 201 с тем же Message. Другой ответ меняет одну ветку send_message и сценарий idempotency.
  4. contracts/attachment-states.md требует документированный retention и cleanup неуспешных исходников без указания уровня, а README.md относит очистку к уровню 4. Закрыт уровнем 4: [cleaner] staging_retention_seconds 86400 с, очистка у ready следующим проходом, у failed по сроку. На уровне 3 очистки не было.
  5. Допустим ли на уровне 3 ответ 503 при недоступном брокере? Закрыт уровнем 4: отказ брокера больше не даёт 503, на загрузке 503 только от S3 и PostgreSQL. На уровне 3 был 503: relay ещё не было.
  6. Контракт требует EXIF orientation и alpha на белый только у thumbnail. Как с crop и optimized? Сделано: ориентация применяется у обоих (иначе EXIF, удалённый из WebP, повернул бы изображение), crop компонуется на белый (JPEG), optimized сохраняет прозрачность. Другой ответ правит одну функцию и сценарий.
  7. Контракт называет replay «явным операторским», но не говорит, как его вызывать. Достаточно ли команды в контейнере? Сделано: make replay, HTTP-ручки нет: в API нет роли оператора. Другой ответ добавляет ручку поверх той же транзакции.
  8. Изображение, не уложившееся в лимиты времени или памяти обработки, — это invalid_image или отдельный код? Сделано: invalid_image, точная причина — в записи для оператора. Другой ответ добавляет значение enum и требует обновить реплики раньше worker.
  9. Контракт требует retention «неуспешных и непривязанных исходников», но молчит о конечных объектах, которые успела записать неудачная попытка. Сделано: по истечении срока удаляются и они, метаданные failed остаются. Другой ответ убирает один шаг очистки.
  10. Предел незавершённых заданий: 429 или 503? Контракт называет 429 «ограничением частоты запросов», здесь ограничено количество принятой работы; 503 — «зависимость недоступна». Сделано: 429 rate_limited с Retry-After: 5, как у занятых мест: зависимости живы, реплика готова. Другой ответ меняет строку DOMAIN_ERRORS и сценарии.
  11. Как долго загрузка обязана отвечать 202 при остановленном worker? Рубрика уровня 3 показывает «worker остановлен → upload 202», трек 1 требует ограничить принятую работу. Сделано: пока незавершённых меньше предела (250); дальше 429, а текст, история, метаданные, готовые байты и /health/ready работают. Другой ответ — значение настройки.
  12. Требуется ли на уровне лабы закрыть чтение секретов worker процессом обработки? Он идёт под тем же UID и может прочитать /proc/1/environ (раздел «Ограничения и следующие шаги»). Сделано: кодом не исправлено, в окружении самого процесса обработки секретов нет. Предложение — PR_SET_DUMPABLE=0 в процессе worker до запуска процессов обработки: одна строка на старте worker и сценарий.

Ответы на вопросы защиты

Чем publisher confirm отличается от consumer ack? Confirm — брокер сообщает издателю, что принял сообщение на себя: durable-очередь, persistent-сообщение, записано. Это граница между relay и брокером: только после неё relay ставит отметку published_at, неподтверждённое остаётся намерением и публикуется снова. Ack — потребитель сообщает брокеру, что сообщение можно удалить. Worker шлёт его только после фиксации исхода в PostgreSQL (ready, failed, queued со сроком следующей попытки) или решения «эффекта не нужно». Это разные участки пути: confirm ничего не говорит об обработке, ack — о доставке. Ни тот, ни другой больше не определяют ответ клиенту: 202 — это COMMIT в PostgreSQL.

Что именно уже сохранено в момент 202? Проверенный оригинал целиком в staging приватного S3, строка вложения и намерение обработки в PostgreSQL (queued, attempt 0, одна транзакция). Сообщения в очереди может ещё не быть: его опубликует relay, и брокер в этот момент может быть недоступен. Вариантов и объекта в конечном ключе ещё нет. Проверка — test_durable_state_at_202, переживание — test_api_killed_after_202, test_relay_killed_before_publish, test_broker_restart_keeps_job, test_broker_kill_keeps_confirmed.

Почему повторная доставка нормальна и где ключ идемпотентности job? Подтверждение и результат работы нельзя зафиксировать атомарно: процесс может умереть между COMMIT и ack, relay — между confirm и отметкой, и сообщение придёт снова. Это at least once, а не exactly once. Эффект идемпотентен: ключ — (attachment_id, pipeline_version, variant), первичный ключ attachment_variants, вставка ON CONFLICT DO NOTHING; ключи объектов одни и те же при каждом повторе, логическая работа — UNIQUE (attachment_id, pipeline_version). Сообщение — подсказка, истина в строке: доставка готовой работы подтверждается без записи (test_redelivery_of_ready_is_noop, test_crash_after_commit_before_ack: attempt 1, тот же updated_at), ready не откатывается, replay готового — отказ already_ready.

Как отличить зависший worker от долго работающего и не запустить два неконтролируемых дубля? Только сроком: флаг redelivered этого не доказывает, брокер ставит его и после nack. Попытка жёстко ограничена: шаги прерывает asyncio.timeout(job_timeout_seconds), процесс обработки убивается, поэтому аренда job_timeout + lease_margin (70 с) обходится без пульса. Истёкшая аренда значит «мёртв или заморожен», такую попытку возвращает relay. Пока аренда жива, дубль подтверждается без эффекта и без траты номера (busy, test_duplicate_during_processing), долгая живая попытка не теряет работу (test_long_attempt_keeps_lease). Новая попытка получает новый номер, и фиксация условна: state = 'processing' AND attempt = :своя. Размороженный прежний процесс получает superseded и ничего не меняет, в том числе пока новая попытка ещё идёт: тогда решает только номер (test_hung_worker_lease_fencing). Цена — после KILL следующая попытка ждёт аренду, до 70 с (наблюдали 70 с, evidence/attachments/defense-faults.md). Пульс отвергнут: запись на задание каждые несколько секунд, зависимость от event loop и ложные срабатывания под перегрузкой.

Где работа перестаёт приниматься и ускоряться, и почему предел — 429? Приниматься — на местах загрузки реплики и на пределе незавершённых заданий: оба уровня отвечают 429 с Retry-After. Ускоряться — на CPU worker: при 1 CPU конкуренция сверх двух не поднимает потолок, а на lp ломает обработку; у файлов на границе байтов ещё на CPU S3, общем для приёма и обработки. За входом клиент видит только дольше неизменный queued. 429, а не 503: зависимости живы, реплика готова и остаётся в LB, а текст, история, метаданные и готовые байты работают. Трактовка — вопрос 10 преподавателю. Числа — раздел «Очередь под перегрузкой».

Сценарий защиты

Порядок автоматизирован: driver.py --port 8080 defense-scenario → evidence/attachments/defense.md, тот же порядок на стенде отказов — test_defense_scenario.

  1. make test: 202, опрос до ready, оригинал и настоящий JPEG thumbnail.
  2. docker compose stop worker, загрузка — 202, снимок queued; сообщение с вложением — 201; скачивание — 409; текстовое сообщение — 201; в очереди ≥ 1 сообщение, потребителей 0.
  3. scripts/restart.sh — рестарт LB, реплик, PostgreSQL, Valkey, S3 и брокера с сохранением volumes; сообщение в очереди, прежний токен читает queued. docker compose start worker — та же запись ready; оригинал с тем же SHA-256, thumbnail 256 × 160, crop 128 × 128, optimized WebP 320 × 200. В файле — ID и StartedAt до и после, без токенов. Relay не трогается.
  4. driver.py --port 8080 defense-faults → evidence/attachments/defense-faults.md: шесть окон на рабочем стенде (таблица ниже). Триггеры — только на уникальный filename прогона, после прогона их нет, worker и relay запущены при любом исходе.
Окно Действие Начато попыток Итог
после записи объектов до COMMIT kill worker, ожидание аренды 2 ready через 70 с, те же SHA-256 в S3 и метаданных
после COMMIT до ack заморозка и kill worker, сообщение вернулось 1 ready, no-op, тот же updated_at, очередь пуста
после COMMIT queued до publish kill relay, загрузка 202, 0 сообщений, запуск 1 ready без ручного задания
после confirm до отметки kill relay, сообщение есть, отметки нет, запуск — 2 сообщения 1 ready, дубль без эффекта
replay failed staging подменён, failed source_corrupted, реестр без изменений, объект возвращён, --apply 2 ready, то же задание, attempt_base 1, запись аудита
replay готового --apply на ready 1 код 3, already_ready, ничего не изменилось
  1. Для 5 — выбранный эксперимент, трек 1: make bench_queue_quick (~11 мин, рабочий стенд — make stop) на глазах или заранее и разбор evidence/queue/baseline/summary.md: таблица настроек, плато предела, второй worker, рестарты.

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

В шапке каждого файла — команда, дата, commit и стенд. На 9639aa1 (код src/ и bench/ тот же, что на 5ee3257, изменён только драйвер скилла: новые команды worker-memory, freeze-sessions, freeze-lb) сняты evidence/tests/student-test-lb.md, evidence/tests/test-isolated.md, evidence/cache/hits.md, evidence/auth/passwords-and-tokens.md, evidence/idempotency/replay-after-restart.md, evidence/worker/memory.md, evidence/storage/freeze-sessions.md. На d8fe2e8 (правки verify: сессии после заморозки, один срок на JSON-запрос, тест одновременных доставок) сняты evidence/tests/failure-checks.md, evidence/tests/service-tests.md. На 6ba74b1 (единица работы, поведение то же) сняты метки evidence/bench/unit-of-work-after/ и evidence/rollout/unit-of-work*/, а ещё evidence/replicas/test-persistence.md, evidence/failover/test-failover.md, evidence/attachments/defense-faults.md, evidence/s3/privacy.md, evidence/worker/process.md, evidence/relay/process.md. На 399da05 снята таблица «Красные прогоны» в failure-checks.md. Остальные файлы уровня 4 сняты на e2a6427: из кода приложения 399da05 меняет только src/utils/image_variants.py, одну ветку перевода в RGBA, а 6ba74b1 поведения не меняет. d8fe2e8 меняет только путь отказа: метки и файлы на 6ba74b1 не переснимались, потому что на пути без отказа правка убирает один таймер блока и обменов с PostgreSQL не добавляет, а make failure_checks на новом commit те же отказы прошёл. Остались снятыми на прежнем коде ff1a83b и названы так в шапках: метка evidence/uploads/baseline/, evidence/rollout/async-attachments/, evidence/migrations/async-attachments.md, evidence/s3/worker-key.md: это доказательства перехода уровня 3, их поведение уровень 4 не менял.

Уровень 3

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab5 public API scenario evidence/tests/test-isolated.md
Минимум лаб 1–4 сохранён с переходом 201 → 202 make student_test через LB 224 passed, реплики выполнены; сверка: 389 сценариев, 358 проверены, 31 исключение evidence/tests/student-test-lb.md
Тот же набор на временной базе make test_isolated smoke PASS; 218 passed, 6 skipped (реплики); уборка полная evidence/tests/test-isolated.md
Отказы make failure_checks (d8fe2e8) 141 passed, pytest 2214 с, crash markers 0 evidence/tests/failure-checks.md
Ветки сервисов и настоящая единица работы make service_test, make service_test_db (d8fe2e8) 201 passed за 1,44 с без хранилищ; 75 passed за 32,47 с на временной базе; 16 регрессий дают названный красный evidence/tests/service-tests.md
Заморозка PostgreSQL: сессий сверх пула нет, одна запись об отказе driver.py --port 8080 freeze-sessions (TCP-прокси пробы, сервер не трогается), driver.py freeze-lb (docker pause на своём временном проекте, рабочий mtusi-lab5 — код 2); то же в тестах test_no_sessions_over_pool_after_freeze, test_deadline_in_second_block_single_record 503 за 4,00–4,03 с при сроке 2 с, записей пула нет, сессий через прокси 0 во всех раундах; через LB 503 за 8,01–8,09 с, 504 нет, сессий до и после каждой заморозки поровну evidence/storage/freeze-sessions.md
202 только после устойчивого приёма и сохранения задания test_durable_state_at_202, test_upload_with_broker_stopped, test_upload_with_broker_paused к 202 объект в staging, строка и намерение в одной транзакции; брокер остановлен или заморожен — по-прежнему 202, намерение ждёт (на уровне 3 было 503) evidence/tests/failure-checks.md
Остановка API после ответа не теряет работу test_api_killed_after_202 реплика убита после 202, вложение становится ready evidence/tests/failure-checks.md
Отдельные broker и worker в общем compose driver.py broker-check, driver.py worker-process образ с тегом и digest, volume, AMQP только на loopback; PID 1 python -m src.worker, лимиты 1 CPU / 1 ГБ evidence/broker/stand.md, evidence/worker/process.md
Сообщения durable broker-check, test_queue_durable очередь durable, сообщение persistent evidence/broker/stand.md, evidence/tests/failure-checks.md
Доставка at least once, ack после устойчивого эффекта test_worker_killed_during_processing, test_redelivery_of_ready_is_noop worker убит посреди обработки — задание доводится; регрессия «ack до фиксации» делает тест красным (design, «Уточнения apply», п. 12) evidence/tests/failure-checks.md
Недоступность worker не вызывает синхронный resize test_worker_down_api_serves, worker-process API принимает и отвечает, _imaging нет в процессах реплик evidence/tests/failure-checks.md, evidence/worker/process.md
Состояния в API test_attachment_becomes_ready, test_queued_while_worker_stopped, test_processing_visible, test_undecodable_becomes_failed queued, processing, ready, failed видны в метаданных evidence/tests/student-test-lb.md, evidence/tests/failure-checks.md
Оригинал неизменен test_original_published_unchanged, driver.py attachment-storage те же байты и SHA-256; байты только в приватном bucket evidence/tests/failure-checks.md, evidence/attachments/storage.md
Thumbnail по контракту test_thumbnail_*, test_download_thumbnail 256 × 160 у fixture, округление вниз, минимум 1 px, EXIF, alpha на белый, настоящий JPEG, размеры и SHA-256 сходятся с метаданными evidence/tests/student-test-lb.md, evidence/attachments/defense.md
Ограниченный retry [worker] max_attempts = 5, test_transient_error_retried, test_attempts_exhausted временная ошибка повторяется под тем же job_id, исчерпание — failed с retry_exhausted evidence/worker/process.md, evidence/tests/failure-checks.md
Финальное failed с безопасным error_code test_undecodable_becomes_failed, test_staging_corrupted, журнал invalid_image, processing_failed; причина для оператора — в задании и журнале evidence/worker/logs.md, evidence/tests/failure-checks.md
Повтор не создаёт второго набора вариантов test_ready_failure_retried, test_redelivery_of_ready_is_noop; проба ограничения второй вариант с тем же именем — 23505 pk_attachment_variants evidence/attachments/storage.md, evidence/migrations/async-attachments.md
В сообщении нет bytes и credentials test_job_message_matches_schema сообщение проходит contracts/jobs.schema.json, только ID и служебные поля evidence/tests/failure-checks.md
Демонстрация: worker остановлен → … → ready driver.py --port 8080 defense-scenario все строки expected = got, StartedAt API и брокера новые, у relay прежний; thumbnail 256 × 160, crop 128 × 128, optimized 320 × 200 evidence/attachments/defense.md
Принятое задание переживает рестарт брокера с volume test_broker_restart_keeps_job, test_broker_kill_keeps_confirmed, test_broker_recreated сообщения на месте после stop, KILL и up --force-recreate evidence/tests/failure-checks.md
Очереди разных баз разделены make test_isolated KEEP_TEST_DB=1, broker-check --require-test-queue, make test_isolated очередь временной базы есть после первого и нет после второго evidence/broker/isolated.md
Сохранность и hook make test-persistence ACTION_SCRIPT=scripts/restart.sh PASS; api, haproxy, postgres, rabbitmq, s3, valkey — те же контейнеры и новый StartedAt, relay, worker и cleaner прежние evidence/replicas/test-persistence.md
Отказ реплики make test-failover stop и kill failed_attempts 0, восстановление 1,72 и 0,85 с evidence/failover/test-failover.md
Принявшая реплика остановлена driver.py attachment-failover --mode stop|kill файл отдаёт другая реплика, SHA-256 тот же, постороннему 404 evidence/attachments/failover.md
Согласованность БД и S3 driver.py upload-consistency 503, строки pending не видны, уборщик убрал по ключу staging, объектов без строки 0 evidence/attachments/consistency.md
Приватность S3, права worker make s3_check PASS: 90 checks; worker: запись и чтение — да, удаление, список, админ — 403 evidence/s3/cleaner-staging.md (и evidence/s3/worker-key.md, ff1a83b)
Журнал worker проба на стенде общий request_id записей задания, filename 0 раз, сообщение не по схеме — error без содержимого evidence/worker/logs.md
Миграция только расширяет, откат без отката схемы проба на временной базе, make rolling_update COMMIT=cc33a03 MIGRATE=0 и возврат (ff1a83b) CHECK NOT VALID, по lock_timeout — без изменений; прежний образ работает, чтение нового статуса — 500 evidence/migrations/async-attachments.md
Сроки LB пути загрузки driver.py lb-upload-timeouts 202 после 12 с молчания, 504 через 10 и 30 с, 400 в формате контракта evidence/uploads/lb-timeouts.md
Замена реплик под нагрузкой make bench_rollout ROLLOUT_LABEL=async-attachments (ff1a83b), ROLLOUT_LABEL=pipeline-reliability (e2a6427), ROLLOUT_LABEL=unit-of-work (6ba74b1) 8,52, 8,67 и 8,68 с, ошибок 0, новые миграции, записей столько же, сколько ключей (12000 и 12001) evidence/rollout/async-attachments/summary.md, evidence/rollout/pipeline-reliability/summary.md, evidence/rollout/unit-of-work/summary.md
Память реплики при загрузках make bench_uploads (ff1a83b) «с лимитом» 10 MiB: пик 172,9 / 180,1 / 185,6 MiB при 10 / 20 / 40 клиентах, OOM 0, 5xx 0 evidence/uploads/baseline/summary.md
Секретов в доказательствах нет поиск значений из .env по evidence/ 17 значений, 0 совпадений evidence/tests/secrets.md

Исключения сверки покрытия подтверждены файлами этой лабы: evidence/cache/hits.md, evidence/auth/passwords-and-tokens.md, evidence/idempotency/replay-after-restart.md сняты на 9639aa1, test_exclusion_evidence_exists зелёный.

Уровень 4

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Crop 128 × 128 по контракту test_crop_center, test_crop_small, test_crop_orientation_alpha, test_download_crop_optimized центр, маленькие растягиваются, ориентация, alpha на белый, JPEG; размеры и SHA-256 по байтам evidence/tests/student-test-lb.md, evidence/attachments/defense.md
Optimized WebP, параметры качества и удаление метаданных описаны test_optimized_fit, test_optimized_small, test_optimized_no_metadata, test_optimized_alpha; раздел «Варианты и лимиты обработки» вписан в 1280, без увеличения; quality=80, method=4; EXIF, XMP, ICC нет; прозрачность цела evidence/tests/student-test-lb.md, evidence/attachments/defense.md
Лимит по bytes test_limit_oversized_staging объект больше строки не читается: processing_failed evidence/tests/failure-checks.md
Лимит по пикселям test_limit_pixels invalid_image, причина limit_pixels evidence/tests/failure-checks.md
Лимит по времени test_limit_cpu_scan_bomb, test_limit_render_timeout настоящий дорогой JPEG прерван по CPU: invalid_image; срок процесса — временная ошибка evidence/tests/failure-checks.md
Лимит по памяти worker test_limit_memory, test_max_pixels_fit_worker_memory, test_pixel_limit_png_modes, test_render_killed, driver.py worker-process RLIMIT_AS — invalid_image; 40 Мпкс укладывается в любом типе PNG, включая серый с альфой и RGB с tRNS; убитый процесс обработки не роняет worker; лимиты 1 CPU / 1 ГБ; два файла на обеих границах — memory.peak 705–926 МиБ, сумма пиков 987 МиБ, OOM нет (driver.py worker-memory) evidence/tests/failure-checks.md, evidence/worker/process.md, evidence/worker/memory.md
Разрыв PostgreSQL и брокера закрыт outbox test_upload_with_broker_stopped, test_upload_with_broker_paused, test_relay_survives_broker_outage, test_relay_survives_database_outage, driver.py relay-process, broker-check 202 без брокера; у реплик нет настроек брокера; relay переживает отказы (тот же StartedAt, RestartCount 0) evidence/tests/failure-checks.md, evidence/relay/process.md, evidence/broker/stand.md
Crash между COMMIT и publish, задача доходит до ready без ручного задания driver.py defense-faults, окна «после COMMIT queued до publish» и «после подтверждения до отметки»; test_relay_killed_before_publish, test_relay_killed_after_confirm published_at пуст, 0 сообщений, после запуска relay — ready, attempt 1; при KILL после confirm — 2 сообщения, ready, attempt 1, очередь пуста evidence/attachments/defense-faults.md, evidence/tests/failure-checks.md
Состояние намерений видно оператору driver.py pipeline-state, в том числе при замороженном брокере задания по состояниям, due, аренды; брокер заморожен — available: false, код 0 evidence/relay/pipeline-state.md
Backoff с jitter test_retry_backoff_with_jitter, test_retry_waits_outside_worker, test_relay_respects_next_attempt пауза растёт случайно в [d/2, d], не занимает место конкуренции, попытка не раньше срока; регрессия «фиксированная пауза» — красный evidence/tests/failure-checks.md
Различие постоянных и временных ошибок test_undecodable_becomes_failed, test_staging_corrupted, test_transient_error_retried, test_attempts_exhausted постоянная — failed сразу (attempt 1); временная повторяется, затем retry_exhausted evidence/tests/failure-checks.md, evidence/worker/logs.md
Реестр failed make replay, test_replay_registry_dry_run, test_replay_by_code показ без изменений; выбор по коду и причине; реестр — строки PostgreSQL, отдельной DLQ нет evidence/relay/logs.md, evidence/attachments/defense-faults.md
Безопасный явный replay, не дубль успешной job driver.py defense-faults, окна replay; test_replay_returns_work, test_replay_ready_refused, test_replay_in_progress_refused, test_replay_without_source_refused, test_replay_new_budget --apply с выбором, то же задание, attempt 2, attempt_base 1, запись аудита; ready — код 3 already_ready, ничего не изменилось evidence/attachments/defense-faults.md, evidence/relay/logs.md
Остановка worker после записи объекта до ack, повтор завершает тот же результат driver.py defense-faults, окна «после записи объектов до COMMIT» и «после COMMIT до ack»; test_crash_after_objects_before_commit, test_crash_after_commit_before_ack те же SHA-256 трёх объектов в S3 и метаданных, attempt 2; после COMMIT — no-op, тот же updated_at evidence/attachments/defense-faults.md, evidence/tests/failure-checks.md
Timeout и lease зависшего processing test_hung_worker_lease_fencing, test_hung_worker_thawed_after_ready, test_long_attempt_keeps_lease, test_duplicate_during_processing, test_last_attempt_lost, test_worker_killed_during_processing истёкшую аренду возвращает relay; прежняя попытка после разморозки — superseded; живая не теряется, дубль без эффекта evidence/tests/failure-checks.md
Ограниченная конкуренция и prefetch test_concurrency_bounded, test_prefetch_bounded, test_published_backlog_limit, test_broker_memory_alarm prefetch 2 + конкуренция 2, сообщения сверх них у брокера; предел опубликованных 1000 evidence/tests/failure-checks.md, evidence/worker/process.md
Очистка staging после безопасной фиксации test_staging_removed_after_ready, test_staging_retention, test_staging_keeps_current_work, test_staging_cleanup_survives_outage, test_staging_foreign_key_kept, test_reconcile_orphan_staging, driver.py upload-consistency, make s3_check у ready убран следующим проходом (removed_ready), у failed по сроку; текущая работа цела; отказ S3 не держит сообщения; список уборщика только по двум префиксам evidence/tests/failure-checks.md, evidence/attachments/consistency.md, evidence/s3/cleaner-staging.md
Шаг 4 сценария защиты driver.py --port 8080 defense-faults шесть окон, все строки expected = got, триггеров не осталось evidence/attachments/defense-faults.md
Тесты ловят нарушение десять временных регрессий задачи 10.9 каждая даёт названный красный, откачена, хэши src совпали evidence/tests/failure-checks.md, раздел «Красные прогоны»
Журнал relay и worker, без filename и секретов проба на стенде общий request_id, причина и оператор replay, метка filename 0 раз evidence/worker/logs.md, evidence/relay/logs.md
Миграции расширяют, откат работает проба на временной базе, откат на 7f38948 и возврат CHECK NOT VALID, индексы indisvalid, планы по индексам решения 10, по lock_timeout без изменений; прежний образ работает; вложение прежнего образа — один thumbnail, crop 404, сверка без находок evidence/migrations/pipeline-reliability.md
Сроки LB после отказа от публикации driver.py lb-upload-timeouts 202 после 12 с молчания, 504 через 10 и 30 с, 400 в формате контракта; цепочка 26 с и 73 с evidence/uploads/lb-timeouts.md
Очереди разных баз разделены make test_isolated KEEP_TEST_DB=1, broker-check --require-test-queue, make test_isolated очередь временной базы есть после первого и нет после второго evidence/broker/isolated.md
Замена реплик с двумя ревизиями под нагрузкой make bench_rollout ROLLOUT_LABEL=pipeline-reliability 8,67 с, ошибок 0, a1d4c7e90b23 → d3f9a6b2c1e7, записей 12000 = ключей 12000, dirty false evidence/rollout/pipeline-reliability/summary.md

Трек 1 уровня 5

Change track1-queue-overload, код d667fa3, метка 7999002. Гипотезы, таблицы и выводы — раздел «Очередь под перегрузкой».

Критерий Команда Результат Файл
≥3 настройки на разных размерах make bench_queue 4 настройки × 4 класса (12 конфигураций) × 3 повтора evidence/queue/baseline/summary.md
Throughput, очередь, p95 до ready, RSS там же таблица «Настройки и классы» evidence/queue/baseline/cells.csv, timeline.csv
Backpressure и ограничение принятой работы там же, make failure_checks FAULT_ARGS='-k backlog' плато 250 против 425; 429 от мест, затем от предела; 6 тестов отказов evidence/queue/baseline/summary.md
Восстановление там же ноль незавершённых без оператора в 57 ячейках, потерянных и зависших 0; на lp (4, 4) 2 задания в failed, возврат — make replay evidence/queue/baseline/cells.csv
Компромисс latency и ресурсов там же раздел «Очередь под перегрузкой» REPORT.md

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

Поочерёдная замена на версию с брокером: метка async-attachments

Гипотеза: миграция и замена реплик с 04f8592 на ff1a83b идут без ошибок клиента, потому что схема только расширяется, а публикация ленива и не нужна чтениям и записи сообщений.

Методика — make bench_rollout: git.dirty false, swapouts_delta 0, посторонних контейнеров нет. Две реплики API 1 CPU / 512 МБ, PostgreSQL 2 CPU / 1 ГБ, Valkey 0,5 CPU / 128 МБ, HAProxy 1 CPU / 256 МБ, k6: 100 записей с ключом и 100 чтений в секунду, один прогон. В профиле только сообщения и история: загрузки не участвуют, поэтому смесь 201 и 202 он не показывает.

Замена Сборка / миграция Ревизия Ошибки до / во время / после Успешных в секунду p95 до / макс. во время Записи
8,52 с 1 / 1 с 5c3e1f0a9b7d → a1d4c7e90b23 0 / 0 / 0 200 / мин. 200 4 / 8 мс 12000 сообщений = 12000 ключей, повторов 0

CPU API всего: 0,54 ядра до и 0,55 после, 0,78 во время. Гипотеза подтверждена. Сырые данные — evidence/rollout/async-attachments/.

Поочерёдная замена на версию с relay: метка pipeline-reliability

Гипотеза: две ревизии (атомарная и индексы CONCURRENTLY) и замена реплик с 7f38948 на e2a6427 идут без ошибок клиента: схема только расширяется, а новым репликам брокер не нужен. Методика та же: git.dirty false, swapouts_delta 0, посторонних контейнеров нет, питание от сети. Загрузки в профиле не участвуют.

Замена Сборка / миграция Ревизия Ошибки до / во время / после Успешных в секунду p95 до / макс. во время Записи
8,67 с 1 / 2 с a1d4c7e90b23 → d3f9a6b2c1e7 0 / 0 / 0 200 / мин. 200 5 / 72 мс 12000 сообщений = 12000 ключей, повторов 0

CPU API всего: 0,61 ядра до, 0,95 во время, 0,62 после. Гипотеза подтверждена. Сырые данные — evidence/rollout/pipeline-reliability/.

Поочерёдная замена на единицу работы: метки unit-of-work и unit-of-work-previous

Гипотеза: API, схема и настройки те же, поэтому замена на 6ba74b1 идёт без ошибок клиента и с версии до pipeline-reliability, и с предыдущего commit. Методика та же: git.dirty false, swapouts_delta 0, host_warnings пусты, питание от сети; посторонние контейнеры на хосте — domains-api-1, domains-bot-1, domains-postgres-1 (названы в паспортах).

Метка, откуда Замена Сборка / миграция Ревизия Ошибки до / во время / после Успешных в секунду p95 до / макс. во время Записи
unit-of-work, 7f38948 (make bench_rollout ROLLOUT_LABEL=unit-of-work) 8,68 с 0 / 2 с a1d4c7e90b23 → d3f9a6b2c1e7 0 / 0 / 0 200 / мин. 200 6 / 161 мс 12001 сообщение = 12001 ключ
unit-of-work-previous, b2fb88f (bench/run.py --profile rollout --from b2fb88f) 10,2 с 1 / 3 с d3f9a6b2c1e7 → d3f9a6b2c1e7 0 / 0 / 0 200 / мин. 200 7 / 180 мс 12001 сообщение = 12001 ключ

CPU API на запрос до и после замены у unit-of-work: 3089 и 3113 мкс, PostgreSQL 493 и 524 мкс; у unit-of-work-previous — раздел «Единица работы» выше. Гипотеза подтверждена. Сырые данные — evidence/rollout/unit-of-work/, evidence/rollout/unit-of-work-previous/.

Память реплики при загрузках: метка baseline

Снята на ff1a83b, потому что на неё ссылаются исключения сверки лабы 4; с этой меткой новые не сравниваются (с уровня 4 профиль не запускает брокер). Методика — make bench_uploads: одна реплика 1 CPU / 512 МБ без swap, 72 прогона, 50 мин, медиана из 3 повторов; worker не запущен, задания ждут в очереди. Поправки к чтению — evidence/uploads/README.md.

Вариант, 10 MiB C = 10: пик, MiB C = 20 C = 40 OOM при 40 Загрузок/с при 10 p95 при 10, мс
с лимитом 172,9 180,1 185,6 0/3 10,50 1253
без лимита 227,6 331,0 OOM 3/3 9,00 1480

H1 (пик ограничен местами) и H4 (нет 503 по сроку S3) выполнены. H2 в сводке — «нет»: вариант «до» теперь 04f8592, где места уже есть, поэтому прежнее поведение он не показывает; настоящее «до» — отчёт лабы 4. H3 в сводке — «нет»: на 1 MiB «с лимитом» даёт 85–89 % «без лимита» при пороге 90 %, на 10 MiB — 117–121 %. Память приёма после перехода на брокер в границах прежних сценариев спека: ~185 MiB из 512 при 40 клиентах.

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

Трек 1 уровня 5, change track1-queue-overload. Код метки — commit d667fa3, сама метка baseline — commit 7999002 (dirty false, 57 ячеек из 57, 2 ч 05 мин, swapouts_delta 0, сна нет, питание от сети, предупреждений о хосте нет, посторонние контейнеры domains-* названы в паспорте). Гипотезы и правило записаны и закоммичены раньше метки. Числа порогов — из проб стадии propose (design, раздел «Пробы»); числа результатов ниже — из evidence/queue/baseline/summary.md и evidence/queue/baseline/cells.csv.

Метка переснимается как baseline2. Проверка нашла ошибки инструмента, которые нельзя поправить задним числом, поэтому метка снимается целиком заново на коммите с правками. Каталог baseline остаётся в репозитории как снятый раньше, с кодом и порогами в прежнем виде: числа ниже — пока его. Что неверно в baseline:

  • lb_down считал строку BACKEND репликой, и выход одной реплики не срабатывал: условие H7 «lb_down нет» метка не проверяла;
  • cpu_worker_per_job_s занижен на ~8–12 %: CPU до конца восстановления делился на все ready, включая окно after;
  • каждый перезапуск worker считался завершением ядром: причина в метке не проверялась;
  • queue lag есть только на ячейку, а не по окнам, в сводке его нет; CPU и троттлинг — не по всем окнам и ролям;
  • нет счётчика перезапусков relay, лишние строки в базе не искались.

Пороги H1–H9 и порог правила рекомендации не менялись.

Главное. Подтверждены H1, H2, H3, H5, H6, H7, H8, H9, H4 не подтверждена (2 ячейки из 33 ниже порога, причина — разбор ниже). Рекомендация правила — (2, 2), значения по умолчанию оставлены. Конкуренция сверх двух при 1 CPU не ускоряет, а на lp (4, 4) ломает обработку: 16 перезапусков worker за три ячейки и 2 принятых задания в failed. Настоящее ускорение даёт второй worker.

Команда: make bench_queue (метка baseline, ~2 ч 10 мин, RESUME=1), самопроверка — make bench_queue_quick (~11 мин, метка в git не идёт).

Методика. Стенд mtusi-bench: LB, две реплики API 1 CPU / 512 МБ, PostgreSQL 2 CPU / 1 ГБ, Valkey, S3 1 CPU / 512 МБ, брокер 1 CPU / 512 МБ, relay 0,25 CPU / 256 МБ, worker 1 CPU / 1 ГБ, уборщик 0,25 CPU / 256 МБ — лимиты рабочего стенда, без swap; у worker — restart: unless-stopped, как на рабочем стенде. Каждая ячейка — свежий стенд на новых volume.

  • Настройки (конкуренция, prefetch): (1, 1), (2, 2) — значения по умолчанию, (4, 4), (2, 256).
  • Классы: s — JPEG 1600 × 1200, q85, ~0,5 MiB; m — PNG из шума ~3,5 Мпкс, ~10 MiB; lj — JPEG 8000 × 5000, q88, ~8,6 MiB; lp — PNG RGBA 8000 × 5000, значащие 4 бита на канал, ~10 MiB. Файлы детерминированы от зерна, размеры и SHA-256 — в паспорте.
  • Матрица: (2, 2) и (4, 4) на всех классах; (1, 1) на m и lp; (2, 256) на s и lp, по три повтора, круги с перестановкой от зерна; план — в паспорте до первой ячейки.
  • Интенсивность одна на класс для всех настроек, низкая / высокая, загрузок/с: s 1,5 / 8, m 1,5 / 6, lj 1,2 / 6, lp 0,5 / 2,5. Открытая модель (constant-arrival-rate), ответ не повторяется: 429 — отказ.
  • Окна: before 10 с низкой λ; over 20 с высокой (блоки предела и рестартов — 25 с, приёма — 45 с); recovery — до нуля незавершённых, не дольше 420 с; after 10 с низкой λ.
  • Контрольный поток всё время: запись 10/с, чтение истории 10/с, скачивание готовых 5/с.
  • Блоки: gate-on и gate-off — s, (2, 2), 20/с, предел по умолчанию и выключен; accept — m, (2, 2), 15/с, 45 с; w2-p2, w2-p256 — второй worker в конце over; kill-worker — KILL и запуск посреди over; restart-broker — compose restart посреди over.
  • Шум: разброс — min–max трёх повторов. Разница двух конфигураций считается эффектом, только если их разбросы не пересекаются и разница медиан больше наибольшего разброса пары; иначе «в пределах шума». Отдельной метки A/A нет: настройка по умолчанию повторяется в каждом круге.

Определения.

Что Как считается Откуда
Очередь, outbox queued, не опубликовано, срок наступил PostgreSQL
waiting queued, не опубликовано, срок не наступил: пауза следующей попытки PostgreSQL
published queued, брокер подтвердил, никто не взял PostgreSQL
broker_ready, broker_unacked сообщения в очереди брокера и выданные, не подтверждённые метрики брокера
processing взято, идёт аренда PostgreSQL
prefetched max(0, broker_unacked − processing): у worker, ждёт места конкуренции вычисляется
unfinished outbox + waiting + published + processing: то, что считает предел PostgreSQL
oldest_s возраст старейшего незавершённого PostgreSQL
Throughput вложений с updated_at статуса ready в окне over и в окне recovery, делённые на длину окна GET /attachments/{id}
Время до ready updated_at у ready минус момент ответа 202; p50, p95, p99 по окну прихода; before и after — повторы сводятся вместе GET /attachments/{id}, k6
Queue lag возраст старейшего незавершённого, пик по окну тика (peak_oldest_<окно>_s), и время задания от подтверждения брокером до взятия, p50 и p95 по окну прихода (queue_wait_<окно>_*_ms) PostgreSQL, журнал worker
Восстановление от последней загрузки окна over до нуля незавершённых k6, PostgreSQL
RSS VmHWM процесса 1 worker, render_peak_kib процесса обработки (p50, наибольший), memory.peak, наибольшая anon, oom_kill; у перезапущенного контейнера — наибольшее и сумма по жизням /proc, журнал, cgroup
Причина завершения worker worker_die_oom (oom и код 137), worker_die_command (kill), worker_die_other (остальное, worker_exit_codes) docker events

Гипотезы.

№ Гипотеза Подтверждено, если
H1 Потолок при 1 CPU — CPU worker; конкуренция сверх двух его не поднимает на всех классах медиана throughput окна recovery (4, 4) / (2, 2) ≤ 1,05; CPU worker в окне over при c ≥ 2 ≥ 0,85 ядра; на m и lp (1, 1) / (2, 2) ≤ 1,0
H2 Обработка задания дольше пропорционально конкуренции, память растёт на пик процесса duration_ms p50 (4, 4) / (2, 2) ≥ 1,5 на всех классах; memory.peak (2, 2) < 1 ГБ без oom на всех классах; (4, 4) на lp: memory.peak ≥ 95 % лимита во всех повторах, oom_kill > 0 хотя бы в одном; (4, 4) на lj: без oom, пик ≤ 500 МиБ
H3 Большой prefetch не меняет throughput одного worker и прячет очередь от брокера и второго worker (2, 256) / (2, 2): throughput в [0,85; 1,15], p95 до ready в [0,8; 1,25] на s и lp; пик broker_ready ≤ 10 % пика незавершённых у (2, 256), ≥ 70 % у (2, 2); блок второго worker: доля второго среди заданий, завершённых после его запуска, ≥ 30 % при prefetch 2 и ≤ 5 % при 256, восстановление p256 / p2 ≥ 1,4
H4 Задержка под перегрузкой — это очередь на всех ячейках матрицы без oom p95 до ready окна over в [0,8; 1,25] × пик незавершённых / throughput
H5 Предел ограничивает принятую работу и срок ожидания gate-on: пик незавершённых ≤ 290, 429 > 0, у всех Retry-After 5, 5xx нет, 429 = записи backlog; gate-off: пик ≥ 375; gate-on / gate-off: p95 до ready и восстановление ≤ 0,75; p95 до ready gate-on в [0,8; 1,25] × предел / throughput; загрузка before p50 gate-on − gate-off ≤ 3 мс
H6 Восстановление: система приходит в норму сама и никого не теряет во всех ячейках lost, stuck, duplicate, sha_mismatch нет; восстановление ≤ 1,3 × пик незавершённых / throughput окна over (матрица без oom, предел); p95 after ≤ 1,5 × p95 before по конфигурации; failed только при oom и только retry_exhausted
H7 Перегрузка очереди не задевает остальной API во всех окнах всех ячеек, кроме accept: p95 записи и чтения ≤ 200 мс, скачивания ≤ 500 мс; 5xx контрольного потока нет; lb_down нет
H8 Рестарты под перегрузкой не теряют работу kill-worker: всё ready, заданий с повторной попыткой ≤ 2, очередь разобрана не позже большего из «конец over + 1,3 × пик / throughput» и «KILL + аренда 70 с + 15 с»; restart-broker: всё ready, заданий с повторной попыткой нет, 5xx на загрузке нет, восстановление ≤ 1,3 × пик / throughput + 15 с
H9 Приём ограничен S3, местами и затем пределом, а не падением; S3 общий с worker accept: первый 429 busy раньше первого backlog, оба есть, 5xx нет; CPU S3 в первые 30 с окна ≥ 0,85; принято за окно / длина окна ≥ 6/с; пик незавершённых ≤ 290; готовых/с в окне ≤ 1,5 при ≥ 2,4 в окне восстановления; контрольный поток: запись и чтение p95 ≤ 200 мс, скачивание ≤ 1 с, без 5xx

Вердикт считает bench/overload.py в сводке метки: «подтверждено», «нет», «нет данных».

Уточнения условий (пороги те же).

  • H3, доля второго worker. Порог говорит «среди заданий, завершённых после его запуска», а код считает только до нуля незавершённых. Окно after к опыту не относится: оно приходит после разбора бэклога, большого prefetch уже нечем держать, и новые задания брокер делит поровну при любом prefetch. По оценке проверки буквальная доля при prefetch 256 была бы ~6,4–6,8 %, то есть при буквальном прочтении H3 — «нет». Порог не менялся; чтобы это было числом, а не оценкой, в cells.csv есть second_share_all (все завершённые после запуска) и second_share_after (доля в окне after); вердикт считает прежний second_share.
  • H2 и правило рекомендации — по подтверждённому oom. В baseline любой перезапуск считался oom; в baseline2 это только завершение, подтверждённое событиями Docker, или счётчик cgroup. Условия не менялись, смысл стал тем, что в них написано; аварийный перезапуск не от ядра — пометка worker_crash, условие правила он не нарушает (QUESTIONS.md, вопрос 3).

Правило рекомендации. Кандидат — настройка без oom и failed ни на одном классе, с throughput не ниже 90 % лучшей на каждом классе; из кандидатов — наименьшая конкуренция, а prefetch равен конкуренции. Настройка, снятая не на всех классах, не кандидат: по плану это (1, 1) и (2, 256), сводка их называет, порог 90 % прежний. Значения по умолчанию меняются, только если рекомендация отличается от (2, 2), и выигрыш по throughput или памяти на каком-либо классе вне шума при том, что на остальных она не хуже в пределах шума; такая правка — отдельный commit после метки с повтором make bench_queue_quick. Компромисс latency и ресурсов — вывод из таблиц метки; проверяемая формула: concurrency ≤ min(CPU + доля ожидания, (лимит − база) / пик процесса).

Вердикты (evidence/queue/baseline/summary.md, раздел «Гипотезы»).

№ Вердикт На чём
H1 подтверждено (4, 4) / (2, 2) по throughput восстановления: s 2,57 / 3,02, m 2,67 / 2,95, lj 2,12 / 2,32, lp 0,24 / 0,96; (1, 1) / (2, 2): m 2,54 / 2,95, lp 0,94 / 0,96
H2 подтверждено duration_ms p50 (4, 4) / (2, 2): s 1503 / 634, m 1413 / 666, lj 1806 / 832, lp 3902 / 2060 мс; memory.peak (2, 2) не выше 838 МиБ; lp (4, 4) — 1024 МиБ во всех повторах; lj (4, 4) — 299 МиБ
H3 подтверждено пик очереди брокера при (2, 256) — 0, при (2, 2) на s — 98 из 100; второй worker взял 47–48 % заданий при prefetch 2 и 0 при 256
H4 нет m-c1p1-r2 0,797, m-c1p1-r3 0,778 при нижней границе 0,8; разбор ниже
H5 подтверждено пик 250 с пределом против 425 без него; p95 81,4 против 134,0 с; восстановление 81,5 против 141,5 с; все 429 — от предела, Retry-After 5; загрузка before p50 16 против 15 мс
H6 подтверждено lost, stuck, duplicate, sha_mismatch — 0 во всех ячейках, 2280 проверенных SHA-256; failed — только 2 на lp-c4p4-r1, что порог допускает: при oom и retry_exhausted
H7 подтверждено вне accept наибольшие p95 за все окна: запись 54,5, чтение 14,6, скачивание 262,4 мс; 5xx контрольного потока и lb_down нет
H8 подтверждено kill-worker: заданий с повтором 2 во всех повторах, восстановление 58,5 с; restart-broker: повторов 0, 5xx нет, восстановление 44,6 с
H9 подтверждено первый busy на 3,1–3,3 с, первый backlog на 34,0–36,3 с; CPU S3 в первые 30 с 1,00; принято 306–309 за 45 с; пик 282–285; готовых/с 0,80–0,93 в окне и 2,87–2,97 после

Оговорка к H6: lp (4, 4). Условие «p95 after ≤ 1,5 × p95 before» здесь проходит без смысловой нагрузки: p95 before по повторам — 83 с (lp-c4p4-r3: 83,27 с; r1 и r2 — 3,59 и 3,87 с), потому что окно before этого повтора задето OOM. Сравнивать тут не с чем: порог не меняется, но о возврате задержки на этой конфигурации условие ничего не доказывает. Что p95 after сам вернулся к 1,31–1,36 с, видно напрямую.

Настройки и классы (evidence/queue/baseline/summary.md, «Ячейки по конфигурациям»; медиана и min–max трёх повторов). «Процесс» — пик процесса обработки по его отчёту: p50 / наибольший.

Класс (c, p) Готовых/с: окно восстановление Пик незаверш. Пик брокера До ready over p50 / p95 / p99, с Восст., с memory.peak, МиБ VmHWM, МиБ Процесс, МиБ CPU worker, S3 Троттлинг worker OOM Перезапуски
s (2, 2) 3.00 (2.90–3.00) 3.02 (3.01–3.05) 100 (99–102) 98 (97–99) 17.1 / 31.7 / 33.1 33.6 (33.5–34.5) 175 (175–176) 114 49 / 49 1.00, 0.08 0.99 0 0
s (4, 4) 2.60 (2.60–2.60) 2.57 (2.35–2.57) 107 (106–108) 102 (102–104) 21.4 / 41.2 / 42.3 42.5 (42.5–46.5) 251 (247–251) 116 49 / 49 0.99, 0.08 0.99 0 0
s (2, 256) 3.00 (2.95–3.00) 3.01 (2.96–3.05) 101 (100–102) 0 (0–0) 17.1 / 31.9 / 33.4 33.6 (33.5–34.5) 175 (175–175) 114 49 / 49 0.99, 0.08 0.99 0 0
m (1, 1) 2.10 (2.05–2.15) 2.54 (2.51–2.56) 78 (77–79) 76 (74–78) 16.8 / 29.6 / 30.8 31.2 (30.3–31.3) 154 (154–154) 136 58 / 58 0.71, 0.70 0.15 0 0
m (2, 2) 2.70 (2.65–2.75) 2.95 (2.90–3.03) 66 (64–68) 63 (62–64) 12.1 / 21.5 / 22.3 23.2 (21.5–23.3) 211 (210–211) 161 58 / 58 0.95, 0.77 0.89 0 0
m (4, 4) 2.70 (2.70–2.70) 2.67 (2.57–2.71) 67 (66–67) 62 (62–62) 12.7 / 23.9 / 24.6 25.5 (25.4–26.2) 290 (280–293) 199 58 / 58 0.98, 0.78 0.96 0 0
lj (2, 2) 2.15 (2.00–2.25) 2.32 (2.29–2.34) 78 (75–81) 75 (73–79) 17.4 / 32.2 / 33.8 34.4 (32.3–35.2) 206 (204–206) 151 57 / 57 0.96, 0.62 0.92 0 0
lj (4, 4) 2.10 (1.95–2.15) 2.12 (2.08–2.14) 78 (76–82) 73 (72–78) 18.3 / 35.8 / 37.0 37.4 (36.3–39.3) 299 (293–306) 188 57 / 57 0.99, 0.64 0.97 0 0
lp (1, 1) 0.85 (0.85–0.85) 0.94 (0.91–0.94) 34 (33–34) 33 (32–33) 19.5 / 34.9 / 36.2 36.4 (36.4–37.0) 467 (466–467) 136 367 / 368 0.90, 0.29 0.23 0 0
lp (2, 2) 0.85 (0.85–0.90) 0.96 (0.96–0.99) 33 (32–34) 31 (30–32) 18.5 / 33.9 / 35.1 35.0 (33.8–35.4) 830 (696–838) 160 367 / 368 0.97, 0.30 0.97 0 0
lp (2, 256) 0.90 (0.90–0.90) 0.96 (0.94–0.96) 34 (32–34) 0 (0–0) 19.5 / 34.0 / 35.3 34.8 (34.0–35.7) 832 (742–834) 160 367 / 368 0.97, 0.30 0.98 0 0
lp (4, 4) 0.40 (0.30–0.40) 0.24 (0.17–0.53) 44 (44–46) 38 (37–42) 70.0 / 194.2 / 204.2 187.1 (83.1–249.1) 1024 (1024–1024) 215 367 / 368 0.97, 0.34 0.98 159 16
  • VmHWM у lp (4, 4) (215 МиБ) — только последняя жизнь контейнера: его читают в конце ячейки, а контейнер за ячейку перезапускался до 10 раз. Это не наибольшее значение за ячейку и не сравнимо с соседними строками.
  • Столбцы OOM и «Перезапуски» — суммы трёх повторов. Столбец OOM уже включает перезапуски: счётчик oom_kill прочитан у 143 завершений, 16 прибавлены как перезапуски (design, «Уточнения apply», п. 1).

Блоки (evidence/queue/baseline/summary.md, «Ячейки по конфигурациям» и «Блоки»; последний столбец — evidence/queue/baseline/cells.csv).

Блок Принято 429 Готовых/с: окно восстановление Пик p95 до ready, с Восст., с Второй worker
gate-on: 20/с, 25 с, предел 250 355 (355–357) 177 (176–178) 2.96 3.07 250 (250–250) 81.4 81.5 (81.5–83.5) —
gate-off: то же, без предела 532 (531–533) 0 3.00 3.02 425 (423–426) 134.0 141.5 (138.5–141.5) —
accept: m, 15/с, 45 с 338 (337–339) 369 (366–369) 0.89 (0.80–0.93) 2.95 (2.87–2.97) 283 (282–285) 92.7 90.2 (90.2–95.4) —
w2-p2 191 (190–192) 0 2.95 5.54 (5.52–5.78) 100 (100–101) 17.4 18.4 (17.6–18.6) 48 заданий, 0,47–0,48
w2-p256 193 (191–193) 0 3.00 3.04 (2.99–3.06) 101 (100–102) 31.6 33.5 (33.4–34.4) 0 заданий
kill-worker 231 (231–233) 0 2.80 2.24 (2.21–2.26) 129 (127–132) 40.9 58.5 (58.4–58.6) —
restart-broker 231 (231–231) 0 2.52 3.08 (2.95–3.11) 137 (136–137) 42.6 44.6 (44.4–46.5) —

Backpressure: где работа перестаёт приниматься и ускоряться.

Уровень Значение Что видит клиент Что показала метка
Места загрузки реплики 4 + 16, ожидание 5 с 429, Retry-After: 1 accept: 204–236 отказов с 3,1–3,3 с окна, загрузка 202 p50 ~4,8 с
Предел заданий 250 429, Retry-After: 5, сразу gate-on: плато ровно 250, первый отказ на ~14,7 с; accept: 130–165 отказов с 34,0–36,3 с, пик 282–285
Шлюз S3, общий с worker 1 CPU загрузка дольше accept: CPU S3 1,00 в первые 30 с, готовых/с 0,80–0,93 вместо 2,87–2,97 после окна
Outbox копит queued держится на 1–6, relay не узкое место; при рестарте брокера — до 47
max_published_backlog 1000 queued не достигнут ни в одной ячейке
Предел памяти брокера 400 МиБ queued не достигнут: медиана памяти брокера по конфигурациям 207–227 МиБ. Срабатывание проверяет test_broker_memory_alarm, отказы публикации в метке — только в restart-broker (2–3 прохода)
prefetch 2 queued неподтверждённых не больше prefetch во всех ячейках с (2, 2); при 256 — до 100 на s и до 34 на lp, а в очереди брокера 0
concurrency 2 processing processing не больше конкуренции, кроме ячеек с гибелью worker: строки убитого ждут аренду (kill-worker — 4, lp (4, 4) — 8–30); w2-* — 4 на двух worker
Лимит контейнера 1 ГБ дольше до ready, failed при исчерпании попыток (2, 2) помещается на всех классах, lp (4, 4) — нет

Клиент за входом видит только дольше не меняющееся queued, ни одного кода ошибки. Перестаёт приниматься на первых двух уровнях. Перестаёт ускоряться на CPU worker (конкуренция сверх двух), а на файлах у границы байтов — ещё на CPU S3, и там приём отнимает ресурс у обработки. Предел заданий останавливает это только на ~35-й секунде такой нагрузки: приоритета обработки над приёмом в S3 нет, это ограничение.

Разбор H4: почему «нет». Вердикт остаётся «нет»: условие записано раньше метки и на двух ячейках нарушено. Отношение p95 окна over к «пик / throughput окна over» (evidence/queue/baseline/cells.csv). Правая колонка — та же величина с throughput окна recovery: это расчёт после метки, порога у него нет, и на вердикт он не влияет.

Конфигурация Записанное условие, r1 / r2 / r3 С throughput recovery, r1 / r2 / r3
s-c2p2 0,912 / 0,938 / 0,962 0,948 / 0,953 / 0,968
s-c2p256 0,938 / 0,955 / 0,936 0,953 / 0,959 / 0,939
s-c4p4 1,010 / 0,984 / 1,058 0,998 / 0,973 / 0,955
m-c1p1 0,803 / 0,797 / 0,778 0,958 / 0,953 / 0,966
m-c2p2 0,879 / 0,840 / 0,881 0,967 / 0,936 / 0,946
m-c4p4 0,961 / 0,964 / 1,005 0,965 / 0,953 / 0,957
lj-c2p2 0,922 / 0,887 / 0,827 0,960 / 0,947 / 0,959
lj-c4p4 0,963 / 0,878 / 0,981 0,979 / 0,937 / 0,966
lp-c1p1 0,871 / 0,880 / 0,886 0,958 / 0,938 / 0,976
lp-c2p2 0,890 / 0,925 / 0,848 1,008 / 0,986 / 0,987
lp-c2p256 0,899 / 0,900 / 0,925 0,935 / 0,961 / 0,987

Всего 33 ячейки без oom: по записанному условию 0,778–1,058, две ниже 0,8; с throughput recovery 0,935–1,008.

  • Проверено по метке.
    • На m (1, 1) throughput окна over 2,05–2,15, окна recovery 2,51–2,56.
    • По timeline.csv это не разгон: готовых в секунду ровно ~2 все 20 с окна (m-c1p1-r2: первые 10 с — 2,1/с, последние — 2,1/с).
    • В окне over CPU worker 0,70–0,74 и S3 0,69–0,70, в recovery — 0,79–0,82 и 0,25–0,26.
    • Задание, пришедшее в конце окна, разбирается уже со скоростью recovery, а формула считает его по скорости over. Поэтому отношение занижено там, где эти скорости расходятся; сильнее всего — на m (1, 1).
  • Предположение, метка его не меряет: в окне over worker при (1, 1) медленнее, потому что ждёт S3, занятый приёмом. На это указывают CPU S3 и троттлинг worker 0,15, но времени ожидания S3 в метке нет.
  • Вывод. Причина в определении: в формулу гипотезы взят throughput окна, а разбирается очередь в основном после него. Это объяснение, а не отмена вердикта. Гипотеза в записанном виде не подтверждена. Данные показывают, что время до ready следует за очередью с отклонением до ~22 % вниз, а не с заявленным запасом 20 %, и на классах с заметным S3 отношение почти всегда ниже единицы. На ячейках с oom формула неприменима (lp-c4p4: 1,766 / 0,827 / 1,271): там задержку определяют аренда и повторы.

lp (4, 4): что произошло (evidence/queue/baseline/cells.csv).

Повтор Принято ready failed oom_kill с перезапусками Перезапуски Заданий с повтором Истёкших аренд processing, пик Восст., с p95 over, с CPU на задание, с
r1 63 61 2 69 10 36 40 30 249,08 194,23 2,075
r2 62 62 0 30 1 25 4 8 83,11 90,95 1,497
r3 63 63 0 60 5 34 20 20 187,07 194,96 1,824
  • Что значит. Четыре процесса по 367 МиБ не помещаются в 1 ГБ: memory.peak 1024 МиБ, наибольшая anon 951–1006 МиБ. Ядро завершает процессы обработки, задания возвращаются на новую попытку и снова занимают память. Работа делается повторно: CPU на задание 1,50–2,08 с против 0,94 при (2, 2). С первого раза не обрабатываются 40–57 % заданий. Когда завершён процесс 1, взятые задания ждут аренду 70 с (пик processing 30 при конкуренции 4), и worker простаивает: CPU в окне recovery 0,41 / 0,82 / 0,49. Итог — throughput 0,24 вместо 0,96 и p95 194 с вместо 34 с, при том же лимите. После разбора система приходит в норму: p95 окна after 1,31–1,36 с.
  • 2 failed — это 2 принятых задания из 188, ушедших в реестр. Клиент получил на них 202, а теперь видит status: failed и error_code: retry_exhausted (причина для оператора — render_killed). Варианта нет, новое сообщение с таким вложением получает 409. Сами они не восстановятся: возврат — make replay ERROR_CODE=retry_exhausted APPLY=1, оригинал лежит в staging до срока хранения (24 ч). Replay в этой метке не запускался, его проверяют make failure_checks и driver.py defense-faults. lost 0 означает только, что каждое принятое вложение названо состоянием, а не то, что каждое обработано.
  • Расхождение с пробами. Пробы ждали редких завершений процесса 1: один подтверждённый и один по тем же признакам из пяти прогонов, и в design записано «случайно». Метка показала другое: перезапуски во всех трёх ячейках, 16 за три прогона, до 10 в одной. Причина расхождения разобрана только частично: на пробах стоял restart: "no", первое завершение останавливало опыт, повторяться циклу было негде; метка идёт с unless-stopped, и цикл доходит до конца. Что перезапуск снова берёт дорогие задания и завершается по той же причине — предположение: повторные завершения в метке отдельно не прослежены. Частоту трёх повторов как оценку не использовать: она только показывает, что завершение не редкость.
  • Ограничение измерения. Метка не проверяет причину перезапуска: прибавляет каждый к oom_kill по косвенному признаку (design, «Уточнения apply», п. 1), .State.OOMKilled после нового старта сброшен. Другой аварийный выход процесса 1 в столбце от завершения ядром не отличается.

Восстановление (evidence/queue/baseline/cells.csv). Без действий оператора незавершённых становится ноль во всех 57 ячейках, очередь брокера пуста, not_recovered нет. Эффект не дублируется: 0 вторых заданий и наборов вариантов. Скорость разбора не падает: при (2, 2) recovery не ниже окна over. Время до ready возвращается (H6, условие по конфигурациям). Контрольный поток — H7; в accept наибольшие p95 — запись 39,2, чтение 15,1, скачивание 355,4 мс (порог H9 — 1 с), p95 скачивания в окне over — 342,9 мс против 8,3 на s при CPU S3 ~1,0, ошибок нет. Связь с занятым S3 — предположение: отдельно не мерилась.

Компромисс latency и ресурсов (вывод из таблиц выше).

  • Память без скорости. По правилу шума решения 11 (разбросы не пересекаются, разница медиан больше наибольшего разброса):
    • (4, 4) против (2, 2) — эффект в худшую сторону на s, m, lj: throughput ниже на 15, 10 и 9 %, память выше на 43, 38 и 45 %. На lp — потеря обработки.
    • (1, 1) против (2, 2) на lp — в пределах шума по скорости (0,94 и 0,96), памяти 467 МиБ вместо 830: выигрыш 44 %.
    • (1, 1) на m — эффект: на 14 % медленнее (2,54 и 2,95), памяти 154 МиБ вместо 211, потому что worker при одном задании ещё ждёт S3 (CPU 0,71).
  • CPU, а не конкуренция, поднимает потолок. Второй worker на s: 5,54 готовых/с вместо 3,02, восстановление 18,4 с вместо 33,6, ценой ещё 1 CPU и 1 ГБ лимита. Формула масштабирования этим не доказана (ограничения ниже).
  • Большой prefetch ничего не даёт и прячет очередь: та же скорость на s и lp, брокер показывает 0 готовых, второй worker простаивает, восстановление 33,5 с вместо 18,4.
  • Цена отказа клиенту. Предел обменивает принятые файлы на срок: 177 загрузок из ~533 получают 429, зато p95 до ready 81,4 с вместо 134,0. Цена проверки в окне before: p50 16 против 15 мс при разбросе того же порядка.
  • Формула подбора на двух точках сходится. Память: база ≈ 467 − 368 ≈ 99 МиБ на (1, 1), прогноз для (2, 2) — 99 + 2 × 368 = 835 МиБ при измеренных 830; (1024 − 99) / 368 ≈ 2,5, то есть 2 помещается, 4 нет; 3 в метке нет. CPU: при (1, 1) на m 0,71 ядра, значит, конкуренция 2 ещё даёт прирост, что и видно; при (2, 2) уже 0,95. Это согласие с данными, а не доказательство: опытов на формулу метка не ставила.

Рекомендация и значения по умолчанию (evidence/queue/baseline/summary.md, «Рекомендация»). Правило решения 12 даёт конкуренцию 2, prefetch 2. (1, 1) не кандидат: на m throughput ниже 90 % лучшей. (4, 4) не кандидат: на lp есть oom и failed. (2, 256) по правилу сводится к (2, 2): prefetch равен конкуренции. Значения оставлены: рекомендация совпала с (2, 2), поэтому условие смены не наступило и отдельного commit нет. Условия рекомендации: 1 CPU и 1 ГБ на worker. При другом лимите пересчитать по формуле выше; для потока только больших PNG (1, 1) экономит память без потери скорости, но это другая установка, а не значение по умолчанию.

Предел 250 по измеренному потолку. Обоснование решения 2 опиралось на пробу: потолок lp 0,92/с и ожидание ~270 с при границе 300 с ([relay] republish_after_seconds). Метка: потолок lp при (2, 2) — 0,96/с (recovery), 250 / 0,96 ≈ 260 с. Совпало только для измеренных классов: ожидание меньше 300 с, предел менять незачем. Запас меньше, чем кажется: с окном приёма (0,85/с) ~294 с, с превышением (пик до 290) ~302 с при потолке recovery и ~341 с при потолке окна, то есть за границей. Выход за границу на (2, 2) копий не даёт: выданное сразу взято, а пока в брокере есть готовые, relay не публикует заново. При (2, 256) задания старше порога получат копию, эффект нулевой по пробе (188 копий на 150 заданий, лишнего эффекта 0). В метке копий 0, но lp у предела не снимался.

Класс Потолок (2, 2), готовых/с Ожидание у предела 250, с Как получено
s 3,02 ~83 измерено: gate-on p95 81,4 с, восстановление 81,5 с
m 2,95 ~85 расчёт; accept при пике 283 измерил p95 92,7 с
lj 2,32 ~108 расчёт, у предела не снималось
lp 0,96 ~260 расчёт, у предела не снималось

Staging при заполненном пределе: 250 × 10 458 117 байт ≈ 2,4 ГиБ плюс превышение — расчёт, на lp у предела не снималось. Отставание очистки: наибольшее число ready с необнулённым staging за конфигурацию 35–194 (timeline.csv), очищается следующими проходами уборщика (60 с). Ограничение счёта, а не байтов названо ниже.

Ограничения метода.

  • Один хост и ВМ Docker Desktop (arm64, 12 CPU, 7,75 ГиБ): лимит 1 CPU — квота CFS, а не отдельное ядро; генератор и посторонние контейнеры на той же ВМ, доля их CPU видна по vm.
  • Один worker; второй — только в своём блоке и на классе, где S3 не узкое место (CPU S3 ~0,08): общая формула масштабирования не утверждается.
  • Ячейка — один класс, один файл на все загрузки: смесь размеров и разброс содержимого не мерятся.
  • Окна короткие, 20–45 с перегрузки: многочасовая перегрузка, autovacuum под длинным оборотом и рост WAL не мерятся, проба — только 90 с оборота.
  • Открытая модель без повторов: поток клиентов, послушно повторяющих после Retry-After, не мерится; отказ считается отказом.
  • PostgreSQL, relay и брокер в этих интенсивностях не упираются: их предел трек не определяет; max_published_backlog и предел памяти брокера нагрузкой не достигаются. Метка это подтвердила (таблица backpressure).
  • Одна нода S3, staging и конечный префикс на одном диске ВМ; ячейки — на свежем volume, поэтому рост памяти S3 с накопленными объектами не мерится (проба на старом стенде — KNOWN_ISSUES.md).
  • Выборки before и after малы на lp: повторы сводятся, p99 у малых выборок — только справочно.
  • Поправлено по метке. В решении 12 стояло: завершение процесса 1 ядром при (4, 4) на lp случайно, один подтверждённый случай и один по тем же признакам из пяти прогонов. Метка показала его в трёх ячейках из трёх, 16 раз. Частота из трёх повторов по-прежнему не следует, но «редко» неверно. «Работа не теряется» верно только с оговоркой: 2 задания из 188 ушли в failed и ждут make replay.
  • Предел считает задания, а не байты: lp в 3 раза дороже s при том же счёте; предел один на стенд, справедливости между пользователями нет.

Отказы

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
Worker остановлен, рестарт API и хранилищ, worker запущен принятая работа дожидается queued → ready, те же байты (defense.md) потерь нет
Брокер остановлен при загрузке 202, намерение ждёт, остальное API работает так (test_upload_with_broker_stopped, test_readiness_without_broker_and_worker) после возврата relay публикует, потерь нет
Брокер заморожен 202 без ожидания брокера так (test_upload_with_broker_paused) потерь нет
Relay убит до публикации 202, сообщения нет, следующий запуск публикует так (defense-faults.md, test_relay_killed_before_publish) потерь нет, ручного задания нет
Relay убит после confirm до отметки дубль сообщения без второго эффекта так (defense-faults.md, test_relay_killed_after_confirm) attempt 1, потерь нет
KILL брокера и up --force-recreate с volume подтверждённые сообщения на месте так (test_broker_kill_keeps_confirmed, test_broker_recreated) потерь нет
Сообщение потеряно вместе с очередью relay публикует снова, при непустой очереди копий нет так (test_lost_message_republished, test_no_copies_while_queue_has_messages) через republish_after_seconds, 300 с
Worker убит посреди обработки или после записи объектов следующая попытка по аренде, те же ключи так (defense-faults.md, test_worker_killed_during_processing) 70 с на рабочем стенде, потерь нет, попытка посчитана
Worker убит после COMMIT до ack повторная доставка, no-op так (defense-faults.md, test_crash_after_commit_before_ack) сразу после запуска, потерь нет
Worker заморожен дольше аренды новая попытка, прежняя не фиксирует ни при живой новой, ни после её итога так (test_hung_worker_lease_fencing, test_hung_worker_thawed_after_ready) по аренде, дублей эффекта нет
Дорогой файл в пределах контракта процесс обработки прерван по CPU, worker цел так (test_limit_cpu_scan_bomb) 15 с CPU на рабочем стенде, invalid_image
S3 недоступен при обработке повторы с backoff под одним job_id, затем ready или retry_exhausted так (test_transient_error_retried, test_attempts_exhausted) рабочий стенд выдерживает сумму пауз 37,5–75 с и сроки попыток (расчёт по настройкам, design, решение 4; тесты — на коротких сроках стенда отказов); дольше — failed, возврат make replay
S3 недоступен при очистке staging проход прерван, сообщения не ждут так (test_staging_cleanup_survives_outage) следующий проход повторяет
PostgreSQL недоступен при обработке задание ждёт, попытка не считается так (test_database_outage_during_processing) потерь нет
Сообщение не по схеме отброшено, error без содержимого так (test_malformed_message_dropped, logs.md) следующие задания идут
Реплика API остановлена или убита запись через другую failed_attempts 0 (test-failover.md) 1,72 и 0,85 с, потерь нет

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

Ограничения этого уровня, названные спеками:

  • Отказ S3 дольше бюджета. Сумма пауз 37,5–75 с и сроки попыток: рестарт S3 (~25 с) укладывается, более долгий отказ переводит взятые задания в failed retry_exhausted. Лечит make replay ERROR_CODE=retry_exhausted APPLY=1: это явный шаг оператора, а не автоматика.
  • Восстановление после KILL по аренде. После KILL worker следующая попытка начинается по истечении аренды, до 70 с (наблюдали 70 с). Пульс отвергнут (раздел «Ответы на вопросы защиты»). Повторная доставка уже готовой работы — сразу.
  • Дубли сообщений. Неизвестный исход публикации, crash до отметки и потерянные сообщения дают дубли: at least once. Каждый дубль — SELECT … FOR UPDATE и ack, эффект защищён ключом и fencing. Сообщения, которые держит большой prefetch дольше republish_after_seconds, брокер готовыми не считает: они могут получить копию.
  • Объект, дописанный прежней попыткой. Фиксацию fencing прежней попытке запрещает, но замороженный процесс после разморозки может записать объект теми же байтами: ключ тот же, версия декодера та же.
  • Профиль ICC отбрасывается. Учебные данные — sRGB; изображение с другим профилем изменит цвет в вариантах.
  • Лимит памяти на macOS. setrlimit(RLIMIT_AS) на хосте macOS отказывает, консольный worker это пишет в журнал (render_memory_limit_applied); на стенде Linux лимит действует.
  • Цена процесса на задание. Метка baseline: CPU worker на задание при (2, 2) — 0,30 с на s и m, 0,39 на lj, 0,94 на lp (evidence/queue/baseline/cells.csv). Долю запуска процесса метка не выделяет, проба — ~100 мс на маленьком файле. Forkserver (9 мс) отвергнут сейчас: секреты родителя в окружении и свой жизненный цикл. Граница — один модуль.
  • Изоляция секретов процесса обработки неполная. В его окружении секретов нет, но он идёт под тем же UID, что процесс 1 worker, и может прочитать /proc/1/environ с ключами S3 и паролями PostgreSQL и брокера. От случайной утечки это защищает, после эксплойта декодера — нет. Предложение — PR_SET_DUMPABLE=0 в процессе worker, вопрос преподавателю (QUESTIONS.md, ## pipeline-reliability).
  • Дорогие файлы занимают worker. Предел считает задания, а не байты и CPU. Измерен файл на границе байтов и пикселей: ~1 с CPU, поток таких файлов при 250 незавершённых ждёт ~260 с. Худший случай не измерен: scan bomb в пределах контракта стоит лимит процесса, 15 с CPU, расчётом 250 × 15 с ≈ 1 час разбора и копии от relay при таком ожидании. Обоснование предела «ожидание меньше 300 с» верно только для измеренных классов, для этого файла — нет. Защиты, кроме лимита на файл, нет.
  • Завершение процесса 1 worker ядром. Конкуренция, которая не помещается в лимит памяти, стоит не только повторов: lp (4, 4) — 16 перезапусков за три прогона, задания ждут аренду 70 с, 2 из 188 ушли в failed retry_exhausted. Значение по умолчанию на всех классах помещается; правило подбора — раздел «Очередь под перегрузкой».
  • Приём у границы байтов отнимает S3 у worker. Готовых/с 0,80–0,93 вместо 2,87–2,97, пока S3 занят приёмом. Приоритета обработки нет, предел останавливает это на ~35-й секунде такой нагрузки.
  • Предел мягкий и один на стенд. Превышение — загрузки в полёте (измерено до 285 при пределе 250), справедливости между пользователями и чатами нет.
  • Сверка не проверяет объекты вариантов. Наличие и размер объектов вариантов сверка не проверяет: вариант без объекта даёт 500 на скачивание и error в журнале (test_missing_variant). Объекты staging она с этого уровня видит (orphan_staging).
  • Удаление очереди при работающем worker. Потребитель этого не замечает: relay создаст очередь заново, worker нужно перезапустить. На стенде такого нет, кроме уборки своей очереди после остановки своего worker.
  • Старые ready без crop и optimized. Вложения уровня 3 остаются с одним thumbnail, скачивание этих вариантов — 404; replay ready запрещён намеренно. Показано в evidence/migrations/pipeline-reliability.md.
  • Staging и конечный префикс на одном сервере S3. Устойчивость staging — устойчивость этого сервера и bucket: отказ диска или ВМ теряет и то, и другое.
  • Отставание очистки staging. Объект живёт до следующего прохода уборщика (60 с). Метка baseline: наибольший долг по конфигурациям 35–194 вложения, разбирается следующими проходами; многочасовая нагрузка не мерилась. S3 на долго живущем стенде — KNOWN_ISSUES.md.
  • Смесь версий при замене на уровень 3 и новые статусы. С версии лабы 4: прежняя реплика отвечает 201 ready и даёт 500 на чтении строки нового статуса (evidence/migrations/async-attachments.md). Для загрузок реплик прежней версии, переживших grace, защита пометкой уборщика не гарантирована: они пометку не проверяют. Запись — KNOWN_ISSUES.md. Порядок обновления с уровня 3 — раздел «Разрыв COMMIT и publish и окна отказа».
  • Прерванное остановкой задание. Задание, прерванное docker stop дольше graceful_shutdown_seconds (8 с), считается начатой попыткой и продолжается по аренде: release на пути отмены ненадёжен. Замер на двух дорогих JPEG: 8,15 с, при замороженных PostgreSQL и брокере 9,18 с (evidence/worker/process.md). Худший случай остановки 8 + 0,5 + 0,5 + 0,5 = 9,5 с < 10 с.
  • Искажения данных скана JPEG. Структурная проверка и libjpeg байт внутри данных скана ошибкой не считают: такое вложение становится ready, а варианты будут с мусором. Проверка не декодирует пиксели при приёме намеренно.
  • Цена соединения на шаг. Двухшаговая JSON-ручка выдаёт соединение дважды: под перегрузкой запрос встаёт в очередь пула дважды, запас на ожидание у него около половины общего срока. Отказ БД при откате успешного чтения — 503, окно в один обмен: откат теперь до ответа. Отмена задачи сбрасывает соединение вместо возврата в пул (design change unit-of-work, Risks).
  • Подмена do_ping. Дешёвая проверка соединения опирается на внутренние имена адаптера asyncpg в SQLAlchemy: закреплён <2.2, смену ловят тесты test_ping_* в make service_test_db. Прерванная проверка не оставляет сессий сверх пула только потому, что BoundedCloseConnection сам обрывает внутренний _transport asyncpg (design.md, уточнение 17): смену имени ловит test_no_sessions_over_pool_after_freeze.
  • Фейки не проверяют блокировки. Быстрый тест зелёный при сломанном SKIP LOCKED: блокировки и конкуренцию доказывает только make failure_checks (таблица решения 11 design).
  • Метаданные и скачивание вложения без общего срока. Вход и блок — до 12 с при timeout server 10 с: клиент получит 504 от LB вместо 503. Дефект прежний, запись — KNOWN_ISSUES.md.
  • Цепочка LB. Брокера в пути нет, поэтому самым долгим снова стал путь компенсации: после тела проверка ~4 + tx1 6 + PUT 5 + tx2 6 ≈ 21 с, с DELETE компенсации + 5 ≈ 26 с < timeout server 30 с. Наибольшая длительность живой загрузки U = 17 + 30 + 26 ≈ 73 с < дренаж замены 90 с: до тела 2 × request_timeout_seconds + wait_timeout_seconds = 17 с; тело — [uploads] body_timeout_seconds 30 с.

Другие ограничения:

  • CHECK статуса, ck_attachments_error_code_failed и ck_attachment_jobs_attempt_base остаются NOT VALID: VALIDATE держал бы блокировку на время просмотра таблицы, а прежние строки условиям отвечают.
  • Один пользователь брокера на relay и worker; разделение прав — лаба 7.
  • Предел памяти брокера 400 МиБ блокирует публикацию: relay получает отказ по сроку 2 с, загрузка по-прежнему 202, намерения копятся в PostgreSQL (test_broker_memory_alarm), пока не достигнут предел незавершённых заданий.
  • Ранний ответ при загрузке: urllib напрямую к реплике на большом теле теряет ранний ответ; через LB и с httpx или curl — получает.
  • Keyset-пагинация: порядок задаёт (created_at, id); created_at назначает сервер, при расхождении часов реплик порядок вставки возможен только по этому ключу.

Следующие шаги. Вне трека и не сделано: приоритет обработки над приёмом в S3, предел по байтам и на пользователя, forkserver, рост памяти S3 с накопленными объектами. Подтверждено замером только то, что есть в разделах выше.

Источники, библиотеки и использование ИИ

Документация: RabbitMQ reliability, Publisher confirms and acknowledgements (из README.md задания); aio-pika — https://docs.aio-pika.com/; Pillow — https://pillow.readthedocs.io/ (Image.draft, resize с reducing_gap, EXIF); PostgreSQL 18 — NOT VALID, FOR UPDATE, lock_timeout; Harry Percival, Bob Gregory, «Architecture Patterns with Python» (Cosmic Python), главы 2 и 6 — Repository и Unit of Work; источники лаб 2–4 — в их отчётах. Поведение брокера и Pillow проверено пробами: таблица «Пробы» в openspec/changes/archive/2026-10-31-async-attachments/design.md.

Библиотеки: новые — aio-pika 10.2.1, Pillow 13.0.0 (из dev-группы в основную); уровень 4 новых не добавил: WebP уже есть в Pillow (libwebp 1.6.0); единица работы — тоже: async def тесты запускает плагин anyio, он уже в зависимостях. Остальное — uv.lock. Пробы уровня 4 — таблица «Пробы» openspec/changes/archive/2026-10-31-pipeline-reliability/design.md.

ИИ. Код, тесты, инструменты, спеки, снятие доказательств и этот отчёт сделаны с помощью Claude Code (Anthropic) по циклу OpenSpec: предложение, реализация, проверка, правки по проверке, архивация; каждую стадию вёл отдельный агент, основная сессия принимала результат и коммитила. Перенос на единицу работы (unit-of-work, по указанию пользователя) — так же, проверен наборами student-tests/ и make failure_checks без их правок и временными регрессиями; очередь под перегрузкой (track1-queue-overload) — гипотезы и правило рекомендации записаны до метки, метки сняты командой make bench_queue; метку baseline отменили ошибки инструмента, найденные проверкой, baseline2 — выгрузка хоста в swap (QUESTIONS.md). Выбор оценки, трека, брокера и единицы работы — решения автора; решения и отвергнутые варианты — design.md, принятые без пользователя — QUESTIONS.md. Каждый файл evidence/ снят командой из его шапки на стенде этой лабы, а не сгенерирован; числа в отчёте перенесены из выводов команд на названном commit.