Files
mtusi2026lab5/REPORT.md
T
2026-11-10 14:47:33 +03:00

44 KiB
Raw Blame History

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

Понятное объяснение, команды демонстрации и ответы для защиты — в EXPLANATION.md.

  • Автор, группа: Максимова Мария, БВТ2303.
  • Целевая оценка: 4. Исследовательский трек на 5 не выбирается.
  • Ветка: solution/maksimova_bvt2303. Commit и PR ещё не опубликованы.
  • Основа: собственная реализация lab4; задание, COURSE.md, contracts/ и публичные проверки текущей lab5 сохранены.
  • Библиотеки: FastAPI 0.115.0, SQLAlchemy 2.0.36/asyncpg 0.30.0, argon2-cffi 23.1.0, redis-py 5.0.8, aiobotocore 2.15.2/botocore 1.35.36, Pillow 11.0.0, aio-pika 9.4.3. Полный список закреплён в requirements.txt.
  • Источники: задание и контракт этой лабораторной, собственная lab4; ссылки из задания на надёжность RabbitMQ и подтверждения публикации и обработки. Помощь ИИ (Codex): адаптация API, реализация очереди и worker, проверка кода, собственные тесты, оформление отчёта и объяснения для защиты. В таблицах ниже указаны реальные прогоны.

О чём работа, зачем и почему

В lab4 сервер принимал картинку и сохранял готовое вложение. Теперь нужно ещё сделать уменьшенную копию, квадратную обрезку и WebP. Если выполнять это внутри HTTP-запроса, клиент дольше ждёт, а процесс API занят изображением вместо ответов на сообщения.

В этой работе приём файла и обработка разделены. API принимает все байты и надёжно сохраняет исходник вместе с заданием. Отдельный процесс — worker — получает работу через очередь и создаёт варианты. Клиент сначала получает 202 queued, а готовность узнаёт отдельным GET. Смысл 202: «файл принят и работа сохранена».

Очередь нужна ещё и для восстановления. Worker может остановиться, сервер может перезапуститься, задание может прийти повторно. Нужно сохранить принятую работу и получить один правильный результат. Поэтому здесь важны порядок записи в БД, подтверждения, ограниченные повторы и защита от дублей.

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

Стенд проверки: Windows 11, Docker Desktop 29.3.0 с Linux-контейнерами, 14 vCPU и около 7.4 GiB RAM для Docker; Python 3.13.3 на хосте. Образ приложения использует Python 3.12.7. Нужны запущенный Docker Desktop и Docker Compose. Python на хосте нужен для публичных проверок; собственные проверки с управлением контейнерами запускаются в tester.

Роль Service Версия/образ Готовность и сохранность
Балансировщик lb haproxy:3.0.11-alpine /lb-health; проверяет /health/ready API; внешний порт по умолчанию 8080
API ×2 api messenger-lab5-api:dev, сборка из python:3.12.7-slim /health/ready; собственных volumes нет
БД db postgres:16.4-alpine pg_isready; volume postgres_data
Кэш сессий valkey valkey/valkey:8.0.1-alpine PING; исходные сессии в PostgreSQL, кэш можно потерять
Приватное S3 s3 chrislusf/seaweedfs:3.97 /healthz; volume s3_data
Брокер broker rabbitmq:3.13.7-alpine rabbitmq-diagnostics ping; volume broker_data, постоянное имя узла broker
Публикация publisher тот же образ приложения python -m app.jobs; повторяет подключение при отказах
Обработка worker тот же образ приложения python -m app.worker; одна активная задача, prefetch=1
Миграции migrate тот же образ приложения однократный запуск; применённые SQL повторно пропускаются
Создание bucket s3-init тот же образ приложения однократный запуск, проверяет приватность и права S3
Проверки tester python:3.12.11-alpine3.22, Docker CLI из docker:28.5.1-cli профиль tools; make и Pillow

PowerShell, из корня репозитория:

powershell -ExecutionPolicy Bypass -File scripts/init-secrets.ps1
if (-not (Test-Path .env)) { Copy-Item .env.example .env }
# Если 8080 занят, изменить в .env LB_PORT=8080 на LB_PORT=8081.
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build --wait --wait-timeout 180
docker compose ps

