Files
mtusi2026lab2/REPORT.md
T

106 KiB
Raw Blame History

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

  • Автор, группа: Костылев Артём, БПИ2303
  • Целевая оценка: 5; трек «5» — трек 2 «Согласованность двух хранилищ (reconciler)»
  • Состояние на 2026-11-06: перенос SQLAlchemy/Alembic выполнен из immutable snapshot f591fa64e525679a31c9db7f942d36c789e1a12f, код переноса — 8e4532f6f5c05d902b6e2c310f54320d95585904. Текущие проверки уровня 3: новая матрица, полный SHA каждой команды в raw-выводе. Новые проверки уровня4: протокол и память. Штатные3слота: 840/840 успешных загрузок в18точках штатной конфигурации (36точек вместе с контролем), максимум API448MiB, OOM 0; clean-clone cf41f7c прошёл и сохранил volumes. Штатная уборка сняла все 30 pending, после неё 1669 строк/объектов без расхождений. Трек2:13 проверок корректности PASS и27 замеров до100k; методика и ограничения; итоговую редакцию отчёта подготовит этап после ревью. Таблицы и численные результаты ниже, ссылающиеся на evidence вне sqlalchemy-2026-11-06, относятся к исторической реализации asyncpg и не подтверждают текущий SQLAlchemy-код. Финально: check/validate/lint, 410 собственных тестов и smoke PASS; все свои стенды остановлены, volumes сохранены. Публикация в этой фазе не выполняется.
  • Поздний перенос финальной ЛР3: source ba78cf6da439a4ec60fd59389583b38285b0b2b1, диапазон от f591fa64e525679a31c9db7f942d36c789e1a12f, код ЛР4 75b93bbba5f29575d3fca1d013cc7e0770d88082. Полный перечень и применимость evidence. Результаты sqlalchemy-2026-11-06/ сняты до этих исправлений сессий/валидации/LB; текущие проверки находятся отдельно в evidence/forward-final-2026-11-06/. Сохранённая стоимость reconciler относится к неизменённому механизму, а не новому SHA всего API.
  • Использованные источники, библиотеки и помощь ИИ: FastAPI, gunicorn + uvicorn-worker, dishka, pydantic, structlog, SQLAlchemy 2 async, Alembic, asyncpg (драйвер), argon2-cffi, redis-py, aiobotocore/botocore, Pillow, pytest, ruff, ty (версии — evidence/environment.txt и uv.lock); RustFS 1.0 и rc (IAM-политики, anonymous access, lifecycle), Amazon S3 User Guide (PutObject, GetObject, ListObjectsV2, политики bucket), botocore Config (таймауты, повторы, checksum), Pillow (Image.open, verify, draft, защита от decompression bomb), спецификация PNG (чанки и CRC), HAProxy 3.2 Configuration Manual, документация Docker Compose (secrets, depends_on, профили). Решение перенесено из моей лабы 3; в текущем этапе использован Codex. Код, стенд и отказы проверены прогонами, перечисленными ниже.

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

Параметры текущего стенда: COMPOSE_PROJECT_NAME=hlpipe-lab4-<имя>, LB_HTTP_PORT=18084, LB_STATS_PORT=24844, NO_PROXY=localhost,127.0.0.1,::1. Скрипт scripts/clean-clone.sh создаёт отдельный clone внутри .verification/, останавливает только его project и сохраняет volumes. Старый протокол ниже описывает прежний прогон; команды удаления данных больше не выполняются.

Требуются Docker с Compose v2, make и системный Python 3.9+ (только для публичных проверок и сценариев). Образы сторонних сервисов закреплены версией и digest, API собирается из исходников.

git clone <repo> mtusi2026lab4 && cd mtusi2026lab4 && git checkout solution/bpi2303-kostylev

make secrets        # secrets/*: пароли PostgreSQL и Valkey, DATABASE_URL, CACHE_URL, ключ курсора,
                    # root-ключи S3 и отдельный ключ API S3; .env из .env.example (существующее не перезаписывает)
docker compose --env-file .env config --quiet
make up             # docker compose up -d --build --wait: postgres, valkey, s3 → migrate, s3-init → api ×2 → lb;
                    # затем ждёт обе реплики UP в статистике LB
make test           # публичный smoke через балансировщик (BASE_URL — порт lb из docker compose, иначе :8080)
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make restore        # вернуть остановленную реплику и дождаться её в ротации LB
make scenario SCENARIO=failover-upload   # upload → стоп принявшей реплики → download через другую, SHA-256
make scenario SCENARIO=s3-outage         # S3 остановлен: upload/download 503, тексты и метаданные работают
make s3-check       # приватность bucket вне API, права ключа API, консоль, повторный bootstrap
make reconcile      # трек 2: сверка PostgreSQL ↔ S3, по умолчанию dry-run; ARGS="--apply --deep" — исправить
make migrate        # повторный запуск миграций: up to date

make down           # безопасная остановка: контейнеры удаляются, volumes pgdata, valkeydata, s3data остаются

Каждая строка этого блока выполнена в свежем clone (evidence/clean-clone.txt; клон назван mtusi2026lab4-clean, чтобы у него были свои compose-проект и volumes): make up за 11 с (образ из кэша слоёв), все сервисы healthy, migrate применил 0001–0004, s3-init вывел bucket=messenger-attachments anonymous=private policy=messenger-api, smoke, persistence и failover PASS, повторный migrate — up to date, после make down три volume на месте, после make reset-data — ни одного. Отступление от инструкции одно: на машине параллельно работали стенды других лаб, поэтому в .env стояли LB_HTTP_PORT=18084, LB_STATS_PORT=24084 (цели make берут BASE_URL из docker compose port lb 8080). Наружу публикуются только порты lb на 127.0.0.1.

Длинные сценарии уровней «4» и трека запускаются на поднятом стенде так же, без ручных шагов:

make install        # .venv для pytest-сценариев (uv sync --group dev)
make upload-faults  # «4»: негативный suite через LB, компенсация, уборка после grace, обрыв и зависание тела
series="evidence/run-$(date -u +%Y%m%dT%H%M%SZ)"
make upload-memory ARGS="--out $series/memory/run1"
make reconcile-demo ARGS="--out $series/demo"
make reconcile-cost ARGS="--out $series/measurements"
EVIDENCE_DIR="$series" make load-evidence

Каждой серии нужен новый каталог: повтор в существующий отклоняется до нагрузки. Demo и cost выполняются последовательно на отдельных новых Compose projects; существующие данные не удаляются. Для трёх повторов памяти используются run1, run2, run3.

make up ждёт healthy всех долгоживущих сервисов и успешного завершения одноразовых migrate (миграции под advisory lock) и s3-init (bucket, анонимный доступ private, политика и пользователь API, lifecycle). Оба повторяемы: повторный make up, make migrate или restart.sh проходит без изменений состояния.

Собственные проверки и тулчейн:

make install        # uv sync --group dev (Python 3.14 и зависимости из uv.lock)
make lint           # ruff check + ruff format --check (src, student-tests, scripts/*.py стенда) + ty check
make student-test   # собственные тесты; поднимают одноразовые PostgreSQL, Valkey и RustFS того же образа в Docker
make check          # офлайн-проверка skeleton
make validate       # полная валидация OpenAPI: openapi-spec-validator 0.7.2 из .venv
make stack-evidence         # сервисы, порты, hostname ↔ X-Instance-Id, лимиты, сети, версии
make limits                 # лимиты CPU/RAM, порты, секреты, volumes и сети всех сервисов против политики
make storage-evidence       # \d+ схемы, повтор миграций, префикс KDF, правила ignore
make attachments-evidence   # где лежат байты: \d attachments, bucket, сверка вне API, read_only реплик
make failover-evidence      # docker inspect реплик до/после, make test-failover, логи остановленной, restore
make persistence-evidence   # persistence-тест + StartedAt всех контейнеров до и после
make lb-check               # один токен на обеих репликах; 20 гонок одного Idempotency-Key через LB
make retry-check            # потерянный ответ на живой и на убитой реплике, повтор тем же ключом
make faults-evidence        # все проверки стенда под маркером stack (лабы 2–3 и уровень «4»)

Версии и стенд: Python 3.14.7 в образе python:3.14-slim-trixie@sha256:51dafde8…, rustfs/rustfs:1.0.4@sha256:ed9210d6…, rustfs/rc:v0.1.36@sha256:ab024bfe…, haproxy:3.2.26-alpine@sha256:58938405…, postgres:17.11-alpine@sha256:266d3c25…, valkey/valkey:8.1.11-alpine@sha256:2602ace2…, uv 0.9.7 по digest; aiobotocore 3.10.0 (botocore 1.43.117), Pillow 13.0.0; Docker 28.3.2, Compose 2.38.2. Машина — Apple M4 Max, 16 CPU, 48 ГБ RAM, macOS 15.1; VM Docker Desktop — 16 CPU, 7.65 ГиБ (evidence/environment.txt).

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

                                      ┌── api (gunicorn, 2 × UvicornWorker) ─┐   SQLAlchemy async engine     ┌▶ postgres (метаданные, pgdata)
клиент ──HTTP──▶ lb (HAProxy 3.2) ────┤   X-Instance-Id = hostname           ├────────────────────┼▶ valkey (кэш сессий, AOF)
127.0.0.1:8080   round robin,         └── api (gunicorn, 2 × UvicornWorker) ─┘   aiobotocore      └▶ s3: RustFS (байты, s3data)
                 httpchk /health/ready      migrate (образ api, один раз) ──▶ postgres
                                            s3-init (rc, один раз) ──▶ s3: bucket private, пользователь и политика API
сеть edge ─────── lb ─────── сеть backend (internal): lb, api, migrate, postgres, valkey, s3, s3-init, s3-cli

