REPORT.md gets the track 2 section: what the reconciler does and why it is safe, the hypotheses written before the first run, the method of the demo and the cost matrix with its screening, both result tables, the verdicts and the limits. H1 holds. H2 holds for the pass cost: time is linear (t(30k)/t(10k) = 3.73, 3.05 in the series of 29.10), the listing is 95 % of it, list requests are ceil(N/1000) and SQL one more for the empty last keyset page, RSS stays at 82.5-83.8 MiB; --deep is 4.3-5 times dearer per object, not ten. The criteria table, the failure table, the limits, AGENTS.md and the openspec context name the track rows, and evidence/reconcile/README.md describes every file. On a stand from a clean state make test, test-persistence, test-failover, restore, reconcile, lint, check, validate and student-test (342 passed) all pass; the dry-run after these scenarios finds 3 objects, 3 rows and no discrepancy. Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
80 KiB
Отчёт — лабораторная 4
- Автор, группа: Костылев Артём, БПИ2303
- Целевая оценка: 5; трек «5» — трек 2 «Согласованность двух хранилищ (reconciler)»
- Commit/PR: ветка
solution/bpi2303-kostylev, PR в репозиторий преподавателя - Использованные источники, библиотеки и помощь ИИ: FastAPI, gunicorn + uvicorn-worker, dishka, pydantic,
structlog, 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 и выполнено с помощью Claude Code; код, стенд и отказы проверены прогонами, перечисленными ниже.
Запуск из чистого clone
Требуются Docker с Compose v2, make и системный Python 3.9+ (только для публичных проверок и сценариев).
Образы сторонних сервисов закреплены версией и digest, API собирается из исходников.
git clone <repo> && 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
make test # публичный smoke через балансировщик, http://localhost: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 через другую
make scenario SCENARIO=s3-outage # S3 остановлен: upload/download 503, тексты и метаданные работают
make s3-check # приватность bucket вне API, права ключа API, консоль, повторный bootstrap
make upload-faults # уровень «4»: негативный suite через LB, компенсация, уборка после grace, обрыв и зависание тела
make upload-memory # уровень «4»: пик памяти реплик и LB при 10/20/40 одновременных загрузках 1 и 10 MiB
make reconcile # трек 2: сверка PostgreSQL ↔ S3, по умолчанию dry-run; ARGS="--apply --deep" — исправить
make reconcile-demo # трек 2: внедрение ошибок, dry-run/apply/повтор, безопасность, нагрузка → evidence/reconcile/
make reconcile-cost # трек 2: стоимость обхода 1k/10k/30k × 3 на чистом стенде → evidence/reconcile/cost/
make down # безопасная остановка: контейнеры удаляются, volumes pgdata, valkeydata, s3data остаются
make reset-data # НАМЕРЕННОЕ удаление учебных данных, включая байты вложений: docker compose down -v
make up ждёт healthy всех долгоживущих сервисов и успешного завершения одноразовых migrate (миграции под
advisory lock) и s3-init (bucket, анонимный доступ private, политика и пользователь API, lifecycle). Оба
повторяемы: повторный make up или restart.sh проходит без изменений состояния. Наружу публикуются только
порты lb на 127.0.0.1: LB_HTTP_PORT (8080) и LB_STATS_PORT (8404). На машине, где выполнялась работа,
параллельно работали стенды других лаб, поэтому в локальном .env стояли LB_HTTP_PORT=18084,
LB_STATS_PORT=24084, а проверки запускались с BASE_URL=http://localhost:18084. Прогон из свежего clone —
evidence/clean-clone.txt.
Собственные проверки и тулчейн:
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 PYTHON="uv run --no-project --with-requirements requirements-dev.txt python" # полная валидация OpenAPI
make stack-evidence # сервисы, порты, hostname ↔ X-Instance-Id, лимиты, сети, версии
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 всех контейнеров до и после
Версии и стенд: 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) ─┐ asyncpg pool ┌▶ 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.
Изменено: новая зона attachments; attachment_ids в сообщениях; миграция 0003; лимит тела в конвейере
зависит от маршрута; S3-сервисы в 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 и откатывает всю отправку вместе с ключом идемпотентности, а используемое
вложение нельзя удалить.
Схема (0003_attachments.sql, 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 его не разбирает.
401— guard конвейера;- объявленный
Content-Length>MAX_UPLOAD_BYTES→413в конвейере, тело не читается (лимит 10 MiB только у маршрута upload, у JSON остаётся 1 MiB); - членство в чате →
404(раньше любых проверок содержимого); filenameпосле percent-decode: 1–255 code points, не пробельный, без/,\и символов категорииCc(NUL,\x01,\x7f, перевод строки…) → иначе400; используется только для отображения;Content-Typeбез параметров и регистра ∈ {image/png,image/jpeg} → иначе415;- слот загрузки: не больше
UPLOAD_CONCURRENCY=3тел в памяти воркера, остальные ждут, не читая тело (uvicorn приостанавливает чтение сокета после 64 KiB), ожидание ограничено таймаутом запроса; - поток копится со счётчиком и инкрементальным SHA-256; байт
MAX_UPLOAD_BYTES + 1→413, дальше не читаем (так закрыт и chunked безContent-Length); обрыв клиента посреди тела →400в журнале, не500; - проверка изображения в потоке под семафором (
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; - запись (ниже); буфер тела освобождается до перевода в
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_timeout10 с) и не даёт задержавшемуся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 от
приложения за ≤2,6 с, а тексты и метаданные работают (evidence/s3-outage.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 и держит освобождённые тела в куче).
Цепочка таймаутов: клиент 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 с ключом, повтор отказа соединения безопасен (запрос
не ушёл).
Роли и сервисы (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…, read_only |
код выхода 0 | нет (infra/s3 только для чтения) |
backend |
root-ключи и ключ API (создаёт пользователя) |
операторский CLI (профиль tools) |
s3-cli |
тот же rc |
нет | нет | backend |
aliases root, api, anon |
| сессии (кэш) | valkey |
valkey/valkey:8.1.11-alpine@sha256:2602ace2…, uid 999 |
valkey-cli ping |
valkeydata (AOF) |
backend |
valkey.conf |
| bootstrap схемы | migrate |
образ api, restart: "no" |
код выхода 0 | нет | backend |
database_url |
сверка PostgreSQL ↔ S3 (профиль reconcile) |
reconciler |
образ api, read_only, entrypoint — модуль сверки |
код выхода 0 / 1 | нет | backend |
database_url, s3_access_key_id, s3_secret_access_key через *_FILE (ключ API, не root) |
нагрузка (профиль 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 (Get/Put/DeleteObject, abort/list multipart на
messenger-attachments/*, ListBucket и GetBucketLocation на сам bucket), пользователь API с ключом из
secrets/, lifecycle «незавершённый multipart старше суток удаляется», самопроверка анонимной политики и
привязки. Root-ключи есть только у s3, s3-init и s3-cli (evidence/storage-layout.txt, make limits).
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») |
| — | RECONCILE_CPUS, RECONCILE_MEMORY, RECONCILE_S3_READ_TIMEOUT_SECONDS |
1, 256m, 10 с: лимиты сервиса сверки и таймаут чтения страницы листинга (трек 2) |
| — | S3_CPUSET, PG_CPUSET, RECONCILE_CPUSET |
пусто — без закрепления; make reconcile-cost задаёт отдельные ядра на время замеров (трек 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 |
Доказательства критериев
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
| Публичный smoke | make test BASE_URL=http://localhost:18084 |
PASS: lab4 public API scenario (upload fixture → 201 ready, сообщение text="" с attachment_ids, скачивание bob побайтно с image/png, eve 404 на метаданные и /content, весь минимум lab2–lab3) |
evidence/smoke.txt |
| Запуск из чистого clone | git clone, make secrets, config --quiet, make up, make test |
valid; все сервисы Healthy, migrate и s3-init Exited (0); smoke PASS |
evidence/clean-clone.txt |
make check / make validate |
make check; make validate в venv с requirements-dev.txt |
PASS: offline skeleton structure…; PASS: full OpenAPI 3.1 and JSON Schema validation |
evidence/contract-checks.txt |
| Собственные тесты и линтер | make lint; make student-test |
ruff, формат, ty — All checks passed!; 335 passed (15 проверок стенда под маркером stack идут отдельно) |
evidence/student-tests.txt |
| 3.1 S3 в общем стенде; метаданные в PostgreSQL, байты в приватном bucket, не в БД и не на API | make attachments-evidence (ps, \d attachments, bytea по схеме, листинг bucket, docker inspect) |
s3 healthy без портов; в схеме bytea только хеши токенов и отпечатки; 14 строк ready и 14 объектов attachments/<uuid>; у реплик ro=true, только tmpfs /tmp и bind секретов; данные S3 на volume s3data |
evidence/storage-layout.txt |
3.2 201 ready только после записи объекта и COMMIT; побайтное скачивание вторым участником, SHA-256 |
smoke; make student-test (test_storage_failure_leaves_nothing_visible: S3 отказал → 503, строка pending, вложения нет); сверка вне API |
sha256 и размер последней строки ready в PostgreSQL равны sha256 и размеру объекта, прочитанного rc из bucket (99ea7533…, 111817) |
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) |
ровно 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 |
evidence/student-tests.txt |
| 3.5 Upload → остановка обслужившей реплики → download через другую | make scenario SCENARIO=failover-upload |
upload принят 196b3a876d81, хук остановил её за 2,69 с, скачивание через 8bd1d38428d0 через 2,70 с от старта хука, SHA-256 равен, реплика возвращена |
evidence/failover-upload.json |
| 3.5 Остановка каждой реплики под записью (публичный хук) | make failover-evidence дважды, между прогонами restore и сдвиг round robin |
196b3a876d81: первая запись через 2,74 с, 129 записей, 0 ошибок; 8bd1d38428d0: 3,08 с, 127, 0; target в exited, в логе — сигнал, окно readiness 503, выход; вложение после отказа читается bob; PASS: failover … |
evidence/failover-196b3a876d81.txt, evidence/failover-8bd1d38428d0.txt |
| 3.6 Restart с сохранением volumes сохраняет метаданные и оригинал | make persistence-evidence |
PASS: persistence … (после хука один GET метаданных и один /content без повторов совпали); StartedAt у lb, обеих api, postgres, valkey, s3, migrate, s3-init новее, контейнеры те же |
evidence/persistence.txt |
| 3.7 Недоступность S3: ограниченная ошибка, тексты работают, политика readiness | make scenario SCENARIO=s3-outage |
при остановленном s3: upload 503 за 0,98 с, /content 503 за 2,53 с, метаданные 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 s3-check |
образы по digest; s3-init пишет bucket=messenger-attachments anonymous=private policy=messenger-api; 22/22 проверки PASS, включая двойной повторный bootstrap без изменений |
evidence/s3-security.txt, evidence/environment.txt |
| 3.9 Перенос lab3: ≥2 реплики, одна точка входа, порты только у LB, схема и миграции, секреты вне Git | make stack-evidence, make storage-evidence |
2 api без портов, container_name 0, LB видит api1/api2 UP L7OK 200; миграции 0001–0003, повтор up to date без изменения счётчиков; git ls-files secrets .env пуст, secrets/s3_* игнорируются |
evidence/stack.txt, evidence/schema.txt, evidence/migrations.txt, evidence/secrets.txt |
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) |
335 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, уборка удалила вместе с объектом через 23 с, свежее осталось (pending, HEAD 200) и ушло через 3 с после сдвига; готовое вложение в сообщении со сдвинутым created_at скачивается с тем же SHA-256; обрыв после 256 KiB из 5 MiB → 400 в журнале, намерение не создавалось, ключи bucket те же; зависшее тело → 503 за 8,00 с, ничего не записано. API-тесты: снятое во время PUT намерение → 503 и удалённый объект, сбой PUT оставляет pending до конца grace, два параллельных прохода делят 5 намерений ровно, следующий проход удаляет 0 |
evidence/upload-faults.txt, evidence/student-tests.txt |
| 4.3 Лимиты, таймауты и потоковая обработка не дают одной загрузке занять неограниченную RAM; ≥10 одновременных загрузок с пиком памяти | make upload-memory (слоты 64 и 3 × 1 и 10 MiB × 10, 20, 40 одновременных, по 2 загрузки на клиента, реплики и LB пересоздаются перед каждым прогоном) |
при 3 слотах пик реплики 304 / 319 / 330 MiB для 10 / 20 / 40 одновременных загрузок по 10 MiB (простой ~120 MiB, лимит 512), все 140 загрузок 201, oom_kill 0, пик LB ≤ 29 MiB; без лимита слотов те же загрузки дают 300 / 423 / 513 MiB — при 40 упор в лимит cgroup и только 43 из 80 201, 37 × 503; 1 MiB при любой настройке — 187–219 MiB; с порогом mmap 32 MiB вместо 128 KiB — 317 / 334 / 368 MiB; таймауты: зависшее тело — 503 за 8 с (4.2), S3 — 2 × (1 + 2) с, LB timeout server 10 с |
evidence/upload-memory/summary.txt, evidence/upload-memory/*.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 — AccessDenied; анонимные Head/List/Put — deny, прямой HTTP GET объекта из отдельного контейнера — 403, анонимная политика private |
evidence/s3-security.txt |
| Регрессия уровня «3» и лабы 3 после изменений «4» | make test, make test-persistence ACTION_SCRIPT=scripts/restart.sh, make test-failover ACTION_SCRIPT=scripts/stop-one.sh по каждой реплике с make restore, lab4_scenarios.py failover-upload, s3-outage, abort-upload, make limits, make test-faults |
все PASS; остановлены по очереди обе реплики (Exited (0)); S3 остановлен — upload и /content 503 за 1,7 с, текст 201; 15 проверок стенда (лабы 2–3 и уровень «4») — passed |
evidence/regression-level4.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; объекты, строки и классы независимой проверки до и после 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) |
342 passed; каждый класс в dry-run без изменений, apply и повтор = 0, свежее и используемое сохранены, строка после листинга, карантин и 404, healed, --deep, занятая блокировка, отказ листинга посреди прохода → Unavailable; порядок и страницы листинга RustFS |
evidence/reconcile/after-checks.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; Docker
Desktop VM 16 CPU, 7.65 ГиБ, параллельно работали стенды других лаб. Объём данных — синтетические пользователи
smoke и fixture sample.png (111 817 B), для уровня «4» — синтетические PNG 1 и 10 MiB, для трека 2 — до 30 000
синтетических вложений по 264 B и 3 418 загрузок PNG 8 × 8 (разделы ниже).
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|---|---|---|---|
Остановлена реплика, принявшая upload (failover-upload) |
скачивание через другую реплику, тот же SHA-256 | download 200 через 8bd1d38428d0, SHA-256 равен |
2,70 с от старта хука; потерь нет |
Остановлена реплика под записью (make test-failover, обе реплики) |
запись восстанавливается ≤10 с, дублей нет, вложение читается | 2,74 и 3,08 с, 0 ошибок, история без дублей, вложение байт-в-байт | ≤3,1 с; потерь нет |
| Перезапуск LB, API, PostgreSQL, Valkey, S3 с volumes | метаданные, байты, сессия и история на месте | однократные GET метаданных и /content сразу после хука совпали |
хук ждёт healthy S3; потерь нет |
docker compose stop s3 |
upload и /content → 503 за ограниченное время; тексты, метаданные, readiness работают |
503 за 0,98 и 2,53 с; текст 201, метаданные и readiness 200 |
S3 healthy через 5,8 с; файл тот же; неудачный upload оставил одну невидимую строку pending (уборка — уровень «4») |
Посторонний: метаданные, /content, upload в чужой чат, ссылка на чужое вложение |
404 без раскрытия |
404 во всех случаях, раньше проверок содержимого |
— |
| Анонимный клиент S3 из сети стенда | 403 |
прямой GET 403, Head/List/Put — deny |
— |
Тело 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 убраны через 23 с, свежий остаток не тронут до своего сдвига |
grace 900 с (в тесте — сдвиг created_at); реплика возвращена up --wait |
| Клиент оборвал тело после 256 KiB из 5 MiB | ничего не записано, не 500 |
400 в журнале реплики, намерения нет, ключи bucket те же |
— |
| Тело зависло после 1 KiB | 503 не позже таймаута запроса |
503 за 8,00 с, ничего не записано |
слот свободен, следующий upload 201 |
| 36 ошибочных запросов к вложениям через LB | 4xx по контракту, ни одного 5xx |
16 × 400, 6 × 404, 4 × 413, 10 × 415; в журнале 0 × 5xx |
— |
| 40 одновременных загрузок по 10 MiB без лимита слотов | память растёт до лимита | пик 513 MiB = лимит cgroup, 43 из 80 201, 37 × 503; в предварительном прогоне ядро ещё и убило воркер (oom_kill 1, 7 × 502) |
воркер перезапущен gunicorn; потерь ready нет |
| То же с 3 слотами на воркер | пик ограничен, все 201 |
пик 330 MiB, LB 29 MiB, 80 × 201, p95 4,8 с |
— |
| То же с 3 слотами, но до ограничения буферов сокетов (предварительный прогон) | — | HAProxy (128 MiB) убит OOM: память сокетов ≈ 110 MB, соединения оборвались | найдено замером; исправлено tune.*buf LB и tcp_rmem/tcp_wmem API |
| Трек 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 раз объект идущей загрузки выглядел объектом без строки и остался |
потерь нет |
Эксперимент уровня «4»: память при одновременных загрузках
Гипотеза. Без ограничения каждая загрузка 10 MiB в полёте держит в воркере несколько копий тела, и пик памяти
реплики растёт с числом одновременных загрузок до лимита cgroup. С UPLOAD_CONCURRENCY слотами на воркер пик
ограничен величиной «простой + 2 воркера × слоты × память загрузки» и от числа клиентов не зависит; лишние клиенты
ждут слота — растёт задержка, а не число ошибок.
Методика. make upload-memory (scripts/upload_memory.py и генератор scripts/lab4_seed.py из заготовки).
Стенд 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). Задержка — от отправки до ответа на клиенте; пик —
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/summary.txt, коммит a774a2f):
| Слоты | Размер | c | Ответы | p50 / p95, мс | Пик реплики, MiB | Пик LB, MiB |
|---|---|---|---|---|---|---|
| 64 | 1 MiB | 10 / 20 / 40 | все 201 |
201 / 283 … 347 / 688 | 188 / 202 / 219 | ≤ 27 |
| 64 | 10 MiB | 10 | 20 × 201 |
912 / 950 | 300 | 21 |
| 64 | 10 MiB | 20 | 40 × 201 |
2177 / 2493 | 423 | 24 |
| 64 | 10 MiB | 40 | 43 × 201, 37 × 503 |
3921 / 6328 | 513 = лимит | 26 |
| 3 | 1 MiB | 10 / 20 / 40 | все 201 |
113 / 233 … 298 / 557 | 190 / 193 / 194 | ≤ 30 |
| 3 | 10 MiB | 10 | 20 × 201 |
2352 / 4190 | 304 | 21 |
| 3 | 10 MiB | 20 | 40 × 201 |
1921 / 3241 | 319 | 24 |
| 3 | 10 MiB | 40 | 80 × 201 |
2711 / 4799 | 330 | 29 |
3, mmap 32 MiB |
10 MiB | 10 / 20 / 40 | все 201 |
1045 / 1054 … 3994 / 7735 | 317 / 334 / 368 | ≤ 29 |
Вывод. Гипотеза подтверждена: без лимита пик 10 MiB-загрузок растёт 300 → 423 → 513 MiB и при 40 одновременных
упирается в лимит cgroup — реплика начинает отказывать (503 по таймауту, в одном прогоне — убитый воркер). С тремя
слотами пик держится на 304–330 MiB (64 % лимита) при росте нагрузки вчетверо, все загрузки успешны; цена —
ожидание слота (p95 4,8 с при 40 клиентах). Одна загрузка 10 MiB в полёте стоит ≈ 35 MiB ((330 − 121) / 6 слотов):
тело, склейка кусков, копии проверки изображения и клиента S3. Для 1 MiB лимит не нужен: 190–220 MiB при любой
одновременности. Замер нашёл ещё два места, где копится память: буферы сокетов LB (до ограничения tune.*buf
HAProxy убивался OOM) и куча glibc (порог mmap 32 MiB даёт +38 MiB к пику при 40 клиентах).
Ограничения. Один прогон на точку, разброс задержки между прогонами до 2 раз (неравномерное распределение соединений между воркерами gunicorn); клиент, LB, API и RustFS делят один хост и CPU; пик cgroup включает страничный кэш и память сокетов; параллельно работали стенды других лаб.
Трек 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 |
в карантине и всё ещё расходится / снова совпал | ничего / снять карантин |
Безопасность: готовая строка и её объект не удаляются никогда — строка уходит в карантин (миграция 0004:
quarantine_reason, quarantined_at), метаданные не меняются, /content отвечает 404 без запроса к S3, на строку
по-прежнему ссылаются сообщения (message_attachments → attachments ON DELETE RESTRICT); карантин обратим. Каждое
действие предваряет повторная проверка той стороны, которую оно меняет (отказ — rechecked). Одновременно идёт один
проход: pg_try_advisory_lock(20260004) на отдельном соединении на всё время прохода, второй отвечает skipped с
кодом 0. --deep читает каждый объект потоком и хеширует кусками по 64 KiB, не больше 8 в полёте. Отчёт — JSON в
stdout (классы, исправленное, rechecked, до 20 примеров id, запросы, время, CPU, пик RSS), журнал — в stderr без
ключей объектов и кредов; код 1 — недоступна зависимость или не выполнено действие. Ключ S3 — тот же
ограниченный ключ API (ListBucket, GetObject, DeleteObject), root-ключей у сервиса нет.
Гипотезы (записаны в design.md изменения до первого прогона). H1 (корректность): слияние находит каждое
внедрённое расхождение в его классе, --apply исправляет ровно найденное исправимое, повторный --apply — 0
действий; свежие объекты и намерения, готовые и используемые вложения не удаляются, в том числе во время загрузок.
H2 (стоимость): время прохода без --deep линейно (t(30k)/t(10k) = 3 ± 30 %) и определяется страницами листинга;
листингов и SQL — ⌈N/1000⌉, HEAD/GET — 0; пик RSS на 1k и 30k отличается меньше чем на 10 %; --deep на порядок
дороже на объект и линеен по объёму.
Методика.
make reconcile-demo(scripts/reconcile_track.py demo, стенд из чистого состояния, коммит5c3c238,--grace 60 --skew 0): 18 загрузок через LB, 6 из них в двух сообщениях → снимок готовых вне API (scripts/reconcile_check.py:rcпод root-ключом,psql, SHA-256 каждого объекта) → внедрение на обеих сторонах (scripts/reconcile-inject.sh): 3 объекта без строки (rc pipeмусора под префикс), 3 удалённых объекта (rc object remove, два — у вложений в сообщениях), 3 объекта, перезаписанных короче, 3 — случайными байтами той же длины, 3 строкиpendingбез объекта (INSERT— загрузка оборвалась доPUT) и 3 с объектом (PUTпрошёл,COMMIT readyнет — тот же остаток, что оставляет реплика, убитая между ними вmake upload-faults), все старше grace → пауза 65 с → ещё 2 свежих объекта без строки и 2 свежих намерения →--dry-run --deep→--apply --deepдважды → независимая проверка с--expect-readyи проверки API → возврат объекта (healed) → проход при занятой блокировке → проход при остановленномs3→ 75 с загрузок через LB (3 потока, каждое 10-е вложение — в сообщение) и--applyподряд всё это время → проверка--deep.make reconcile-cost(scripts/reconcile_track.py cost, свежий стенд, коммитb191623): RustFS 2 CPU / 3 GiB наcpuset11–12, PostgreSQL 13–14,reconciler15 (1 CPU, 256 MiB); наполнение до N = 1 000, 10 000, 30 000 синтетических вложений (student-tests/tools/seed_storage.py: 4 параллельныхPutObjectPNG 264 B иCOPYстрокready); на каждой точке 3 прохода--dry-run(страница 1000) и 3--dry-run --deep, на 10k ещё 3 со страницей 100. Метрики — из отчёта сверки: время прохода, ожидание листинга и SQL, число запросов, процессорное время, пик RSS.- Отбраковка: до и после каждого прогона читаются
/proc/statвсей VM Docker иcpu.statcgroups3и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 (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,943 | 0,078 | 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 | 1,018 | 0,045 | 10 / 11 / 10 000 | 4,72 | 84,1 |
| 30 000 | --deep |
16,150 | 538 | 3,597 | 0,133 | 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 и повторная проверка строки. - H2 подтверждена в части стоимости обхода, опровергнута в части
--deep. Без--deepвремя растёт линейно:t(10k)/t(1k)= 9,5,t(30k)/t(10k)= 3,73 (в пределах 3 ± 30 %, у верхней границы; в серии 29.10 — 3,05); запросов листинга⌈N/1000⌉, SQL на один больше — keyset дочитывает пустую последнюю страницу; пик RSS 82,5 → 83,8 MiB (+1,6 %) — память от N не зависит. 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), а не по расписанию.
Ограничения и следующие шаги
- Один Docker-host: RustFS работает одним узлом без parity, S3 и PostgreSQL — единственные точки отказа; это не HA.
RustFS молод (GA 1.0.0 — 2026-09-16,
rc0.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, повтор клиента создаёт новое вложение. - Слоты защищают память ценой ожидания: при 40 одновременных загрузках по 10 MiB p95 — 5,3 с, а при ещё большей
нагрузке хвост очереди упрётся в таймаут запроса 8 с и получит
503; правильная реакция клиента — повтор позже. Пик памяти снят на одном хосте, клиент и стенд делят CPU, по одному прогону на точку. - Тело всё ещё собирается в памяти целиком (до ~34 MiB на загрузку 10 MiB с учётом копий проверки и клиента S3): потоковая запись в S3 без буфера потребовала бы multipart и проверки изображения после записи.
- Ранний
413/404до конца тела: клиент, ещё отправляющий 10 MiB, может получить reset вместо ответа; собственные тесты проверяют413черезContent-Length. - Сверка хранилищ (трек 2) запускается вручную и не восстанавливает байты: у повреждённого вложения нет второго источника, оно остаётся в карантине до ручного возврата объекта. Стоимость обхода измерена до 30k объектов, дальше — экстраполяция; ограничения замеров — в разделе трека.
- Подтверждено прогонами: всё в таблице доказательств, включая уровень «4» и трек 2 (H1 подтверждена, H2 — в части
линейной стоимости обхода и постоянной памяти;
--deepоказался дороже в 4–5 раз, а не на порядок).