# Все проверки API и уровня 4 одной командой; Python на хосте без дополнительных пакетов.
# Тесты запускаются в Docker, логи автоматически сохраняются в evidence/.
python -X utf8 scripts/test_lab5.py
# Короткая проверка без остановок сервисов:
# python -X utf8 scripts/test_lab5.py --quick

# Ниже порт проведённых прогонов: 8081. Для стандартного порта указать 8080.
python -X utf8 scripts/check_contract.py
python -X utf8 tests/smoke.py --base-url http://localhost:8081

# Полная проверка OpenAPI и JSON Schema:
python -m venv .venv
.venv/Scripts/python -m pip install -r requirements-dev.txt
.venv/Scripts/python -X utf8 scripts/validate_openapi.py

# Собственные проверки и публичные сценарии с POSIX hooks:
docker compose --profile tools build tester
docker compose --profile tools run --rm tester python3 student-tests/lab5_images.py
docker compose --profile tools run --rm tester python3 student-tests/lab5_recovery.py
Get-Content -Raw student-tests/lab5_limits.py | docker compose exec -T worker python
docker compose --profile tools run --rm tester make test-persistence ACTION_SCRIPT=scripts/restart.sh BASE_URL=http://lb:8080
docker compose --profile tools run --rm tester make test-failover ACTION_SCRIPT=scripts/stop-one.sh BASE_URL=http://lb:8080
docker compose --profile tools run --rm tester sh scripts/start-api.sh

На машине проверки 8080 был занят, поэтому локальный .env задаёт LB_PORT=8081. В .env.example оставлен обычный 8080. Внутри Docker адрес всегда http://lb:8080; tester получает его автоматически вместе с именем проекта messenger-lab5.

scripts/test_lab5.py подходит и для Windows, и для Linux. Он проверяет, что сервисы уже запущены, собирает tester и последовательно выполняет проверку контракта, smoke, семь тестов валидатора, проверку вариантов и ограничений декодера. Полный запуск дополнительно воспроизводит шесть сценариев recovery, публичные persistence и failover. После failover вторая API-реплика запускается обратно. Файлы доказательств содержат UTC-время, команду и код завершения; container-events.txt фиксирует состояния контейнеров до и после публичных отказов. Полная валидация OpenAPI выполняется отдельно с requirements-dev.txt, как показано в блоке команд.

Workflow .github/workflows/application.yml запускает полный runner и сохраняет текстовые логи как артефакт. Схемы проверяет отдельный workflow contracts.yml. Эти workflows подготовлены для CI; результат удалённого GitHub Actions в локальные доказательства не включается.

В Linux вместо PowerShell: sh scripts/init-secrets.sh, cp .env.example .env. Для публичных проверок — make check, make test BASE_URL=http://localhost:8080; для схемы — make validate PYTHON=.venv/bin/python после установки requirements-dev.txt. Проверка ресурсов: docker compose exec -T worker python < student-tests/lab5_limits.py.

Скрипты создания secrets генерируют случайные значения локально, не печатают их и не перезаписывают существующие файлы. Они лежат в infra/secrets/, исключённом из Git; .env тоже исключён. При старте ожидаются хранилища, затем выполняются migrate и s3-init, после них запускаются API, publisher и worker; LB ждёт готовности API. Новая миграция — migrations/005_async_pipeline.sql.

Безопасная остановка с сохранением данных:

docker compose stop
# Возобновить работу с теми же volumes:
docker compose up -d --wait --wait-timeout 180

Отдельная команда намеренного удаления всех учебных данных, включая пользователей, сессии, файлы и очередь:

docker compose down -v

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

клиент -> HAProxy -> api x2 -> PostgreSQL: пользователи, чаты, сообщения,
                          |              сессии, вложения, outbox, job_events
                          +-> Valkey: кэш сессий
                          +-> S3: staging/<случайный ключ> — принятый исходник

PostgreSQL outbox -> publisher -> RabbitMQ -> worker -> S3: конечный original,
                                                          thumbnail, crop, optimized
                                                  -> PostgreSQL: ready + метаданные

клиент -> GET /attachments/{id}: queued / processing / ready / failed