Источник истины. PostgreSQL — для всего, что знает API о вложении: владелец, чат, отображаемое имя, тип по содержимому, размер, SHA-256, размеры в пикселях, ключ объекта, статус и связи с сообщениями. S3 (RustFS) — только для байтов оригинала под ключом attachments/<uuid7>, который назначает сервер. Реплика API не хранит файлов: корень только для чтения, tmpfs /tmp нужен лишь heartbeat gunicorn, volume у api нет (evidence/storage-layout.txt).

Перенесено из лабы 3 без изменения поведения: зоны identity и messaging, порты и адаптеры, UoW, шина событий с журналом аудита, ASGI-конвейер, Basic → Bearer, Argon2id, сессии в PostgreSQL с кэшем в Valkey, подписанный курсор, порядок истории под блокировкой строки чата, X-Instance-Id, обязательный Idempotency-Key в одной транзакции с сообщением, HAProxy с проверкой готовности и политикой повторов, окно вывода реплики из ротации по SIGTERM, хуки stop-one.sh, restore.sh, lb-wait.sh, проверки уровня «4» лабы 3 (на итоговом коде прогнаны make limits, lb-check, retry-check, test-faults). Перенос шёл двумя шагами: решение лабы 3 на 61c0c28 (bf8e4e3), затем её исправления после ревью (e927afd): отправка сообщения одной командой SQL под блокировкой строки чата (улучшение трека 1 лабы 3), 503 в формате контракта для запроса, прерванного остановкой, готовность за портом Readiness, счёт реально полученных байтов тела в конвейере. Изменено: новая зона attachments; attachment_ids в сообщениях — ссылки пишутся той же командой SQL, что и сообщение; миграции 0003 и 0004; лимит тела в конвейере зависит от маршрута; S3-сервисы и reconciler в compose.yaml; restart.sh перезапускает и S3; политика scripts/limits.py знает S3-сервисы.

Зона attachments и её связь с messaging. Зона владеет агрегатом Attachment (pending → ready), значением Filename, своими ошибками, событием AttachmentStored, командой UploadAttachment, запросами GetAttachment/OpenAttachment, портами ObjectStorage, ImageInspector, ChatMembership и HTTP-слоем. Ей нужен один ответ от messaging — «входит ли пользователь в чат»; его даёт адаптер MessagingMembership над ChatDirectory, который собирает main.py. Зоны не импортируют друг друга, SQL каждой зоны читает только свои таблицы (оба правила проверяет тест test_bounded_contexts.py). Целостность между зонами держат внешние ключи: attachments (chat_id, owner_id) → chat_members и message_attachments (attachment_id, chat_id) → attachments (id, chat_id) ON DELETE RESTRICT — сообщение может сослаться только на вложение своего чата, нарушение превращается в 404 и откатывает всю отправку вместе с ключом идемпотентности, а используемое вложение нельзя удалить.

Схема (alembic/versions/0003_attachments.py, evidence/schema.txt): attachments без bytea, CHECK на тип, размер 1..10485760, формат SHA-256, статус; object_key text COLLATE "C" UNIQUE (байтовый порядок, как у листинга S3); частичный индекс (created_at) WHERE status = 'pending'; message_attachments с PK (message_id, position), UNIQUE (message_id, attachment_id) и индексом по attachment_id. messages_text_check ослаблен до ≤ 4000: пустой текст с вложением легален, пустой без вложений по-прежнему отсекает домен (400). История и повтор читают attachment_ids подзапросом по PK message_attachments, без N+1 запросов. Отсутствующий attachment_ids и [] дают один отпечаток тела для Idempotency-Key, другой порядок — 409. Миграция 0004 (трек 2) аддитивно добавляет quarantine_reason (missing, size_mismatch, sha_mismatch) и quarantined_at, обе NULL или обе заданы.

Upload: где применяется каждый лимит. Тело читается потоком, FastAPI его не разбирает.

  1. 401 — guard конвейера: он читает только заголовок Authorization и сессию, тело не трогает;
  2. объявленный Content-Length > лимита маршрута → 413 в конвейере, тело не читается (лимит 10 MiB только у маршрута upload, у JSON остаётся 1 MiB); конвейер считает и реально полученные байты тела против того же лимита;
  3. членство в чате → 404 (раньше любых проверок содержимого);
  4. filename после percent-decode: 1–255 code points, не пробельный, без /, \ и символов категории Cc (NUL, \x01, \x7f, перевод строки…) → иначе 400; используется только для отображения;
  5. Content-Type без параметров и регистра ∈ {image/png, image/jpeg} → иначе 415;
  6. слот загрузки: не больше UPLOAD_CONCURRENCY=3 тел в памяти воркера, остальные ждут, не читая тело (uvicorn приостанавливает чтение сокета после 64 KiB), ожидание ограничено таймаутом запроса;
  7. поток копится со счётчиком и инкрементальным SHA-256; байт MAX_UPLOAD_BYTES + 1 → 413, дальше не читаем (так закрыт и chunked без Content-Length); обрыв клиента посреди тела → 400 в журнале, не 500;
  8. проверка изображения в потоке под семафором (IMAGE_CHECK_CONCURRENCY=2 на воркер): Image.open только PNG/JPEG читает заголовок; формат ≠ заявленному → 415 (подмена MIME); width × height > MAX_IMAGE_PIXELS → 413 до декодирования (decompression bomb 100 000 × 100 000 весом 300 байт отклоняется по заголовку); PNG — verify() (все чанки, CRC, IEND, без распаковки пикселей), JPEG — draft в 1/8 + load() (полное декодирование потока, ≈1/64 памяти); ошибка → 415;
  9. запись (ниже); буфер тела освобождается до перевода в ready.

Порядок записи PostgreSQL ↔ S3. INSERT attachments (status='pending') и COMMIT → PutObject → UPDATE … SET status='ready' и COMMIT → 201. Намерение фиксируется до PUT, поэтому у любого объекта под attachments/ есть строка с тем же ключом; pending не видно ни в метаданных, ни в скачивании, а сослаться на него нельзя — id отдаётся только в 201.

Сбой Что остаётся Ответ клиенту
обрыв клиента, 413, 415, 400, 404 ничего: строка пишется только после чтения и проверки ошибка или обрыв
INSERT pending ничего 503
PutObject (S3 недоступен, таймаут) невидимая строка pending, объект возможен (отложенная запись) 503; уборка после grace
UPDATE ready отклонён компенсация сразу: объект и строка удалены 503
процесс убит между PUT и COMMIT невидимая строка pending и объект обрыв (502 от LB); уборка после grace
после COMMIT ready готовое вложение 201

Компенсация и уборка (уровень «4»). Инвариант: пока объект под attachments/ существует, существует и строка с его ключом; строка-намерение удаляется только после объекта.

  • Компенсация. Если UPDATE … SET status='ready' не зафиксирован, обработчик в новой транзакции берёт строку SELECT … FOR UPDATE: ready (фиксация на самом деле прошла) — не трогает; pending — DeleteObject, затем DELETE … AND status='pending', COMMIT; строки нет — удаляет объект. Блокировка держится на время одного DeleteObject (≤ 6 с < idle_in_transaction_session_timeout 10 с) и не даёт задержавшемуся UPDATE ready проскочить между удалением объекта и строки. UPDATE ready, не нашедший строки (намерение уже убрано), даёт 503 и удаление объекта, а не 201. Сбой самого PUT и отмена по таймауту сразу не компенсируются: исход PUT неизвестен, объект может появиться позже.
  • Уборка. В каждом воркере UploadSweeper раз в UPLOAD_SWEEP_INTERVAL_SECONDS=30 выбирает по одной строке WHERE status='pending' AND created_at < now − UPLOAD_GRACE_SECONDS ORDER BY created_at LIMIT 1 FOR UPDATE SKIP LOCKED (частичный индекс attachments_pending_idx), удаляет объект, затем строку, до UPLOAD_SWEEP_BATCH=100 за проход; SKIP LOCKED делит работу между 4 воркерами стенда, ошибка S3 откладывает строку до следующего прохода. Каждое удаление — событие audit.attachment_discarded с причиной compensation или abandoned.
  • Grace period UPLOAD_GRACE_SECONDS=900 (минимум 60 в настройках): жизнь загрузки от INSERT pending до UPDATE ready ограничена таймаутом запроса 8 с, отложенный PUT — таймаутами S3 6 с; запас больше 50 раз, включая расхождение часов реплик одного хоста. Готовые строки и вложения в сообщениях не выбираются условием status='pending', а message_attachments ссылается на них с ON DELETE RESTRICT.
  • Незавершённый multipart (сервер им не пользуется) удаляет lifecycle-правило bucket через сутки.

Сверка хранилищ (трек 2). Одноразовый сервис reconciler (образ API, профиль reconcile, ключ API S3) сливает отсортированный листинг bucket и keyset-страницы attachments по object_key и находит то, что уборка уровня «4» не видит: объект без строки, готовую строку без объекта или с другими байтами. По умолчанию только отчёт; --apply удаляет старые объекты без строки и брошенные намерения, а готовые строки с расхождением не удаляет, а помещает в карантин (миграция 0004), /content такого вложения отвечает 404. Подробно — раздел трека ниже.

Платформа: откат транзакции раньше стирал все события команды, а шина не публиковала их при исключении — журнал терял удаления из компенсации и уборки. Теперь откат убирает только события своей транзакции.

Скачивание. Строка ready по PK → членство → GetObject до отправки заголовков (пропавший объект → 404 с событием attachment.object_missing в журнале, недоступный S3 → 503) → StreamingResponse кусками 64 KiB с Content-Type из метаданных, Content-Length из S3, X-Content-Type-Options: nosniff, Cache-Control: private, no-store; Accept не учитывается, redirect нет, X-Request-Id/X-Instance-Id ставит конвейер. variant — только original, иное → 400.

Клиент S3. Один клиент aiobotocore на воркер (scope APP dishka): path-style, SigV4, регион S3_REGION, connect_timeout=1, read_timeout=2, 2 попытки, checksum when_required. Обработчик botocore, добавлявший Expect: 100-continue к телу PutObject, снят: aiohttp ждал 100 Continue, RustFS за прокси портов его не присылал, и запись висела до read timeout — это нашёл тест адаптера против настоящего RustFS. Ошибки соединения, таймауты и 5xx → 503 unavailable; ключи S3 в журнал и ответы не попадают.

