# Отчёт — лабораторная 4 - Автор, группа: Костылев Артём, БПИ2303 - Целевая оценка: **5**; трек «5» — **трек 2 «Согласованность двух хранилищ (reconciler)»** - Состояние на 2026-11-06: перенос SQLAlchemy/Alembic выполнен из immutable snapshot `f591fa64e525679a31c9db7f942d36c789e1a12f`, код переноса — `8e4532f6f5c05d902b6e2c310f54320d95585904`. Текущие проверки уровня 3: [новая матрица](evidence/sqlalchemy-2026-11-06/grade3/NOTES.md), полный SHA каждой команды в raw-выводе. Уровни 4/5 обновляются последовательными циклами; итоговую редакцию отчёта подготовит этап после ревью. **Таблицы и численные результаты ниже, ссылающиеся на evidence вне sqlalchemy-2026-11-06, относятся к исторической реализации asyncpg и не подтверждают текущий SQLAlchemy-код.** Публикация в этой фазе не выполняется. - Использованные источники, библиотеки и помощь ИИ: 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 собирается из исходников. ```sh git clone 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» и трека запускаются на поднятом стенде так же, без ручных шагов: ```sh make install # .venv для pytest-сценариев (uv sync --group dev) make upload-faults # «4»: негативный suite через LB, компенсация, уборка после grace, обрыв и зависание тела make upload-memory # «4»: пик памяти реплик и LB при 10/20/40 одновременных загрузках 1 и 10 MiB make reconcile-demo # трек 2: внедрение ошибок, dry-run/apply/повтор, безопасность, нагрузка → evidence/reconcile/ make reconcile-cost # трек 2: стоимость обхода 1k/10k/30k/100k × 3 на чистом стенде → evidence/reconcile/cost/ ``` `make up` ждёт `healthy` всех долгоживущих сервисов и успешного завершения одноразовых `migrate` (миграции под advisory lock) и `s3-init` (bucket, анонимный доступ `private`, политика и пользователь API, lifecycle). Оба повторяемы: повторный `make up`, `make migrate` или `restart.sh` проходит без изменений состояния. Собственные проверки и тулчейн: ```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/`, который назначает сервер. Реплика 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/`; у реплик `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 приведено как дополнительное. **Методика.** - `make reconcile-demo` (`scripts/reconcile_track.py demo`, стенд из чистого состояния: `make reset-data`, `make up`, `make test`; коммит `61dcb6b`, `--grace 60 --skew 0`): 18 загрузок через LB, 6 из них в двух сообщениях → снимок готовых вне API (`scripts/reconcile_check.py`: `rc` под root-ключом, `psql`, SHA-256 каждого объекта; готовых 19 — 18 загрузок сценария и fixture предварительного публичного smoke) → внедрение на обеих сторонах (`scripts/reconcile-inject.sh`): 3 объекта без строки (`rc pipe` мусора под префикс `attachments/`, uuid запоминается), 3 удалённых объекта (`rc object remove`, два — у вложений в сообщениях), 3 объекта, перезаписанных короче, 3 — случайными байтами той же длины, 3 строки `pending` без объекта (`INSERT` — загрузка оборвалась до `PUT`) и 3 с объектом (`PUT` прошёл, `COMMIT ready` нет — тот же остаток, что оставляет реплика, убитая между ними в `make upload-faults`), все старше grace → пауза 65 с → ещё 2 свежих объекта без строки и 2 свежих намерения → `--dry-run --deep` (сравниваются и счёт, и множества id по классам) → `--apply --deep` дважды → независимая проверка с `--expect-ready` и проверки API → под ключ одного вложения в карантине возвращаются исходные байты, под ключ другого — случайные той же длины → `--apply` без `--deep` → проход при занятой блокировке → `docker stop` прохода, висящего на листинге остановленного (`docker compose pause`) S3 → проход при остановленном `s3` → 75 с загрузок через LB (3 потока, каждое 10-е вложение — в сообщение) и `--apply` подряд всё это время → проверка `--deep`. - `make reconcile-cost` (`scripts/reconcile_track.py cost`, свежий стенд после `make test`, коммит `61dcb6b`): RustFS 2 CPU / 3 GiB на `cpuset` 11–12, PostgreSQL 13–14, `reconciler` 15 (1 CPU, 256 MiB); наполнение до N = 1 000, 10 000, 30 000, 100 000 синтетических вложений (`student-tests/tools/seed_storage.py` в одноразовом контейнере образа API под ключом API: 4 параллельных `PutObject` PNG 264 B и `COPY` строк `ready`); на каждой точке 3 прохода `--dry-run` (страница 1000) и 3 `--dry-run --deep`, на 10k ещё 3 со страницей 100. Метрики — из отчёта сверки: время прохода, ожидание листинга и SQL, число запросов, процессорное время, пик RSS. - Отбраковка: до и после каждого прогона читаются `/proc/stat` всей VM Docker и `cpu.stat` cgroup `s3` и `postgres`; чужой CPU за окно — занятость минус наше (`s3`, `postgres`, CPU процесса сверки) минус запуск контейнера (1,5 ядро·с во всей VM, 0,5 на закреплённых ядрах — замерено на простаивающем стенде). Прогон с чужим CPU больше 2 ядер во всей VM или 0,25 ядра на закреплённых ядрах уходит в `cost/disturbed/` и повторяется после 15 с тишины. Снимок `docker stats --all` хоста — до и после серии (`cost/host-docker-stats.txt`). **Результаты H1** (`evidence/reconcile/demo.json`: 12 из 12 проверок `ok`, 248 с): | Проверка | Наблюдение | Файл | | --- | --- | --- | | dry-run находит каждый класс и ничего не меняет | найдено ровно внедрённое: `orphan_stale` 3, `missing` 3, `size_mismatch` 3, `sha_mismatch` 3, `pending_stale` 6, `orphan_fresh` 2, `pending_fresh` 2; объектов 24 и строк 27 — до и после, классы независимой проверки те же | `dry-run.json`, `check-before.json` | | `apply` исправляет ровно найденное | 18 исправлений: 3 объекта без строки удалены, 9 строк в карантине (по 3 `missing`, `size_mismatch`, `sha_mismatch`), 6 намерений удалены (объект, затем строка); 9 `DeleteObject`, 6 `HEAD`, 19 SQL, ошибок 0 | `apply-1.json` | | повторный `apply` | 0 действий; видны 2 + 2 свежих и 9 в карантине | `apply-2.json` | | свежие и используемые не удалены | независимая проверка после: нарушений нет, `lost_ready` 0, свежие объект и намерение на месте; все 6 ссылок сообщений и 9 строк с расхождениями сохранены | `check-after.json`, `demo.json` | | карантин виден через API | метаданные вложения в сообщении с удалённым объектом — `200`, `/content` вложения с испорченными байтами — `404`, нетронутое вложение из того же сообщения скачивается побайтно | `demo.json` | | возврат объекта | объект вернули теми же байтами → `healed` 1, карантин снят, `/content` `200` с исходными байтами | `healed.json` | | один проход | пока другой сеанс держит `pg_advisory_lock(20260004)`: `skipped`, код `0`, 0 запросов | `lock-busy.json` | | S3 остановлен | код `1` за 1,63 с, журнал `reconcile.failed error=EndpointConnectionError`, stdout пуст, объекты, строки и классы те же | `s3-down.json` | | сверка во время загрузок | 75 проходов `--apply` за 75 с, 3 418 загрузок — все `201`; исправлены только 10 остатков внедрения (5 объектов без строки, 5 намерений), ошибок 0, `skipped` 0; объект идущей загрузки 247 раз попадал в проход без строки и 82 раза — свежим намерением, ни один не тронут; после нагрузки 3 429 готовых, у всех SHA-256 совпадает, `lost_ready` 0 | `under-load.json`, `check-under-load.json` | Кроме стенда, `make student-test` (`test_reconciler.py`) проверяет то же против одноразового PostgreSQL, включая строку, появившуюся между листингом и удалением (объект остаётся, `rechecked`), и отказ листинга посреди прохода `--deep` (проход завершается `Unavailable`; тест нашёл, что раньше ошибка выходила группой исключений `TaskGroup` и печаталась трассировкой вместо `reconcile.failed`, исправлено в `3b3cb5b`); `test_s3_storage.py` — байтовый порядок и страницы листинга RustFS. **Исторические результаты H2 до SQLAlchemy** (`evidence/reconcile/cost/summary.txt`, медиана трёх прогонов; отбраковано 0 из 21 — чужой CPU не больше 0,2 ядра в VM и 0,01 на закреплённых ядрах; разброс повторов ≤ 5 %): | N | Режим | Проход, с | мкс на объект | Листинг, с | SQL, с | Листингов / SQL / `GET` | CPU сверки, с | Пик RSS, MiB | | ---: | --- | ---: | ---: | ---: | ---: | --- | ---: | ---: | | 1 000 | без `--deep` | 0,105 | 105 | 0,090 | 0,008 | 1 / 2 / 0 | 0,47 | 82,5 | | 10 000 | без `--deep` | 1,000 | 100 | 0,946 | 0,043 | 10 / 11 / 0 | 0,73 | 83,6 | | 30 000 | без `--deep` | 3,729 | 124 | 3,562 | 0,145 | 30 / 31 / 0 | 1,36 | 83,8 | | 10 000 | страница 100 | 2,058 | 206 | 1,966 | 0,079 | 100 / 101 / 0 | 0,80 | 81,0 | | 1 000 | `--deep` | 0,493 | 493 | 0,091 | 0,009 | 1 / 2 / 1 000 | 0,86 | 83,0 | | 10 000 | `--deep` | 5,041 | 504 | 0,986 | 0,045 | 10 / 11 / 10 000 | 4,72 | 84,1 | | 30 000 | `--deep` | 16,150 | 538 | 3,620 | 0,149 | 30 / 31 / 30 000 | 13,68 | 84,1 | `HEAD` и удалений на согласованных данных — 0 во всех прогонах. Время `docker compose run` на 0,8–0,9 с больше прохода (старт контейнера и интерпретатора; CPU процесса без работы — 0,44 с, `lock-busy.json`). Первая серия 29.10 (`cost-2026-10-29/`, `5ca2cdc`, без отбраковки, на хосте шёл k6 другой лабы): без `--deep` 0,096 / 1,086 / 3,317 с, `--deep` на 30k — 15,9 с. **Выводы.** - H1 **подтверждена.** Каждый внедрённый класс найден в своём классе, dry-run ничего не меняет, `apply` исправил ровно найденное, повтор — 0 действий, независимая проверка вне API (другие инструменты и root-ключ) не нашла ни нарушений, ни потерь. Под непрерывной загрузкой 75 проходов подряд не тронули ни одного вложения: идущая загрузка выглядит для прохода «объектом без строки» (листинг увидел объект раньше, чем страница строк — строку) сотни раз, на этом стенде её защищает порог grace. Повторная проверка строки независимо доказана тестом `test_row_written_after_listing_keeps_the_object`; наблюдение grace не доказывает срабатывание recheck. - H2 **подтверждена в части стоимости обхода, опровергнута в части `--deep`.** Без `--deep` время растёт линейно: `t(10k)/t(1k)` = 9,5, `t(30k)/t(10k)` = 3,73 (в пределах 3 ± 30 %, у верхней границы; в серии 29.10 — 3,05); запросов листинга `⌈N/1000⌉`, в исторической версии SQL на один больше; текущий lookahead выбирает size+1 и делает ⌈N/страница⌉ запросов; пик RSS 82,5 → 83,8 MiB (+1,6 %) — память от N не зависит. На 10k и 30k 95 % прохода — ожидание листинга RustFS, а не код сверки (CPU сверки сверх старта ≈ 30 мкс на объект, SQL — 4–5 мс на страницу). Цена листинга — около 83 мкс на ключ плюс 11 мс на запрос (страница 100 вдвое дороже страницы 1000 при вдесятеро большем числе запросов), и на ключ она растёт с размером префикса: 90 / 95 / 119 мс на страницу при 1k / 10k / 30k — свойство RustFS 1.0.4 (та же картина у его записи, `cost-aborted/NOTE.txt`). `--deep` дороже не на порядок, а в 4,3–5 раз (493–538 мкс на объект) и линеен: `t(30k)/t(10k)` = 3,20. Его упор — CPU однопоточного процесса сверки (13,7 с CPU за 16,2 с при лимите 1 CPU): на мелких объектах время уходит на запрос `GetObject` в aiobotocore, а не на хеширование (8 МБ за проход). - Практически: проход без `--deep` по 30k вложений — 3,7 с и 84 MiB, т. е. около 2 мин на миллион объектов при той же цене листинга (на практике больше — листинг RustFS дорожает с префиксом); его можно запускать часто, `--deep` — реже или выборочно. Независимая проверка через `rc` хеширует 3 429 объектов за 68,5 с (20 мс на объект) — в 40 раз медленнее `--deep` сверки: она годится как оракул, но не как механизм. **Ограничения трека.** Верхняя точка матрицы — 30k, а не 100k: наполнить RustFS 1.0.4 до 100k объектов под одним префиксом за разумное время не удалось дважды (запись дорожает с ~8 до ~32 мс с ростом префикса, `cost-aborted/NOTE.txt`), поэтому линейность проверена на разбросе в 30 раз, а поведение на 100k+ — экстраполяция. Объекты матрицы мелкие (264 B): `--deep` на реальных вложениях (до 10 MiB) упрётся в объём, а не в число запросов, это не замерялось. Один хост и одна VM: S3, PostgreSQL и сверка разведены по vCPU, но не по физическим ядрам (у M4 Max ядра двух типов), загрузку самого macOS отбраковка видит только как loadavg (1,9–2,8 за серию). Отбраковка ловит чужой CPU сверх 2 ядер в VM и 0,25 ядра на закреплённых ядрах, меньший остаётся шумом; задержки диска VM она не видит. В этой серии соседей почти не было (стенд lab6 и проверка другого проекта, ≤ 0,2 ядра), серия 29.10 шла рядом с k6 другой лабы и без отбраковки — её 30k на 11 % быстрее, что даёт оценку разброса между днями. Расхождение часов S3 и сверки не моделировалось (один хост, `--skew 0` в сценарии, 60 с по умолчанию). Сценарий использует `--grace 60` вместо 3600 по умолчанию, чтобы уложиться в минуты; при боевом grace свежими были бы все объекты моложе часа. Сверка не следит за объектами вне префикса `attachments/` и за незавершёнными multipart (их убирает lifecycle-правило bucket через сутки), запускается вручную (`make reconcile`), а не по расписанию. ## Ответы на вопросы защиты **Сценарий защиты 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 видят все участники в `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`, повтор клиента создаёт новое вложение. В серии памяти так остались 67 невидимых намерений (у 25 — объект), уборка удалила их после grace (`overload-leftovers.txt`). - Слоты защищают память ценой ожидания: при 40 одновременных загрузках по 10 MiB на две реплики p95 — 4,6–7,6 с, у границы таймаута запроса 8 с, и в одном прогоне из трёх 7 из 80 загрузок получили `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) запускается вручную и не восстанавливает байты: у повреждённого вложения нет второго источника, оно остаётся в карантине до ручного возврата объекта. Стоимость обхода измерена до 30k объектов, дальше — экстраполяция; ограничения замеров — в разделе трека. - Подтверждено прогонами: всё в таблице доказательств, включая уровень «4» и трек 2 (H1 подтверждена, H2 — в части линейной стоимости обхода и постоянной памяти; `--deep` оказался дороже в 4–5 раз, а не на порядок). Гипотеза, а не факт: поведение сверки на 100k+ объектов, `--deep` на реальных вложениях до 10 MiB, расхождение часов S3 и сверки. - Процесс 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 здесь — тесты файлов.