Из lab4 сохранены регистрация, Basic-вход и Bearer-сессии, авторизация участников чата, сообщения с идемпотентным POST, пагинация, две API-реплики, X-Request-Id/X-Instance-Id, HAProxy, graceful shutdown, приватное S3 и скачивание через API. Изменение upload 201 ready → 202 queued предусмотрено контрактом lab5. queued и processing разрешено прикреплять к сообщению; failed — нельзя, ответ 409. Скачать содержимое до ready тоже нельзя: 409.

Источник истины. PostgreSQL хранит принадлежность файла чату, исходные размер и SHA-256, состояние, попытку и намерение обработать файл. S3 хранит байты. RabbitMQ доставляет задания, а outbox позволяет восстановить ещё не опубликованное задание. Valkey ускоряет проверку сессий, но не заменяет PostgreSQL.

Что происходит до ответа 202

  1. API проверяет пользователя и членство в чате, имя файла, MIME, размер и изображение по содержимому. Разрешены PNG/JPEG до 10 MiB и 40 млн пикселей. Имя от клиента используется для отображения; путём S3 оно не становится.
  2. Тело читается частями во временный spool: в памяти до 1 MiB на загрузку, остальное во временном файле. SHA-256 считается во время чтения. На реплику разрешено до восьми одновременных загрузок; ожидание слота ограничено 10 секундами, приём тела — 60 секундами.
  3. В БД фиксируется upload_intent: пометка для поиска незавершённой загрузки. Затем все байты записываются в приватный S3-prefix staging/.
  4. Одной транзакцией PostgreSQL удаляется intent, создаётся вложение queued и строка outbox. Только после COMMIT возвращается 202 со снимком queued и пустым списком вариантов.

Staging здесь уже находится в S3. Это не временная память API и не готовый результат: worker позже читает объект, проверяет исходный SHA-256 и пишет оригинал в конечный prefix вместе с вариантами. Поэтому выключение API после 202 не теряет принятые байты.

Если S3-запись прошла, а транзакция вложения не завершилась, остаётся intent. Сохраняется уборка из lab4: незавершённые загрузки удаляются после UPLOAD_GRACE_SECONDS=900. Блокировка строки intent защищает от одновременного завершения upload и удаления файла уборщиком. При неизвестном исходе COMMIT сначала проверяется intent, чтобы не удалить уже принятое вложение.

Зачем outbox и чем confirm отличается от ack

Нельзя одним обычным COMMIT одновременно записать PostgreSQL и отправить сообщение RabbitMQ. Если записать БД и упасть перед отправкой, запись есть, а worker о ней не узнает. Поэтому намерение отправить задание хранится в outbox вместе с вложением.

Publisher выбирает строку под FOR UPDATE SKIP LOCKED, публикует persistent-сообщение в durable-очередь attachments, ждёт publisher confirm и отмечает строку опубликованной. Confirm означает: брокер принял сообщение. При падении после отправки, но до отметки в БД отправка повторится — это допустимый дубль.

Consumer ack отправляет worker после устойчивой фиксации результата или сохранённого решения о повторе/ошибке. Ack означает: эту доставку можно убрать из очереди. Принятие брокером ещё не означает, что картинка обработана.

Сообщение соответствует contracts/jobs.schema.json: версия схемы, job_id, attachment_id, pipeline_version, attempt, тип и время создания. В нём нет байтов, паролей или клиентского URL. Доверенный ключ объекта worker получает из БД.

Состояния, повторы и защита от дублей

Состояние Что означает Что происходит дальше
queued Исходник и задание сохранены Publisher доставляет задание, worker захватывает его
processing Worker получил аренду задачи — lease Выполняется ограниченная по времени обработка
ready Оригинал и три варианта записаны, метаданные опубликованы Можно скачивать; дубль не меняет результат
failed Постоянная ошибка либо закончились попытки Безопасный error_code, реестр для оператора; возможен явный replay

Worker обрабатывает одну задачу за раз, prefetch=1 не позволяет заранее забрать большую пачку. При захвате увеличивается счётчик попыток и выдаётся случайный lease_token на 120 секунд. Общий дедлайн — 90 секунд, меньше lease. Записать результат может только владелец ещё действующего token. Если worker погиб и остался processing, publisher находит истёкшую аренду и сохраняет повтор в БД/outbox.