Готовность. /health/ready от S3 не зависит. Если бы зависела, при падении S3 балансировщик вывел бы все реплики, отказали бы и тексты, а ответы LB не несут X-Instance-Id. Сейчас upload и скачивание получают 503 от приложения: в новой серии upload 0,828–5,039 с, download 0,510–1,397 с (граница проверки 6 с). Тексты и метаданные работают (evidence/sqlalchemy-2026-11-06/grade3/s3-outage-{1,2,3}.json).

Память загрузок (уровень «4»). Пик памяти держат три настройки по всей цепочке, найденные замером (ниже): слоты загрузки на воркер; буферы сокетов — HAProxy tune.rcvbuf/sndbuf.client/server 65536, у api net.ipv4.tcp_rmem/tcp_wmem с максимумом 256 KiB (иначе ядро растит буфер до 6 MiB на соединение, и ожидающие тела копятся в памяти контейнера LB); MALLOC_MMAP_THRESHOLD_=131072 у api (иначе glibc после первого освобождения поднимает порог mmap до 32 MiB и держит освобождённые тела в куче). Буферы сокетов нашёл первый прогон замера, ещё без них: при 3 слотах и 40 загрузках по 10 MiB память сокетов HAProxy выросла до ≈ 110 MB, и LB с лимитом 128 MiB убил OOM (описано в коммите a774a2f; сырых данных того прогона в evidence/ нет). Влияние порога mmap измерено отдельно (evidence/upload-memory/mmap-32m/).

Цепочка таймаутов: клиент smoke/resilience 10/2 с; LB timeout server 10 с > REQUEST_TIMEOUT_SECONDS 8 с > худшая операция S3 2 × (1 + 2) = 6 с и ожидание соединения PostgreSQL + оператор 1 + 2 с. LB не повторяет upload: disable-l7-retry снят только для GET и POST …/messages с ключом, повтор отказа соединения безопасен (запрос не ушёл). Дедлайн запроса в конвейере продлевается переданными байтами тела запроса и ответа: min(now, start + moved / MIN_TRANSFER_RATE_BYTES) + 8 с, по умолчанию 128 KiB/s (схема mod_reqtimeout с потолком). Медленная, но идущая передача не обрывается: upload 10 MiB может идти до 80 + 8 с. Зависшее или ползущее медленнее порога тело обрывается через 8 с плюс кредит уже переданных байтов (1 KiB даёт 8 мс). После последнего байта тела на обработку остаётся не больше 8 с. timeout server/timeout client HAProxy — таймауты простоя одной стороны, поэтому длинная идущая передача через LB не обрывается. Это проверено тестом стенда: 3 MiB вверх и вниз дольше 8 с.

Роли и сервисы (compose.yaml; сети edge и backend с internal: true):

Роль Сервис Версия / digest Health / readiness Volume Сеть / порт Credentials
load_balancer lb haproxy:3.2.26-alpine@sha256:58938405…, uid 99, read_only, буферы сокетов 64 KiB /healthz :8404; реплики — GET /health/ready нет edge + backend; 127.0.0.1:${LB_HTTP_PORT:-8080}, 127.0.0.1:${LB_STATS_PORT:-8404} нет
api ×API_REPLICAS api сборка из Dockerfile, uid 10001, read_only + tmpfs /tmp, tcp_rmem/tcp_wmem ≤ 256 KiB GET /health/ready (PostgreSQL) нет backend, без портов database_url, cache_url, cursor_secret, s3_access_key_id, s3_secret_access_key через *_FILE
postgres (метаданные) postgres postgres:17.11-alpine@sha256:266d3c25…, uid 70 pg_isready pgdata backend postgres_password через POSTGRES_PASSWORD_FILE
s3 s3 rustfs/rustfs:1.0.4@sha256:ed9210d6…, uid 10001, read_only, cap_drop: ALL, консоль выключена curl /health/ready s3data:/data backend, :9000 без публикации root: s3_root_user, s3_root_password через RUSTFS_*_FILE
bootstrap S3 s3-init rustfs/rc:v0.1.36@sha256:ab024bfe…, uid 65534, read_only код выхода 0 нет (infra/s3 только для чтения) backend root-ключи, ключи API и сверки (создаёт пользователей)
операторский CLI (профиль tools) s3-cli тот же rc, uid 65534 нет нет backend aliases root, api, reconciler, anon
сессии (кэш) valkey valkey/valkey:8.1.11-alpine@sha256:2602ace2…, uid 999 valkey-cli ping valkeydata (AOF) backend valkey.conf
bootstrap схемы migrate образ api, uid 10001, init: true, restart: "no" код выхода 0 нет backend database_url
сверка PostgreSQL ↔ S3 (профиль reconcile) reconciler образ api, uid 10001, init: true, read_only, entrypoint — модуль сверки код выхода 0 / 1 нет backend database_url, s3_reconciler_access_key_id, s3_reconciler_secret_access_key через S3_*_FILE (свой ключ, не root и не ключ API)
нагрузка (профиль bench) k6 grafana/k6:2.3.0@sha256:2dd4756e… нет нет edge нет