Логическая работа имеет постоянный job_id; управляемая попытка увеличивает attempt. Ключ результата — (attachment_id, pipeline_version, variant). Здесь pipeline_version=1: конечные ключи имеют вид originals/<attachment_id>/v1/original, thumbnail.jpg, crop.jpg, optimized.webp. Повтор пишет те же байты по тем же ключам, а список вариантов фиксируется одной транзакцией. Дубль ready не запускает resize. Устаревшая попытка не может перезаписать состояние новой благодаря проверке attempt и lease token.

При временном отказе, например недоступности S3, сохраняются следующая попытка и её срок. Максимум — JOB_MAX_ATTEMPTS=5 на один запуск или явный replay. Backoff растёт экспоненциально; случайная задержка (jitter) выбирается между половиной и полным значением верхней границы. Для базы 1 секунда первые интервалы: 0.5–1, 1–2, 2–4, 4–8 секунд; верхняя граница ограничена 60 секундами. Это распределяет повторы во времени. Повреждённый исходник, неверная контрольная сумма и ошибка декодирования считаются постоянными и автоматически не повторяются.

Реестр failed — строки attachments WHERE status='failed'. История обработки и replay хранится в job_events; некорректные сообщения брокера отправляются в durable attachments.dlq. Публичный API выдаёт краткий код, например source_checksum_mismatch или retry_exhausted, без traceback и внутренних адресов.

Правила обработки и ограничения ресурсов

Результат Правило
Original Исходные байты без перекодирования; исходный SHA-256 сохраняется
Thumbnail JPEG, вписан в 256×256 без увеличения; пропорции сохранены, размеры округлены вниз, минимум 1 px
Crop JPEG, квадрат из центра, 128×128; маленький исходник разрешено увеличить
Optimized WebP, вписан в 1280×1280 без увеличения; размер файла не обязан уменьшиться для каждого маленького исходника

Для вариантов применяется EXIF orientation. В JPEG прозрачность накладывается на белый фон. JPEG сохраняется с quality=85, optimize=True; WebP — quality=80, method=4. EXIF и прочие метаданные из вариантов удаляются; исходник остаётся неизменным.

Декодирование worker выполняется дочерним процессом без импорта настроек/секретов приложения. Он получает Linux-ограничение адресного пространства RLIMIT_AS=768 MiB, ограничение CPU и максимум 30 секунд по часам. Родитель при превышении времени убивает и ожидает завершения дочернего процесса. На весь worker дополнительно действует лимит контейнера 1 GiB; общий job ограничен 90 секундами. Лимит 40 млн пикселей проверяется до полной распаковки: маленький сжатый файл тоже может требовать много памяти.

Ограничения проверены отдельно: декодирование настоящего изображения 16 млн пикселей при временном тестовом лимите 48 MiB останавливается по памяти; при тестовом дедлайне 0.001 секунды дочерний процесс убивается и ожидается его завершение. Проверка меняет параметры только внутри своего docker exec-процесса; штатные 768 MiB и 30 секунд остаются прежними. Это проверка механизма ограничения, а не замер максимальной производительности или гарантия обработки каждого изображения 40 млн пикселей.

Очистка и действия оператора

После COMMIT ready publisher удаляет staging-объект и ставит staging_deleted=true. До фиксации результата исходник не удаляется. Для failed исходник и возможные частичные результаты сохраняются семь суток (STAGING_RETENTION_SECONDS=604800), чтобы оператор мог устранить причину и явно повторить обработку. После срока уборка удаляет их; replay такого исходника отклоняется. Сбой очистки S3 не блокирует публикацию outbox.

Команды оператора выполняются внутри контейнера; отдельные HTTP-endpoint к обязательному контракту не добавлены:

docker compose exec --index 1 api python -m app.operator failed
docker compose exec --index 1 api python -m app.operator replay <attachment_id> --reason "Причина устранена"
docker compose exec --index 1 api python -m app.operator redeliver <attachment_id>

Replay разрешён для failed, сохраняет job_id, увеличивает номер попытки, сбрасывает бюджет автоматических повторов и пишет причину в аудит. Для готового результата replay возвращает NO-OP; redeliver отправляет дубль той же работы и позволяет проверить повторную доставку.

Аудит operator_replay сохраняет номер новой попытки. Базовая задержка RETRY_BASE_SECONDS должна быть конечным положительным числом; ноль, отрицательные значения, NaN и infinity отклоняются при запуске pipeline.

Сети, готовность и конфигурация

Внешние порты есть у LB; у API, PostgreSQL, Valkey, S3 и RabbitMQ они не публикуются. Данные и AMQP идут по внутренней сети backend. API дополнительно подключён к edge вместе с LB. Bucket приватен; сервис получает ограниченные S3-ключи, административные используются при bootstrap. Членство в чате проверяется в PostgreSQL при каждом скачивании; bucket сам его проверить не может.

Для небольшого контейнера RabbitMQ задано два Erlang scheduler (RABBITMQ_SERVER_ADDITIONAL_ERL_ARGS=+S 2:2), для его диагностических CLI — один (RABBITMQ_CTL_ERL_ARGS=+S 1:1). Это согласует число потоков с CPU-квотой брокера вместо числа ядер всего хоста.

Первые публичные persistence-прогоны выявили, что штатная остановка и запуск хранилищ на Docker Desktop могут исчерпать срок hook (лог до исправления). Итоговый scripts/restart.sh сначала останавливает LB, API, publisher и worker, затем аварийно завершает PostgreSQL, Valkey, S3 и RabbitMQ через SIGKILL. После этого запускаются те же контейнеры с прежними volumes; hook ждёт здорового состояния всех компонентов. Это явная проверка сохранности после аварии хранилищ; обычная команда docker compose stop остаётся отдельной штатной остановкой. Ограничения времени публичного теста и hook не увеличивались. Точная причина задержки внутри Docker не установлена; её наблюдение не доказывает потерю данных.

/health/ready API зависит от PostgreSQL и состояния graceful drain. Недоступность worker, брокера, Valkey или S3 не выключает обычные сообщения: кэш обходится, задания ждут восстановления, вложения при недоступности S3 получают 503. Это выбранная граница готовности синхронного пути.

Настройки Где применяются
SESSION_TTL_SECONDS, API_REPLICAS, IDEMPOTENCY_TTL_SECONDS, LB_PORT, LB_STATS_PORT, APP_VERSION Параметры Compose; TTL сессии по умолчанию 3600 секунд, API-реплик две
DATABASE_URL_FILE, CACHE_URL_FILE, S3_*_FILE, BROKER_URL_FILE Файлы Docker secrets; приложение читает значение по пути, секретов в репозитории нет
S3_ENDPOINT, S3_REGION, S3_BUCKET, APP_HOST/APP_PORT, SESSION_STORE, byte/pixel limits В этом стенде заданы явно в compose.yaml под именами, которые читает приложение
JOB_MAX_ATTEMPTS, JOB_TIMEOUT_SECONDS, JOB_TOTAL_TIMEOUT_SECONDS, JOB_LEASE_SECONDS, WORKER_MEMORY_MB, RETRY_BASE_SECONDS, STAGING_RETENTION_SECONDS Параметры pipeline из .env; значения и смысл описаны выше
WORKER_CONCURRENCY=1 Объявленный режим: код worker последовательный, prefetch=1; произвольное изменение строки не увеличивает параллелизм
UPLOAD_GRACE_SECONDS, JANITOR_INTERVAL_SECONDS Очистка intents: grace 900 секунд, проход примерно раз в минуту с jitter
PUBLISHER_FAULT, WORKER_FAULT, FAULT_INJECTION Только явные эксперименты; в обычном .env пусты

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