Приватный bucket создаёт infra/s3/init.sh: rc bucket create --ignore-existing, rc bucket anonymous set private, политика messenger-api из infra/s3/api-policy.json (только GetObject, PutObject, DeleteObject на messenger-attachments/*) и пользователь API, политика messenger-reconciler из infra/s3/reconciler-policy.json (ListBucket на bucket, GetObject, DeleteObject на объекты) и пользователь сверки — оба с ключами из secrets/. Дальше идёт lifecycle «незавершённый multipart старше суток удаляется» (он работает на стороне сервера, ключам multipart-действия не нужны), самопроверка анонимной политики и привязки обеих политик. Реплики API листинга bucket не делают и права на него не имеют, листинг есть только у ключа сверки. Root-ключи есть только у s3, s3-init и s3-cli (evidence/storage-layout.txt, evidence/limits.txt). MinIO не выбран: minio/minio удалён с Docker Hub, quay отдаёт 401, проект архивирован; SeaweedFS работает от root и не читает ключи из файлов. Лимиты: lb 1/128m, api 1/512m на реплику, s3 1/512m, s3-init и s3-cli 0.5/64m, migrate 0.5/256m, reconciler 1/256m, postgres 2/1g, valkey 0.5/128m.

Соответствие .env.example реальной конфигурации:

.env.example В решении Комментарий
APP_HOST, APP_PORT HOST, PORT заданы в образе (0.0.0.0:8080); снаружи — порт LB
APP_ENV не используется режимов окружения нет
SESSION_TTL_SECONDS, IDEMPOTENCY_TTL_SECONDS те же 3600 и 86 400
DATABASE_URL_FILE, CACHE_URL_FILE те же любой параметр читается из <ИМЯ>_FILE
SESSION_STORE=postgres фиксировано PostgreSQL — источник истины сессий, Valkey — кэш
API_REPLICAS deploy.replicas: ${API_REPLICAS:-2} число реплик api
S3_ENDPOINT, S3_REGION, S3_BUCKET те же у api, s3-init, s3-cli; RUSTFS_REGION у s3 http://s3:9000, us-east-1, messenger-attachments
S3_ACCESS_KEY_ID_FILE, S3_SECRET_ACCESS_KEY_FILE те же ключ API, не root
MAX_UPLOAD_BYTES, MAX_IMAGE_PIXELS те же 10 485 760 и 40 000 000; больше контракта задать нельзя (валидация настроек)
— S3_CONNECT_TIMEOUT_SECONDS, S3_READ_TIMEOUT_SECONDS 1 и 2 с; две попытки укладываются в 8 с запроса
— IMAGE_CHECK_CONCURRENCY, S3_MEMORY параллельные проверки изображений на воркер; лимит памяти RustFS
— UPLOAD_CONCURRENCY, UPLOAD_GRACE_SECONDS, UPLOAD_SWEEP_INTERVAL_SECONDS, UPLOAD_SWEEP_BATCH 3 тела на воркер; 900 с; 30 с; 100 строк за проход (уровень «4»)
— MALLOC_MMAP_THRESHOLD_ 131 072: тела больше 128 KiB возвращаются системе при освобождении (уровень «4»)
— MIN_TRANSFER_RATE_BYTES 131 072 B/s: каждый переданный байт тела продлевает дедлайн запроса на 1/скорость
— RECONCILE_CPUS, RECONCILE_MEMORY, RECONCILE_S3_READ_TIMEOUT_SECONDS 1, 256m, 10 с: лимиты сервиса сверки и таймаут чтения страницы листинга (трек 2)
— S3_CPUS, S3_CPUSET, PG_CPUSET, RECONCILE_CPUSET 1 CPU у RustFS; пусто — без закрепления; make reconcile-cost задаёт 2 CPU / 3 GiB RustFS и отдельные ядра на время замеров (трек 2)
— LB_HTTP_PORT, LB_STATS_PORT, API_CPUS, API_MEMORY, WEB_CONCURRENCY, DB_POOL_MAX_SIZE, API_SERVER_MAXCONN, DRAIN_SECONDS, PG_*, K6_*, CURSOR_SECRET_FILE как в лабе 3

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

Таблица ниже — историческая серия asyncpg. Актуальные результаты: evidence/sqlalchemy-2026-11-06/grade3/NOTES.md и grade4/NOTES.md; результаты трека добавляются после его отдельного цикла. Файлы старых серий сохранены.

Уровни «3» и «4» сняты одной серией на стенде из чистого состояния (make reset-data, make up) на 81dd816; порядок серии — в evidence/README.md. Трек 2 — на 5c3c238 и b191623, проверка уровней после трека — на 8cb5a66.

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab4 public API scenario (upload fixture → 201 ready, сообщение text="" с attachment_ids, скачивание bob побайтно с image/png, eve 404 на метаданные и /content, весь минимум lab2–lab3) evidence/smoke.txt
Запуск из чистого clone блок «Запуск из чистого clone» дословно в каталоге mtusi2026lab4-clean valid; make up за 11 с: все сервисы healthy, migrate (0001–0004) и s3-init Exited (0), обе реплики UP в LB; smoke, persistence и failover (первая запись через 2,95 с, 128 записей, 0 ошибок) — PASS; failover-upload и s3-outage — ok; 23 проверки S3 — PASS; сверка: 5 объектов, 6 строк, расхождений нет, одно свежее намерение от s3-outage; повтор migrate — up to date; после make down 3 volume, после make reset-data — 0 evidence/clean-clone.txt
make check / make validate make check; make validate (.venv с openapi-spec-validator 0.7.2) PASS: offline skeleton structure…; PASS: full OpenAPI 3.1 and JSON Schema validation; git diff upstream/main контракта, публичных тестов и задания пуст evidence/contract-checks.txt
Собственные тесты и линтер make lint; make student-test PYTEST_ARGS=-v ruff, формат, ty — All checks passed!; 342 passed по именам (17 проверок стенда под маркером stack — отдельно, faults.txt) evidence/student-tests.txt
3.1 S3 в общем стенде; метаданные в PostgreSQL, байты в приватном bucket, не в БД и не на API make attachments-evidence (ps, \d attachments, bytea по схеме, листинг bucket, docker inspect); make limits s3 healthy без портов; bytea во всей схеме — только sessions.token_hash и idempotency_keys.fingerprint, строка attachments ≤ 264 B; 16 строк ready (и одна невидимая pending от s3-outage) и 16 объектов attachments/<uuid>; у реплик ro=true, только tmpfs /tmp и bind секретов; данные S3 — volume:mtusi2026lab4_s3data:/data; root-ключи S3 только у s3, s3-init, s3-cli evidence/storage-layout.txt, evidence/limits.txt
3.2 201 ready только после записи объекта и COMMIT; побайтное скачивание вторым участником, SHA-256 smoke; make student-test (test_storage_failure_leaves_nothing_visible, test_member_uploads_and_another_member_downloads); сверка вне API S3 отказал при записи → 503, строка pending, вложения не видно; sha256 и размер последней строки ready в PostgreSQL равны sha256 и размеру объекта, прочитанного rc из bucket (99ea7533…, 111 817) evidence/smoke.txt, evidence/student-tests.txt, evidence/storage-layout.txt
3.3 Message с attachment_ids читается участниками; посторонний 404; анонимный GET в S3 — 403 smoke; make student-test (test_message_attachments.py, test_attachments.py); make s3-check eve 404 на метаданные и /content; вложение другого чата и неизвестное → 404, 11 и дубли → 400, посторонний с 11 → 404; одно вложение в нескольких сообщениях, порядок сохраняется; прямой HTTP GET объекта из отдельного контейнера → 403, анонимные Head/List/Put → deny, политика private evidence/smoke.txt, evidence/student-tests.txt, evidence/s3-security.txt
3.4 PNG/JPEG ≤10 MiB и ≤40 MP; MIME по содержимому; опасные filename; лимиты до неограниченного чтения/декодирования make student-test (test_attachments.py, test_attachments_domain.py); make upload-faults ровно 10 485 760 B → 201, +1 B с Content-Length и chunked → 413 без строки; 8000×5000 → 201, 8001×5000 и 100 000×100 000 → 413 по заголовку; JPEG/GIF/WebP/текст как PNG, PNG как JPEG, обрезанные PNG/JPEG, пустое тело, application/octet-stream, без Content-Type → 415; ../a.png, a/b.png, a\b.png, %00, %01, %7F, пустое, пробельное, 256 символов, без параметра → 400; кириллица и 255 символов → 201; те же случаи через LB — в 4.1 evidence/student-tests.txt, evidence/upload-faults.txt
3.5 Upload → остановка обслужившей реплики → download через другую make scenario SCENARIO=failover-upload upload принят 899a952a5a21, хук остановил её за 2,72 с, скачивание через 0cc3ee358e59 через 2,73 с от старта хука, SHA-256 равен, реплика возвращена evidence/failover-upload.json
3.5 Остановка каждой реплики под записью (публичный хук) make failover-evidence, затем make failover-evidence SHIFT=1 899a952a5a21: первая запись через 2,89 с, 129 записей, 0 ошибок; 0cc3ee358e59: 2,88 с, 128, 0; target в exited, сосед running; в журнале target — сигнал, service.draining (2 с), readiness 503, выход; вложение после отказа читается bob; PASS: failover …; после restore обе running evidence/failover-899a952a5a21.txt, evidence/failover-0cc3ee358e59.txt
3.6 Restart с сохранением volumes сохраняет метаданные и оригинал make persistence-evidence PASS: persistence … (после хука один GET метаданных и один /content без повторов совпали); StartedAt у lb, обеих api, postgres, valkey, s3, migrate, s3-init новее, ID контейнеров те же evidence/persistence.txt
3.7 Недоступность S3: ограниченная ошибка, тексты работают, политика readiness make scenario SCENARIO=s3-outage при остановленном s3: upload 503 за 2,23 с, /content 503 за 1,99 с, метаданные 200, текст 201, /health/ready 200; S3 снова healthy за 5,8 с, файл скачивается с тем же SHA-256 evidence/s3-outage.json
3.8 Закреплённая версия образа S3 и создание приватного bucket compose.yaml, infra/s3/init.sh; make up; make s3-check все образы по digest; s3-init пишет bucket=messenger-attachments anonymous=private policy=messenger-api lifecycle=abort-incomplete-uploads; 23/23 проверки PASS, включая двойной повторный bootstrap без изменений evidence/environment.txt, evidence/clean-clone.txt, evidence/s3-security.txt
3.9 Перенос lab3: ≥2 реплики, одна точка входа, порты только у LB, схема и миграции, KDF, общая идемпотентность, секреты вне Git make stack-evidence, make limits, make storage-evidence, make lb-check, make retry-check 2 api без портов, container_name 0, LB видит api1/api2 UP L7OK 200, X-Instance-Id чередуется; политика лимитов, портов, секретов и сетей — PASS; миграции 0001–0004, повтор up to date без изменения счётчиков (66 пользователей, 288 сообщений, 17 вложений); Argon2id у всех 66, хеши токенов по 32 B; один токен на обеих репликах — 20 + 20; 20 раундов × 8 параллельных POST одним ключом — 160 × 201, по одной копии; потерянный ответ на живой и на убитой реплике — повтор 201 с тем же сообщением, одна копия; git ls-files secrets .env пуст evidence/stack.txt, evidence/limits.txt, evidence/schema.txt, evidence/migrations.txt, evidence/kdf.txt, evidence/secrets.txt, evidence/lb-check.json, evidence/retry.json
4.1 Тесты: слишком большой файл, повреждённое изображение, подмена MIME, чужое attachment_id, вложение другого чата; пользовательская ошибка не даёт 500 make student-test (test_attachments.py, test_message_attachments.py, test_upload_consistency.py); make upload-faults (test_user_errors_never_become_500 через LB против PostgreSQL и RustFS) 342 passed; на стенде 36 ошибочных запросов: 16 × 400 (опасные и пустые filename, 11 и повторяющиеся attachment_ids, невалидный UUID, пустой текст без вложений, variant=thumbnail), 6 × 404 (upload, метаданные, /content и ссылка постороннего, вложение другого чата, неизвестное вложение), 4 × 413 (10 MiB + 1 с Content-Length — ответ до первого байта тела, chunked, бомба 100 000 × 100 000, 8001 × 5000), 10 × 415 (обрезанные PNG и JPEG, JPEG/GIF/WebP/текст как PNG, PNG как JPEG, пустое тело, чужой и отсутствующий Content-Type); тело ошибки по схеме, request_id равен заголовку; в журнале реплик за исторический прогон 53 ответа, из них 5xx — 0; строк вложений в чате ровно 2 — по числу 201; обрыв клиента посреди тела — 400, не 500 evidence/student-tests.txt, evidence/upload-faults.txt
4.2 Прерывание загрузки и отказ между записью S3 и БД не оставляют вечных неучтённых объектов: компенсация и уборка с grace period make upload-faults (триггеры PostgreSQL на время теста, docker kill -s KILL реплики); make student-test (test_upload_consistency.py) отказ COMMIT после PUT → 503, сразу нет ни строки, ни объекта (HEAD 404), в журнале audit.attachment_discarded reason=compensation; реплика убита между PUT и COMMIT (обе по очереди, клиент получил 502 от LB) → остались pending и объект (HEAD 200); намерение, сдвинутое за grace, уборка удалила вместе с объектом через 24,7 с, свежее осталось (pending, HEAD 200) и ушло через 1,0 с после сдвига; готовое вложение в сообщении со сдвинутым created_at скачивается с тем же SHA-256; обрыв после 256 KiB из 5 MiB → 400 в журнале, намерение не создавалось; зависшее тело → 503 за 8,01 с, ничего не записано. API-тесты: снятое во время PUT намерение → 503 и удалённый объект, сбой PUT оставляет pending до конца grace, два параллельных прохода делят 5 намерений ровно, следующий проход удаляет 0 evidence/upload-faults.txt, evidence/student-tests.txt
4.3 Лимиты, таймауты и потоковая обработка не дают одной загрузке занять неограниченную RAM; ≥10 одновременных загрузок с пиком памяти make upload-memory трижды (scripts/upload_memory.py --out evidence/upload-memory/runN): слоты 64 и 3 × 1 и 10 MiB × 10, 20, 40 одновременных, по 2 загрузки на клиента, реплики и LB пересоздаются перед каждой точкой; отдельно порог mmap 32 MiB при 3 слотах медиана пика реплики 297 / 321 / 334 MiB для 10 / 20 / 40 одновременных загрузок по 10 MiB, максимум трёх прогонов 345 MiB (простой 112–122, лимит 512), oom_kill 0, пик LB ≤ 31 MiB; без лимита слотов те же загрузки — 288 / 428 / 512 MiB, при 40 упор в лимит cgroup во всех трёх прогонах и 27 и 34 × 503 в двух из них; при 3 слотах и 40 клиентах p95 4,6–7,6 с, в одном прогоне 7 из 80 не уложились в таймаут 8 с (503); 1 MiB при любой настройке — 173–213 MiB; порог mmap 32 MiB — +12…35 MiB; таймауты: зависшее тело — 503 за 8,01 с (4.2), S3 — 2 × (1 + 2) с, LB timeout server 10 с evidence/upload-memory/run{1,2,3}/summary.txt и JSON точек, evidence/upload-memory/mmap-32m/
4.4 Идемпотентный bootstrap; отдельные ключи API с ограниченными правами; консоль не открыта; приватность bucket вне API make s3-check 23/23 PASS: у s3 нет host-портов, консоль :9001 не отвечает ни внутри контейнера, ни из отдельного контейнера сети стенда (connection refused); s3-init ещё дважды — код 0, снимок IAM и bucket не изменился; ключ API: Put/Head/Get/List/Delete объектов — разрешены, CreateBucket, DeleteBucket, публичная политика, импорт lifecycle, admin user list, запись и листинг чужого bucket — deny; анонимные Head/List/Put — deny, прямой HTTP GET объекта из отдельного контейнера — 403, анонимная политика private evidence/s3-security.txt
Проверки стенда лаб 2–3 и «4» на итоговом коде make faults-evidence (pytest -m stack) 17 passed: гонка регистрации, откат чата с неизвестным участником, одинаковый Basic-вызов, logout, Valkey остановлен (токен 200, выход 503), рестарт и FLUSHALL Valkey, PostgreSQL остановлен (503 за ≤ 0,015 с и восстановление), рестарт API и всего стенда, срок сессии после рестарта, 5 сценариев вложений evidence/faults.txt
5 (трек 2) Повторяемый reconciler: обнаружение каждого класса в dry-run make reconcile-demo (внедрение scripts/reconcile-inject.sh на обеих сторонах, --dry-run --deep) найдено ровно внедрённое: orphan_stale 3, missing 3, size_mismatch 3, sha_mismatch 3, pending_stale 6, свежих 2 + 2; объекты (24), строки (27) и классы независимой проверки до и после dry-run те же evidence/reconcile/dry-run.json, check-before.json, demo.json
5 Безопасное исправление, повторный запуск --apply --deep дважды 18 исправлений = найденному (3 удалённых объекта без строки, 9 строк в карантине, 6 намерений), ошибок 0; повтор — 0 действий evidence/reconcile/apply-1.json, apply-2.json
5 Свежие и используемые вложения не удаляются, в том числе под нагрузкой независимая проверка scripts/reconcile_check.py --deep --expect-ready (вне API); 75 проходов --apply за 75 с загрузок через LB после apply: lost_ready 0, свежие на месте, 6 ссылок сообщений и 9 строк в карантине сохранены, метаданные 200, /content 404; под нагрузкой: 3 418 × 201, исправлены только 10 остатков внедрения, объект идущей загрузки 247 раз выглядел объектом без строки и не тронут, все SHA-256 совпали, lost_ready 0 evidence/reconcile/check-after.json, under-load.json, check-under-load.json
5 Карантин обратим, один проход за раз, отказ S3 make reconcile-demo возвращённый объект → healed 1, /content 200; при занятой блокировке — skipped, код 0; при остановленном s3 — код 1 за 1,63 с, reconcile.failed, состояние то же evidence/reconcile/healed.json, lock-busy.json, s3-down.json
5 Стоимость обхода make reconcile-cost (1k / 10k / 30k × 3 прогона, закреплённые CPU, отбраковка чужой нагрузки) без --deep 0,105 / 1,000 / 3,729 с, листингов ⌈N/1000⌉, HEAD/GET 0, RSS 82,5–83,8 MiB; --deep 0,49 / 5,04 / 16,15 с; отбраковано 0 из 21 evidence/reconcile/cost/summary.txt, cost/*.json, cost/host-docker-stats.txt
5 Тесты сверки make student-test (test_reconciler.py, test_s3_storage.py) каждый класс в dry-run без изменений, apply и повтор = 0, восстановленный объект выходит из карантина, строка после листинга сохраняет объект, второй проход пропущен, отказ хранилища посреди прохода → Unavailable; листинг RustFS страницами в байтовом порядке evidence/student-tests.txt
Уровни «3» и «4» после трека 2 стенд из чистого состояния: make test, test-persistence, test-failover, restore, make reconcile, lint, check, validate, student-test все PASS, failover — первая запись через 2,70 с, 128 записей, 0 ошибок; dry-run после этих сценариев: 3 объекта и 3 строки, расхождений 0 evidence/reconcile/after-checks.txt

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

Стенд: 2 реплики api (1 CPU, 512 MiB, 2 воркера), RustFS 1 CPU / 512 MiB, PostgreSQL 2 CPU / 1 GiB, HAProxy 1 CPU / 128 MiB, Valkey 0,5 CPU / 128 MiB (evidence/limits.txt); Docker Desktop VM 16 CPU, 7,65 ГиБ на Apple M4 Max (evidence/environment.txt). Во время нагрузки на VM кроме стенда работал один чужой контейнер — RabbitMQ стенда лабы 6 (evidence/load.txt). Данные синтетические: пользователи и чаты сценариев, fixture sample.png (111 817 B), для уровня «4» — PNG 1 и 10 MiB со случайными пикселями, для трека 2 — до 30 000 вложений по 264 B и 3 418 загрузок PNG 8 × 8; к концу серии уровней «3» и «4» в базе 70 839 сообщений и 1 769 готовых вложений. Повторы: память и нагрузка — по три прогона, отказы с бинарным критерием — по одному, остановка реплики под записью — по разу на каждую реплику плюс по прогону в чистом clone и после трека, всегда без неудачных записей.

Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
Остановлена реплика, принявшая upload (failover-upload) скачивание через другую реплику, тот же SHA-256 upload через 899a952a5a21, после её остановки download 200 через 0cc3ee358e59, SHA-256 равен (failover-upload.json) 2,73 с от старта хука; потерь нет
Остановлена реплика под записью (make test-failover, по очереди обе) запись восстанавливается ≤ 10 с, дублей нет, вложение читается 2,89 и 2,88 с до первой записи, 0 неудачных попыток, 129 и 128 записей, история без дублей, вложение байт-в-байт; target exited, сосед running (failover-*.txt) ≤ 2,9 с; потерь нет
Перезапуск LB, API, PostgreSQL, Valkey, S3 с volumes (restart.sh) метаданные, байты, сессия и история на месте однократные GET метаданных и /content сразу после хука совпали; StartedAt всех контейнеров новее, ID те же (persistence.txt) хук ждёт healthy S3; потерь нет
docker compose stop s3 upload и /content → 503 за ограниченное время; тексты, метаданные, readiness работают 503 за 2,23 и 1,99 с; текст 201, метаданные и readiness 200 (s3-outage.json) S3 healthy через 5,8 с; файл тот же; неудачный upload оставил одну невидимую строку pending
docker compose stop postgres / valkey (make faults-evidence) 503 без 500; без Valkey проверка токенов через PostgreSQL PostgreSQL: ready, me, login, register 503 за ≤ 0,015 с; Valkey: токен 200, неизвестный 401, вход 201, выход 503 (faults.txt) после start — без рестарта API; потерь нет
Посторонний: метаданные, /content, upload в чужой чат, ссылка на чужое вложение 404 без раскрытия 404 во всех случаях, раньше проверок содержимого (upload-faults.txt) —
Анонимный клиент S3 из сети стенда 403 прямой GET 403, Head/List/Put — deny (s3-security.txt) —
Тело 10 485 761 B (Content-Length и chunked), PNG 100 000 × 100 000 413 до чтения сверх лимита и до декодирования 413; строк и объектов не появилось —
Отказ COMMIT после записи объекта (триггер PostgreSQL, 55P03) 503; объект и строка удалены сразу 503; строки нет, HEAD объекта 404, audit.attachment_discarded reason=compensation сразу; вечных объектов нет
Реплика убита SIGKILL между PUT и COMMIT (обе по очереди) обрыв запроса; невидимый остаток уходит после grace клиент — 502 от LB; pending и объект на месте; после сдвига за grace убраны через 24,7 с, свежий остаток не тронут до своего сдвига grace 900 с (в тесте — сдвиг created_at); реплика возвращена up --wait
Клиент оборвал тело после 256 KiB из 5 MiB ничего не записано, не 500 400 в журнале реплики, намерения нет —
Тело зависло после 1 KiB 503 не позже таймаута запроса 503 за 8,01 с, ничего не записано слот свободен, следующий upload 201
36 ошибочных запросов к вложениям через LB 4xx по контракту, ни одного 5xx 16 × 400, 6 × 404, 4 × 413, 10 × 415; в журнале 0 × 5xx —
Потерянный ответ: клиент сдался, запись ждёт блокировку чата; повтор тем же ключом (make retry-check) 201 с тем же сообщением, одна копия реплика жива — повтор через 1,53 с, тот же id; реплику убили, пока запрос ждал, — повтор через 1,54 с от соседа, тот же id, одна копия (retry.json) потерь и дублей нет
40 одновременных загрузок по 10 MiB без лимита слотов (×3) память растёт до лимита пик 512,3 MiB = лимит cgroup во всех трёх прогонах; 201 — 53, 46 и 80 из 80, остальные 503 по таймауту запроса; oom_kill 0 67 из этих и следующих 503 оставили невидимые pending — см. строку ниже
То же с 3 слотами на воркер (×3) пик ограничен; ожидание слота укладывается в таймаут запроса пик 333,7–344,6 MiB, LB ≤ 31 MiB, oom_kill 0; 201 — 73, 80 и 80 из 80: в первом прогоне 7 загрузок не уложились в 8 с (ожидание слота плюс запись) и получили 503 во время PutObject; p95 4,6–7,6 с —
Остатки 503 по таймауту после серии памяти невидимы, сверка видит их свежими, уборка удаляет после grace make reconcile: 1 794 объекта, 1 837 строк, pending_fresh 68 (67 от серии и 1 от s3-outage), прочих расхождений 0; уборка удалила все 68 (audit.attachment_discarded reason=abandoned × 68), после неё сверка: 1 769 объектов = 1 769 строк ready, расхождений 0 (overload-leftovers.txt) grace 900 с: намерение s3-outage убрано через 903 с, последнее из серии — через 929 с после создания; готовые не тронуты
Трек 2: мусор под префикс, удалённые и перезаписанные объекты, намерения без объекта и с объектом (старше grace) dry-run находит, apply чинит, повтор — 0 так и есть: 18 найдено, 18 исправлено, повтор 0; строки ready не удалены, а в карантине один проход apply (0,11 с); байты 9 повреждённых вложений не восстановить — второго источника нет, карантин закрывает /content
Трек 2: объект вложения в карантине вернули в bucket карантин снят healed 1, /content снова отдаёт исходные байты следующий проход
Трек 2: сверка при остановленном S3 код 1 за ограниченное время, ничего не меняет код 1 за 1,63 с, EndpointConnectionError в журнале повторить после возврата S3
Трек 2: --apply подряд во время загрузок через LB ни одно идущее или готовое вложение не удалено 3 418 × 201, все готовы с тем же SHA-256, lost_ready 0; 247 раз объект идущей загрузки выглядел объектом без строки и остался потерь нет

Нагрузка записи сообщений (историческая серия asyncpg)

Цель. Проверить, что после переноса исправлений лабы 3 и добавления вложений запись сообщений под нагрузкой проходит без ошибок, и снять её профиль: RPS, задержки, CPU и память. Гипотеза о пределе заранее не ставилась.

Методика (evidence/load.txt). Публичный tests/load.py: закрытый контур, 64 потока, 8 с, все записи прогона — в один новый чат (одна строка chats под блокировкой), без повторов; 3 прогона с паузой 15 с, без прогрева (регистрация и чат создаются до окна замера). Клиент — одноразовый контейнер в сети edge стенда (2 CPU, 512 MiB, образ Python API по digest, tests/ только для чтения, tcp_tw_reuse), адрес — http://lb:8080, как у k6 в лабе 3. Первая попытка с хоста macOS отброшена: load.py открывает соединение на каждый запрос, и через прокси Docker Desktop диапазон эфемерных портов хоста кончился (≈ 16 000 сокетов TIME_WAIT) — 10 045 и 6 398 клиентских ошибок соединения при том, что реплики ответили 201 на каждый дошедший запрос (evidence/load/host-attempt.txt). На 4-й секунде снимается docker stats стенда и клиента, после прогона — статусы request.handled реплик.

Результаты (медиана трёх прогонов, evidence/load/run{1,2,3}.json):

Прогон Успешных запросов Ошибок RPS p50 / p95 / p99, мс
1 17 199 0 2 100 25,9 / 68,5 / 96,6
2 17 386 0 2 118 26,4 / 66,6 / 86,2
3 17 332 0 2 106 26,6 / 67,0 / 88,4
медиана — 0 из 51 917 2 106 26,4 / 67,0 / 88,4

На репликах — только 201 и 200, ни одного 4xx/5xx. CPU в середине прогона: api 89–98 % каждая при лимите 1 CPU, postgres 213–215 % при лимите 2 CPU, lb 79–81 %, клиент 102–106 % из 2 CPU, Valkey ≈ 6 %, RustFS < 4 %; память api 215–218 MiB из 512, postgres 165–186 MiB. Разброс RPS между прогонами — 0,9 %.

Вывод. Запись идёт без ошибок, а упирается в CPU: и реплики, и PostgreSQL работают у своих лимитов, поэтому 2 100 RPS — пропускная способность этого распределения CPU для записи в один горячий чат, а не предел архитектуры. Задержки — только успешных запросов закрытого контура (согласованные пропуски, клиент на той же VM). Загрузки вложений нагружают другое — память и сеть, — их пропускная способность снята в эксперименте ниже: 13 загрузок по 10 MiB в секунду (≈ 130 MiB/s через LB в S3) при 10 и 20 клиентах и 3 слотах на воркер.

Эксперимент уровня «4»: память при одновременных загрузках

Гипотеза (D3 в design.md изменения add-lab4-upload-resilience). Без ограничения каждая загрузка 10 MiB в полёте держит в воркере несколько копий тела, и пик памяти реплики растёт с числом одновременных загрузок до лимита cgroup. С UPLOAD_CONCURRENCY слотами на воркер пик ограничен величиной «простой + 2 воркера × слоты × память загрузки» и от числа клиентов не зависит; лишние клиенты ждут слота — растёт задержка, а 503 получает только тот, чьё ожидание вместе с записью дольше таймаута запроса 8 с.

Методика. scripts/upload_memory.py (цель make upload-memory; генератор scripts/lab4_seed.py), три прогона всей матрицы подряд в evidence/upload-memory/run{1,2,3}/. Стенд compose.yaml: 2 реплики по 1 CPU и 512 MiB, 2 воркера; LB 128 MiB; RustFS 1 CPU, 512 MiB. Перед каждой точкой реплики и LB пересоздаются (memory.peak cgroup v2 на ядре Docker Desktop не сбрасывается) и проходит ожидание двух UP в LB. Затем c потоков на keep-alive соединениях с хоста через LB делают по 2 загрузки одного PNG 1024 × h со случайными пикселями (1 048 276 или 10 485 256 B). Задержка — от отправки до ответа на клиенте, только по 201; пик — memory.peak каждой реплики и LB после точки (включает страничный кэш и память сокетов), простой — memory.current перед ней, oom_kill — из memory.events. Конфигурации: 64 слота (фактически без лимита) и 3 слота; 1 и 10 MiB; c = 10, 20, 40; отдельно один прогон 3 слота × 10 MiB с порогом mmap 32 MiB (evidence/upload-memory/mmap-32m/).

Исторические результаты asyncpg (медиана трёх прогонов, в скобках — разброс; колонка LB — максимум трёх, округлённый вверх; простой реплики 112–122 MiB, лимит 512 MiB):

Слоты Размер c Ответы 201 из 2c в трёх прогонах p50 / p95, мс Пик реплики, MiB Макс. пика LB из трёх, MiB
64 1 MiB 10 / 20 / 40 все 111 / 156 · 161 / 214 · 263 / 398 176 / 189 / 212 ≤ 26
64 10 MiB 10 20, 20, 20 842 / 870 288 (278–291) 24
64 10 MiB 20 40, 40, 40 2 663 / 2 906 428 (422–503) 24
64 10 MiB 40 53, 46, 80 (27 и 34 × 503) 5 986 / 6 981 512 = лимит во всех трёх 26
3 1 MiB 10 / 20 / 40 все 106 / 157 · 142 / 250 · 230 / 390 173 / 180 / 185 ≤ 28
3 10 MiB 10 20, 20, 20 822 / 1 402 297 (281–297) 24
3 10 MiB 20 40, 40, 40 1 020 / 2 164 321 (314–321) 27
3 10 MiB 40 73, 80, 80 (7 × 503) 3 644 / 7 310 334 (334–345) 31
3, mmap 32 MiB 10 MiB 10 / 20 / 40 все (один прогон) 802 / 1 290 · 2 324 / 3 613 · 3 139 / 5 373 321 / 356 / 346 ≤ 31

Вывод. Гипотеза подтверждена, с оговоркой о верхней точке. Без лимита пик 10 MiB-загрузок растёт 288 → 428 → 512 MiB и при 40 одновременных во всех трёх прогонах упирается в лимит cgroup: реплика отвечает 503 на 27, 34 и 0 загрузок из 80 (OOM-убийства в этой серии не было, но память — у самого лимита). С тремя слотами пик держится на 297–345 MiB (не больше 67 % лимита) при росте нагрузки вчетверо. Одна загрузка 10 MiB в полёте стоит ≈ 36 MiB ((334 − 120) / 6 слотов на реплику): тело, склейка кусков, копии проверки изображения и клиента S3. Цена лимита — ожидание слота: при 40 клиентах p95 4,6–7,6 с, у самой границы таймаута запроса 8 с, и в одном прогоне из трёх 7 загрузок из 80 не уложились в него и получили 503 — слоты защищают память, но очередь за ними ограничена таймаутом, и 40 одновременных загрузок по 10 MiB на две реплики — предел этой конфигурации. Для 1 MiB лимит не нужен: 173–213 MiB при любой одновременности. Порог mmap 32 MiB вместо 128 KiB добавляет к пику 12–35 MiB (321 / 356 / 346 против 297 / 321 / 334); это один прогон, и при 40 клиентах эффект сравним с разбросом. 503 по таймауту, пришедшиеся на PutObject или UPDATE, оставили невидимые намерения — их судьба в таблице отказов выше.

Ограничения. Клиент, LB, API и RustFS делят один хост и CPU; клиент работает с хоста через прокси Docker Desktop; пик cgroup включает страничный кэш и память сокетов; распределение соединений между воркерами gunicorn неравномерно, отсюда разброс p95 до 2,6 раза между прогонами одной точки; порог mmap — один прогон.

Трек 5 — трек 2 «Согласованность двух хранилищ (reconciler)»

Что сделано. Одноразовая команда python -m messenger.attachments.entrypoints.reconcile — сервис reconciler под профилем reconcile (make reconcile ARGS=…), по умолчанию --dry-run, --apply исправляет. Один проход сливает два отсортированных потока: листинг ListObjectsV2(Prefix="attachments/", MaxKeys=1000) (S3 отдаёт ключи в байтовом порядке) и keyset-страницы SELECT … FROM attachments WHERE object_key > $1 ORDER BY object_key LIMIT 1000 (Index Scan по attachments_object_key_key, колонка COLLATE "C" — тот же порядок; выбирается страница плюс одна строка, чтобы не читать пустую последнюю страницу). Для каждой строки сначала идут все объекты с меньшим ключом (объекты без строки), затем пара или её отсутствие. Время O(N), в памяти — по странице каждой стороны. Порог «старого» — now − grace − skew (по умолчанию 3600 + 60 с, grace ≥ 60): по LastModified объекта и created_at строки.

Класс Условие --apply
orphan_stale / orphan_fresh объект без строки старше / моложе порога повторный SELECT по ключу; строки нет → DeleteObject / ничего
missing ready, объекта нет HEAD: всё ещё 404 → карантин
size_mismatch ready, Size ≠ size_bytes HEAD: размер всё ещё другой → карантин
sha_mismatch --deep: SHA-256 потока ≠ sha256 карантин
pending_stale / pending_fresh pending старше / моложе порога FOR UPDATE SKIP LOCKED, всё ещё pending и старая → объект, затем строка / ничего
quarantined / healed в карантине и всё ещё расходится / размер снова совпал, и SHA-256 потока объекта равен sha256 (хешируется и без --deep) ничего / снять карантин

Безопасность: готовая строка и её объект не удаляются никогда — строка уходит в карантин (миграция 0004: quarantine_reason, quarantined_at), метаданные не меняются, /content отвечает 404 без запроса к S3, на строку по-прежнему ссылаются сообщения (message_attachments → attachments ON DELETE RESTRICT); карантин обратим, но снимается только после того, как объект прочитан и его SHA-256 совпал с метаданными. Объект той же длины с другими байтами строку из карантина не выпускает. Каждое действие предваряет повторная проверка той стороны, которую оно меняет (отказ — rechecked). Одновременно идёт один проход: pg_try_advisory_lock(20260004) на отдельном соединении на всё время прохода, второй отвечает skipped с кодом 0. --deep читает каждый объект потоком и хеширует кусками по 64 KiB, не больше 8 в полёте. Отчёт — JSON в stdout (классы, исправленное, rechecked, до 20 примеров id, запросы, время, CPU, пик RSS), журнал — в stderr без ключей объектов и кредов. Код 1 — любая ошибка прохода (журнал reconcile.failed с типом ошибки, без трассировки) или не выполненное действие. Удаление брошенного намерения пишет audit.attachment_discarded reason=reconcile, как уборка и компенсация API: события UoW идут через EventBus в AttachmentsJournal, сервис собирает dishka из PlatformProvider и того же провайдера хранилища, что у API. Ключ S3 у сверки свой (ListBucket, GetObject, DeleteObject), ключа API и root-ключей у сервиса нет. init: true: docker stop идущего прохода завершает его сразу, advisory lock снимает PostgreSQL при закрытии соединения.

Гипотезы записаны в design.md изменения add-lab4-storage-reconciler в коммите предложения 148868b, до первого прогона. H1 (корректность): слияние находит каждое внедрённое расхождение в его классе, --apply исправляет ровно найденное исправимое, повторный --apply — 0 действий; свежие объекты и намерения, готовые и используемые вложения не удаляются, в том числе во время загрузок. H2 (стоимость), дословно из 148868b: время прохода без --deep растёт линейно (t(100k)/t(10k) ≈ 10 ± 30 %) и определяется числом страниц листинга; запросов листинга и SQL — ⌈N/1000⌉, HEAD/GET — 0; пик RSS одинаков для 1k и 100k (разница < 10 %); --deep на порядок дороже на объект и линеен по объёму. История формулировки: после двух прерванных наполнений до 100k (cost-aborted/) H2 в 5ca2cdc была переписана на 30k (t(30k)/t(10k) = 3 ± 30 %), и прошлая версия отчёта проверяла уже её. Точка 100k в прежней серии не является доказательством SQLAlchemy; текущий цикл повторяет исходную H2 из 148868b. Соотношение 30k/10k приведено как дополнительное.

Текущая методика и данные SQLAlchemy. H1/H2/H3 повторно зафиксированы до измерений в предложении751aaed4b1baaa957c74bb8874adeb0eac4b0480. Полный протокол: evidence/sqlalchemy-2026-11-06/track5/NOTES.md. Два отдельных свежих project hlpipe-lab4-track-20261106 и hlpipe-lab4-cost-20261106, без удаления существующих volumes и остановки чужих контейнеров. Demo:18 явных upload плюс1 предварительного smoke, grace60/skew0, затем внедрение ошибок, dry/apply/повтор, независимая сверка и75 с загрузок. Cost:1k/10k/30k/100k, по3 shallow/deep и3 page100 на10k; PNG264 B, четыре параллельных PUT, SQLAlchemy INSERT. API/LB/Valkey во время cost остановлены. RustFS2CPU/3GiB на11–12, PG2CPU/1GiB на13–14, CLI1CPU/256MiB на15. Чужой CPU ограничен фильтром2ядраVM/0,25закреплённых; все27 принятых проходят его. Каждая команда, UTC, полный SHA и exit code сохранены; серии используют новый --out.

H1: корректность. 13/13 проверок PASS,256,958 с. Dry-run не изменил24 объекта/27 строк; найдены точные множества внедрённых id/key. Apply:3 orphan удалены,9 строк в карантине, 6 pending удалены с6 audit reason=reconcile; повтор0. Все6 ссылок сообщений и9 строк с расхождениями сохранены. Возврат исходных байтов снял1 карантин без deep; другие байты той же длины карантин не сняли. SIGTERM:exit143 за0,14 с, следующий проход не skipped; занятая блокировка→skipped; S3 и PG outage→exit1/reconcile.failed, без traceback. Под нагрузкой3331×201,67 проходов, после3342 здоровых ready,8 карантинов, lost_ready=0. Видели201 orphan_fresh и52 pending_fresh; rechecked={missing:42} означает повторныйHEAD. Повторную проверку строки перед удалением отдельно подтверждает собственный тест test_row_written_after_listing_keeps_the_object; наблюдение grace не выдано за этот барьер. Файлы: track5/demo/*.json, demo-command.txt и pg-outage.txt новой серии.

H2/H3: стоимость на SHA3402fd69d4922e500035a204d957be2cccaeb85a. Медианы трёх повторов и диапазон времени; CPU и RSS также медианы. Последняя колонка — исторический asyncpg61dcb6b, не причинный A/B-тест. Raw: track5/measurements/cost/; tools/summarize_reconciler.py проверяет все27 raw и воспроизводит analysis.json.

N Режим Проход, с: медиана [min–max] CPU, с Листинг / SQL, с LIST / SQL / GET RSS, MiB asyncpg, с → отношение
1000 shallow 0.107 [0.105–0.113] 0.560 0.087 / 0.011 1 / 1 / 0 109.8 0.108 → 0.991×
1000 deep 0.499 [0.498–0.536] 0.995 0.088 / 0.012 1 / 1 / 1000 110.2 0.546 → 0.914×
10000 shallow 0.999 [0.996–1.077] 0.865 0.907 / 0.079 10 / 10 / 0 110.9 1.032 → 0.968×
10000 deep 4.998 [4.972–5.041] 4.808 0.932 / 0.081 10 / 10 / 10000 111.3 5.041 → 0.991×
10000 page100 2.037 [2.035–2.113] 0.942 1.897 / 0.127 100 / 100 / 0 107.9 2.031 → 1.003×
30000 shallow 3.601 [3.567–3.633] 1.495 3.382 / 0.176 30 / 30 / 0 110.9 3.761 → 0.957×
30000 deep 15.665 [15.630–15.779] 13.503 3.461 / 0.204 30 / 30 / 30000 111.6 15.903 → 0.985×
100000 shallow 20.215 [20.206–21.335] 3.708 19.538 / 0.640 100 / 100 / 0 111.1 20.211 → 1.000×
100000 deep 110.910 [58.661–147.215] 83.969 35.014 / 1.199 100 / 100 / 100000 111.4 60.637 → 1.829×

H2 о времени отвергнута: t100k/t10k=20,235, вне[7,13]. Листинг занимает19,538 из20,215 с на100k, но причина роста внутри хранилища не установлена. LIST и SQL точно ceil(N/page), HEAD/GET=0 без deep; SQL здесь считает страницы, без служебных команд транзакций/пула. Память shallow109,8→111,1MiB (+1,18%) укладывается в<10%. Deep дороже по медианам в4,35–5,49 раза, не на порядок. H3 о страничности и памяти подтверждена в измеренной области. Абсолютный RSS после переноса выше исторического примерно на25–26%.

Ограничения трека. На100k deep получены147,215/110,910/58,661 с, разброс79,84% от медианы. Все три прошли заранее заданный CPU-фильтр; результаты не исключались по времени. Надёжного причинного вывода о влиянии SQLAlchemy на скорость deep нет. В остальных точках разброс0,95–8,11%. Один хост/VM, тёплые после наполнения данные, частоты/диск/нагрузка macOS не контролируются screen. PNG264 B не прогнозирует deep для10MiB; >100k не измерено, экстраполяции на миллион нет. Смещение часов не моделировалось. В demo grace60/skew0; штатная уборка API с grace900 проверена реальным ожиданием в grade4. Сверка не восстанавливает байты, работает вручную с префиксом attachments/; незавершённые multipart убирает lifecycle bucket. Следующий этап после ревью подготовит окончательную редакцию остальных исторических разделов отчёта по новым NOTES.

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

Сценарий защиты README — чем он показывается. (1) Fixture, сообщение с attachment_ids, скачивание вторым участником и сравнение SHA-256 — шаги LAB ≥ 4 в make test и make scenario SCENARIO=failover-upload (sha256_equal). (2) Посторонний получает 404 на метаданные и байты — тот же smoke; прямой анонимный GET объекта из отдельного контейнера — 403 (make s3-check). (3) make test-persistence ACTION_SCRIPT=scripts/restart.sh и make test-failover ACTION_SCRIPT=scripts/stop-one.sh (оба после хука один раз читают оригинал через API). (4) Локального файла оригинала на API нет — make attachments-evidence: корень реплик только для чтения, единственный tmpfs /tmp, volume нет. Для «4» и «5» — make upload-faults, make upload-memory, make reconcile-demo.

Почему файл в Docker volume одной API-реплики не равен объектному хранилищу? Volume реплики видит только она. Round robin отправит скачивание на соседа, и тот файла не найдёт; остановка или пересоздание принявшей реплики уносит доступ к файлу вместе с ней; новая реплика начинает с пустым volume. Общий volume на одном хосте не решает этого: его не подключить к реплике на другом узле, у него нет атомарной публикации объекта целиком, политики доступа, листинга по префиксу и правил жизненного цикла, а запись в него из нескольких процессов ничем не согласована. Объектное хранилище — отдельный сервис с одним пространством ключей для всех реплик: PutObject либо создаёт объект целиком, либо нет, доступ задают ключи и политика bucket, а реплики API остаются без состояния. Здесь upload принят репликой 899a952a5a21, хук остановил её за 2,72 с, и через 2,73 с от старта хука 0cc3ee358e59 отдала те же байты (failover-upload.json); у реплик ro=true и только tmpfs /tmp (storage-layout.txt), байты лежат в volume s3data сервиса s3.

Когда можно честно вернуть 201? Только когда обе записи подтверждены: S3 ответил на PutObject успехом и зафиксирован UPDATE … SET status='ready' в PostgreSQL. До PUT объекта нет — скачивание дало бы 404; после PUT, но до COMMIT, вложения нет для других реплик и для ссылок из сообщений, а после потери процесса на этом шаге клиенту нечего показать. Поэтому порядок — INSERT pending + COMMIT → PutObject → UPDATE ready + COMMIT → 201, и id вложения клиент узнаёт только из 201. Отказ S3 при записи даёт 503 и невидимую строку pending (test_storage_failure_leaves_nothing_visible в student-tests.txt), отказ COMMIT — 503 и немедленную компенсацию (upload-faults.txt). Оговорка: если потерян сам ответ 201, повтор клиента создаст второе вложение — у upload нет Idempotency-Key, LB его не повторяет, контракт допускает дубль.

Что произойдёт, если S3 PUT прошёл, а COMMIT в PostgreSQL — нет? Объект не становится вечным сиротой, потому что его ключ записан в строке-намерении до PUT. Три исхода: (1) PostgreSQL отклонил UPDATE ready — обработчик сразу берёт строку FOR UPDATE, удаляет объект, затем строку, клиент получает 503 (триггер с 55P03: строки нет, HEAD объекта 404, в журнале audit.attachment_discarded reason=compensation); если фиксация на самом деле прошла и строка уже ready, компенсация её не трогает. (2) Процесс убит между PUT и COMMIT — клиент получает 502 от LB, остаются невидимая строка pending и объект; фоновая уборка удаляет их после UPLOAD_GRACE_SECONDS=900 (объект, затем строка); в upload-faults.txt намерение, сдвинутое за grace, убрано через 24,7 с, свежее не тронуто. (3) Объект, о котором PostgreSQL не знает вовсе (ручная запись, ошибка, потерянная строка), находит reconciler трека 2 и удаляет только если он старше grace + skew и повторная проверка строки её не нашла.

Почему случайный object key и приватный bucket не заменяют ACL приложения? Решение «можно ли этому пользователю это вложение» зависит от членства в чате, и знает его только приложение (chat_members в PostgreSQL); S3 о пользователях мессенджера ничего не знает. Ключ — это предъявительский секрет: утёкший из журнала или ссылки, он работает для любого и не отзывается, когда человека удаляют из чата. Здесь ключ и не секрет: он равен attachments/<id>, а id видят все участники в attachment_ids. Приватный bucket закрывает только анонимный доступ — ключ API читает весь bucket. Поэтому скачивание идёт только через API, который при каждом запросе проверяет членство (eve — 404 на метаданные и /content, неотличимо от несуществующего вложения), а приватность bucket (403 анонимному GET), отдельный ключ API на один bucket и закрытая консоль — второй рубеж на случай ошибки в приложении (s3-security.txt).

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

  • Один Docker-host: RustFS работает одним узлом без parity, S3 и PostgreSQL — единственные точки отказа; это не HA. RustFS молод (GA 1.0.0 — 2026-09-16, rc 0.1.x), в 2025 у него были CVE; версия и digest закреплены. Community-образы MinIO недоступны, проект архивирован.
  • verify() для PNG проверяет структуру и CRC всех чанков, но не распаковывает пиксели: PNG с корректными CRC и испорченным zlib-потоком будет принят. Оригинал отдаётся побайтно, серверу это не вредит; полная распаковка стоила бы до 160 MB на 40 MP.
  • Уборка брошенных загрузок живёт в процессах API: если все реплики остановлены, намерения ждут их возвращения (невидимо для клиентов). Она находит только то, что начиналось с намерения в PostgreSQL; объекты без строки, ready без объекта и несовпадение байтов при нормальной работе не возникают и ищутся reconciler трека 2.
  • Компенсация не запускается при отмене запроса таймаутом посреди PUT или UPDATE: такие остатки ждут grace period (15 минут). Ответ в этом случае — 503, повтор клиента создаёт новое вложение. После новой серии памяти и отказов S3 остались 30 намерений (у 8 — объект). Штатная уборка удалила все после grace900с без сдвига возраста (evidence/sqlalchemy-2026-11-06/grade4/overload-leftovers.txt).
  • Слоты защищают память ценой ожидания: при 40 одновременных загрузках по10MiB на две реплики и3слотах новый p95 —4,48–6,51с; все80загрузок каждого из трёх повторов успешны, максимальный пик448MiB. Контроль64слота дал27×503. Это наблюдение выбранной матрицы, а не гарантия для любой нагрузки. Пик памяти снят на одном хосте, клиент и стенд делят CPU.
  • Тело всё ещё собирается в памяти целиком (≈ 36 MiB на загрузку 10 MiB с учётом копий проверки и клиента S3): потоковая запись в S3 без буфера потребовала бы multipart и проверки изображения после записи.
  • Ранний 413/404 до конца тела: клиент, ещё отправляющий 10 MiB, может получить reset вместо ответа; собственные тесты проверяют 413 через Content-Length. Токен проверяется раньше объявленного размера: анонимный клиент получает 401, а не лимит маршрута.
  • Минимальная скорость клиента — MIN_TRANSFER_RATE_BYTES (128 KiB/s): медленнее этого upload и скачивание обрываются (503 для upload, обрыв тела после заголовков для скачивания), быстрее — идут сколько нужно. Длинная передача держит слот загрузки и буфер тела: upload 10 MiB на пороговой скорости занимает слот до 88 с. При SIGTERM реплики передача, не успевшая за SHUTDOWN_TIMEOUT_SECONDS, прерывается.
  • Нагрузка записи снята закрытым контуром tests/load.py с клиентом на той же VM и всеми записями в один чат: это пропускная способность этого распределения CPU (реплики и PostgreSQL у своих лимитов), а не предел архитектуры; с хоста macOS тот же замер упирается в эфемерные порты.
  • Секреты лежат файлами в secrets/ на хосте (каталог 0700, файлы 0644, чтобы их читали непривилегированные пользователи контейнеров) — учебное упрощение вместо менеджера секретов. Ключ API S3 статичен, ротации нет.
  • Сверка хранилищ (трек 2) запускается вручную и не восстанавливает байты: у повреждённого вложения нет второго источника, оно остаётся в карантине до ручного возврата объекта. Стоимость обхода измерена до100k объектов; за этой границей утверждений нет. Ограничения и большой разброс deep100k — в разделе трека.
  • Подтверждено прогонами: всё в таблице доказательств, включая уровень «4» и трек 2 (H1 подтверждена, H2 — в части страничности и постоянной памяти, но не линейного времени или десятикратной цены deep). Не измерены: поведение сверки выше100k, deep на вложениях10MiB и расхождение часов S3/CLI.
  • Процесс openspec: правило config.yaml «proposal в пределах 400 слов» нарушено в двух архивных циклах — add-lab4-image-attachments и add-lab4-upload-resilience (около 453 слов без разметки, 492 и 477 по wc -w); у add-lab4-storage-reconciler 406 по wc -w и 364 без разметки. Архив уже закоммичен, историю не переписываю. Proposal переноса carry-over-lab3-review-fixes ссылается на «пункт 4.1 (согласованные таймауты и SIGTERM)» — это нумерация рубрики лабы 3. В этом отчёте перенос закрывает строку 3.9 (минимум лабы 3), а таймауты и SIGTERM лабы 3 проверяются тестами стенда (faults.txt) и make limits; строка 4.1 здесь — тесты файлов.

Из позднего ревью источника сохранён minor: одиночный Unicode surrogate в text (\ud800/\udfff) принимается CreateMessageRequest, но fingerprint() вызывает PydanticSerializationError до доменной проверки. Локальное воспроизведение на текущем коде — known-minor.txt; реальный HTTP возвращает 500 internal_error для обоих значений: known-minor-http.txt. Место ошибки — src/messenger/messaging/entrypoints/schemas.py:35. Это ограничение обработки непарного surrogate, не доказательство полной Unicode-валидации; по актуальному правилу minor не исправляется и не блокирует этап. Стандартные NUL/non-ASCII Basic сценарии исправлены и проверяются отдельно.

После позднего переноса граничная серия с 40 клиентами и PNG около 10 MiB дала 238/240 ответов 201, два ответа 503; максимум API 456,2 MiB при лимите 512 MiB, OOM 0. Причина двух 503 отдельно не локализована. Точка сохранена без повторения ради лучших чисел; 100% успешность при такой параллельности не заявляется. Три прогона записи дали медиану 1456,338 RPS с 0 ошибок, новый demo reconciler — 3364 upload без потери ready. Методика, сырые результаты и ограничения сравнения — forward-port.md.