Прогоны 10.11.2026 на описанном стенде, внешний адрес http://localhost:8081. Базовый HEAD и состояние рабочего дерева описаны в run-context.txt: реализация ещё не закоммичена, поэтому один HEAD не определяет проверенные исходники. Публичные tests/ и contracts/ не изменялись. Smoke подтверждает обязательный сценарий API; для отказов и вариантов есть отдельные проверки. В таблице имена lab5_*.py означают файлы из student-tests/, запуск в tester, если не указано иначе.

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Контракт и структура skeleton сохранены python -X utf8 scripts/check_contract.py PASS: структура, локальные ссылки и синтаксис публичных Python-проверок check.txt
Схемы OpenAPI и jobs валидны .venv/Scripts/python -X utf8 scripts/validate_openapi.py PASS: полная валидация OpenAPI 3.1 и JSON Schema validate.txt
3: прежний API, upload 202, GET до ready python -X utf8 tests/smoke.py --base-url http://localhost:8081 PASS: также сообщение с queued-вложением, исходные байты и настоящий JPEG thumbnail 256×160 smoke.txt
3: сохранность при остановленном worker и рестарте API/broker lab5_recovery.py --mode persistence PASS: те же ID и сессия, content409 до worker, messages201, после старта ready; подтверждён реальный restart контейнеров recovery.txt
3: restart всех процессов и хранилищ с volumes Публичный tests/resilience.py --mode persistence с scripts/restart.sh (тот же тест, что make test-persistence) PASS: после аварийного перезапуска хранилищ сохранены сессия, подтверждённые сообщения и исходные байты файла; StartedAt всех сервисов изменился persistence.txt, container-events.txt
3: две API-реплики, отказ обслужившей реплики Публичный tests/resilience.py --mode failover с scripts/stop-one.sh (тот же тест, что make test-failover) PASS: подтверждён отказ нужной реплики, данные и сессия сохранены; после теста обе реплики healthy failover.txt, container-events.txt
3: состояния, ограниченный retry, безопасный error_code lab5_recovery.py --mode replay и --mode retry PASS: постоянная ошибка после одной попытки; S3 outage → пять попыток → retry_exhausted recovery.txt
3: повтор не размножает варианты lab5_recovery.py --mode replay PASS: ready до/после redeliver совпадает, вариантов три recovery.txt
4: crop, WebP, EXIF, alpha, отсутствие увеличения и округление lab5_images.py PASS: декодированы варианты, проверены реальные размеры, SHA-256 и исходные байты images.txt
4: bytes/pixels, невалидные изображения lab5_images.py PASS: >10 MiB и >40 млн пикселей → 413; повреждение/MIME mismatch → 415; опасные имена → 400 images.txt
4: ограничения времени и памяти worker Get-Content -Raw student-tests/lab5_limits.py | docker compose exec -T worker python PASS: реальное декодирование 16MP ограничено 48 MiB; timeout убивает и ожидает дочерний процесс limits.txt
4: разрыв COMMIT/publish закрыт outbox lab5_recovery.py --mode outbox PASS: одноразовый crash, прежнее вложение ready после восстановления, без нового задания вручную recovery.txt
4: backoff/jitter, реестр failed, явный replay с аудитом lab5_recovery.py --mode retry и --mode replay PASS: пять сохранённых попыток, failed виден оператору, replay сохраняет job_id и пишет operator_replay с номером новой попытки recovery.txt
4: crash после объектов, восстановление processing по lease lab5_recovery.py --mode objects PASS: processing и записанный S3-объект, естественное истечение lease, вторая попытка, прежний результат recovery.txt
4: crash после COMMIT до ack lab5_recovery.py --mode ack PASS: прежняя ready-задача, исходник и три варианта сохранены recovery.txt
4: concurrency/prefetch и безопасная очистка staging Последовательный worker, prefetch=1; --mode objects, --mode ack PASS: после ready staging_deleted=true, staging-объекта нет; конечные файлы доступны recovery.txt, app/worker.py, app/pipeline.py

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

Это функциональные проверки отказов для уровня 4. Нагрузочное исследование и выбор оптимальной concurrency на 5 не заявляются. RPS и p50/p95/p99 не измерялись: они не нужны, чтобы показать восстановление одной принятой задачи.

Методика: уникальные синтетические пользователи и чат; небольшой PNG 320×200; один worker, prefetch=1; указанные выше лимиты. В тесте изображений дополнительно используются 400×200, 11×7, 513×201, 1701×1003, прозрачный PNG и JPEG с EXIF orientation. Проверяются скачанные байты, а не только JSON. Проверка ограничений использует отдельный 16MP PNG и намеренно уменьшенные лимиты.

lab5_recovery.py имеет режимы persistence, outbox, objects, ack, replay, retry. Без --mode выполняет все. Тест управляет контейнерами своего Compose-проекта через Docker labels, не удаляет volumes и в finally возвращает остановленные сервисы. Токены существуют только в памяти клиента и не печатаются.

Fault injection включается явно через CLI и сохраняется в fault_injections. Каждая точка срабатывает один раз: перед аварийным os._exit(70) фиксируется счётчик hits. После автоматического перезапуска она не убивает процесс снова. Так подтверждается нужное окно отказа, а не обычный успешный путь.

# Включить один сбой для следующей подходящей задачи:
docker compose exec --index 1 api python -m app.operator fault crash_after_commit_before_publish
# Другие точки:
# crash_after_objects_before_commit
# crash_after_commit_before_ack
Воздействие Что ожидаем Что наблюдали Восстановление / потеря данных
Worker остановлен, upload, сообщение с вложением, restart API+broker Upload202, content409; после старта тот же ID ready PASS; обычные сообщения продолжают работать Прежние байты и сессия сохранены
Publisher погиб после COMMIT до publish Pending outbox остаётся; новый publisher отправит прежнюю работу PASS, fault hits=1 2.7 с от наблюдения сбоя до ready; принятое вложение не потеряно
Worker погиб после записи объектов до COMMIT S3 уже записано, processing; lease истечёт и запустит повтор PASS, естественный lease120, без ручного изменения БД 119.5 с от старта ожидания после crash; прежние байты, три варианта
Worker погиб после COMMIT ready до ack Повторная доставка безопасна для ready PASS, fault hits=1 0.3 с до наблюдения ready; второй набор не появился
Испорчен staging одной задачи Постоянная ошибка без retry, content/link409 PASS, failed после одной попытки, виден в реестре После возврата исходных байтов явный replay с аудитом, job_id прежний
S3 остановлено после приёма файла Временные повторы ограничены PASS, пять попыток и retry_exhausted После старта S3 явный replay завершил ту же работу; исходник сохранён
Лимит декодера уменьшен до 48 MiB / 0.001 с Превышение не оставляет работающий декодер PASS на реальном изображении 16MP Ошибка памяти и timeout обработаны, дочерний процесс завершён

Времена 2.7/119.5/0.3 секунды — результаты единичных функциональных прогонов на ноутбуке, а не статистическая оценка задержки. В ack-сценарии ready фиксируется до аварийного выхода; быстрое чтение ready не означает повторной обработки.

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

  • Один Docker host. PostgreSQL, SeaweedFS, RabbitMQ и LB в одном экземпляре. Перезапуск с volumes предусмотрен; потеря диска/host или удаление volume не компенсируются. Резервного копирования и репликации хранилищ нет.
  • Стенд предназначен для запуска из чистого clone и проверен на перезапусках данных lab5. Миграция старого lab4 не создаёт варианты для ранее загруженных ready-вложений: для них требуется новая загрузка; автоматическая обработка исторических файлов не реализована.
  • Доставка — at least once: сообщение может прийти несколько раз. Идемпотентная запись делает повтор безопасным, но не превращает доставку в exactly once. Несколько версий pipeline и исследование устаревших версий результата относятся к уровню 5; здесь только v1.
  • Один worker выполняет одну задачу. Большая очередь увеличит ожидание ready. Порог smoke 60 секунд относится к свободному локальному worker и небольшому изображению, а не к любой нагрузке.
  • Глобальный лимит длины очереди и исследование перегрузки не реализованы. Число загрузок ограничено на API-реплику, время и память обработки — на worker/дочерний процесс.
  • Failed-исходник доступен для replay семь суток. После очистки нужна новая загрузка: восстановить удалённые байты из метаданных невозможно. Успешные конечные объекты сохраняются; outbox и аудит не имеют автоматической архивной ротации.
  • Readiness API отражает работу сообщений и PostgreSQL. Отдельных HTTP health-endpoint у publisher/worker нет; их состояние видно по процессу, журналу, outbox, статусам и срокам lease.
  • tester получает Docker socket для явных учебных отказов. Его профиль запускается оператором; постоянной частью приложения он не является.
  • Проведённые функциональные проверки доказывают перечисленные сценарии на этом стенде. Они не заменяют длительную нагрузку, проверку потери носителя и резервного восстановления.