forked from mtusi2026/mtusi2026lab4
706 lines
111 KiB
Markdown
706 lines
111 KiB
Markdown
# Отчёт — лабораторная 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: [протокол и память](evidence/sqlalchemy-2026-11-06/grade4/NOTES.md).
|
||
Штатные3слота: 840/840 успешных загрузок в18точках штатной конфигурации (36точек вместе с контролем), максимум API448MiB,
|
||
OOM 0; clean-clone cf41f7c прошёл и сохранил volumes. Штатная уборка сняла все 30 pending,
|
||
после неё 1669 строк/объектов без расхождений. Сверка трека проверяется отдельным циклом;
|
||
итоговую редакцию отчёта подготовит этап после ревью.
|
||
**Таблицы и численные результаты ниже, ссылающиеся на 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 <repo> mtusi2026lab4 && cd mtusi2026lab4 && git checkout solution/bpi2303-kostylev
|
||
|
||
make secrets # secrets/*: пароли PostgreSQL и Valkey, DATABASE_URL, CACHE_URL, ключ курсора,
|
||
# root-ключи S3 и отдельный ключ API S3; .env из .env.example (существующее не перезаписывает)
|
||
docker compose --env-file .env config --quiet
|
||
make up # docker compose up -d --build --wait: postgres, valkey, s3 → migrate, s3-init → api ×2 → lb;
|
||
# затем ждёт обе реплики UP в статистике LB
|
||
make test # публичный smoke через балансировщик (BASE_URL — порт lb из docker compose, иначе :8080)
|
||
make test-persistence ACTION_SCRIPT=scripts/restart.sh
|
||
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
|
||
make restore # вернуть остановленную реплику и дождаться её в ротации LB
|
||
make scenario SCENARIO=failover-upload # upload → стоп принявшей реплики → download через другую, SHA-256
|
||
make scenario SCENARIO=s3-outage # S3 остановлен: upload/download 503, тексты и метаданные работают
|
||
make s3-check # приватность bucket вне API, права ключа API, консоль, повторный bootstrap
|
||
make reconcile # трек 2: сверка PostgreSQL ↔ S3, по умолчанию dry-run; ARGS="--apply --deep" — исправить
|
||
make migrate # повторный запуск миграций: up to date
|
||
|
||
make down # безопасная остановка: контейнеры удаляются, volumes pgdata, valkeydata, s3data остаются
|
||
```
|
||
|
||
Каждая строка этого блока выполнена в свежем clone (`evidence/clean-clone.txt`; клон назван `mtusi2026lab4-clean`,
|
||
чтобы у него были свои compose-проект и volumes): `make up` за 11 с (образ из кэша слоёв), все сервисы
|
||
`healthy`, `migrate` применил `0001`–`0004`, `s3-init` вывел `bucket=messenger-attachments anonymous=private
|
||
policy=messenger-api`, smoke, persistence и failover `PASS`, повторный `migrate` — `up to date`, после `make down`
|
||
три volume на месте, после `make reset-data` — ни одного. Отступление от инструкции одно: на машине параллельно
|
||
работали стенды других лаб, поэтому в `.env` стояли `LB_HTTP_PORT=18084`, `LB_STATS_PORT=24084` (цели `make` берут
|
||
`BASE_URL` из `docker compose port lb 8080`). Наружу публикуются только порты `lb` на `127.0.0.1`.
|
||
|
||
Длинные сценарии уровней «4» и трека запускаются на поднятом стенде так же, без ручных шагов:
|
||
|
||
```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/<uuid7>`, который назначает сервер. Реплика API не хранит файлов:
|
||
корень только для чтения, `tmpfs /tmp` нужен лишь heartbeat gunicorn, volume у `api` нет
|
||
(`evidence/storage-layout.txt`).
|
||
|
||
**Перенесено из лабы 3 без изменения поведения:** зоны `identity` и `messaging`, порты и адаптеры, UoW, шина
|
||
событий с журналом аудита, ASGI-конвейер, Basic → Bearer, Argon2id, сессии в PostgreSQL с кэшем в Valkey,
|
||
подписанный курсор, порядок истории под блокировкой строки чата, `X-Instance-Id`, обязательный
|
||
`Idempotency-Key` в одной транзакции с сообщением, HAProxy с проверкой готовности и политикой повторов, окно
|
||
вывода реплики из ротации по `SIGTERM`, хуки `stop-one.sh`, `restore.sh`, `lb-wait.sh`, проверки уровня «4» лабы 3
|
||
(на итоговом коде прогнаны `make limits`, `lb-check`, `retry-check`, `test-faults`). Перенос шёл двумя шагами:
|
||
решение лабы 3 на `61c0c28` (`bf8e4e3`), затем её исправления после ревью (`e927afd`): отправка сообщения одной
|
||
командой SQL под блокировкой строки чата (улучшение трека 1 лабы 3), `503` в формате контракта для запроса,
|
||
прерванного остановкой, готовность за портом `Readiness`, счёт реально полученных байтов тела в конвейере.
|
||
**Изменено:** новая зона `attachments`; `attachment_ids` в сообщениях — ссылки пишутся той же командой SQL, что и
|
||
сообщение; миграции `0003` и `0004`; лимит тела в конвейере зависит от маршрута; S3-сервисы и `reconciler` в
|
||
`compose.yaml`; `restart.sh` перезапускает и S3; политика `scripts/limits.py` знает S3-сервисы.
|
||
|
||
**Зона `attachments` и её связь с `messaging`.** Зона владеет агрегатом `Attachment` (`pending` → `ready`),
|
||
значением `Filename`, своими ошибками, событием `AttachmentStored`, командой `UploadAttachment`, запросами
|
||
`GetAttachment`/`OpenAttachment`, портами `ObjectStorage`, `ImageInspector`, `ChatMembership` и HTTP-слоем. Ей нужен
|
||
один ответ от `messaging` — «входит ли пользователь в чат»; его даёт адаптер `MessagingMembership` над
|
||
`ChatDirectory`, который собирает `main.py`. Зоны не импортируют друг друга, SQL каждой зоны читает только свои
|
||
таблицы (оба правила проверяет тест `test_bounded_contexts.py`). Целостность между зонами держат внешние
|
||
ключи: `attachments (chat_id, owner_id) → chat_members` и `message_attachments (attachment_id, chat_id) →
|
||
attachments (id, chat_id) ON DELETE RESTRICT` — сообщение может сослаться только на вложение своего чата,
|
||
нарушение превращается в `404` и откатывает всю отправку вместе с ключом идемпотентности, а используемое
|
||
вложение нельзя удалить.
|
||
|
||
**Схема** (`alembic/versions/0003_attachments.py`, `evidence/schema.txt`): `attachments` без `bytea`, `CHECK` на тип, размер
|
||
1..10485760, формат SHA-256, статус; `object_key text COLLATE "C" UNIQUE` (байтовый порядок, как у листинга S3);
|
||
частичный индекс `(created_at) WHERE status = 'pending'`; `message_attachments` с PK `(message_id, position)`,
|
||
`UNIQUE (message_id, attachment_id)` и индексом по `attachment_id`. `messages_text_check` ослаблен до `≤ 4000`:
|
||
пустой текст с вложением легален, пустой без вложений по-прежнему отсекает домен (`400`). История и повтор
|
||
читают `attachment_ids` подзапросом по PK `message_attachments`, без N+1 запросов. Отсутствующий
|
||
`attachment_ids` и `[]` дают один отпечаток тела для `Idempotency-Key`, другой порядок — `409`. Миграция `0004` (трек 2)
|
||
аддитивно добавляет `quarantine_reason` (`missing`, `size_mismatch`, `sha_mismatch`) и `quarantined_at`, обе NULL или
|
||
обе заданы.
|
||
|
||
**Upload: где применяется каждый лимит.** Тело читается потоком, FastAPI его не разбирает.
|
||
|
||
1. `401` — guard конвейера: он читает только заголовок `Authorization` и сессию, тело не трогает;
|
||
2. объявленный `Content-Length` > лимита маршрута → `413` в конвейере, тело не читается (лимит 10 MiB только у
|
||
маршрута upload, у JSON остаётся 1 MiB); конвейер считает и реально полученные байты тела против того же лимита;
|
||
3. членство в чате → `404` (раньше любых проверок содержимого);
|
||
4. `filename` после percent-decode: 1–255 code points, не пробельный, без `/`, `\` и символов категории `Cc`
|
||
(NUL, `\x01`, `\x7f`, перевод строки…) → иначе `400`; используется только для отображения;
|
||
5. `Content-Type` без параметров и регистра ∈ {`image/png`, `image/jpeg`} → иначе `415`;
|
||
6. слот загрузки: не больше `UPLOAD_CONCURRENCY=3` тел в памяти воркера, остальные ждут, не читая тело (uvicorn
|
||
приостанавливает чтение сокета после 64 KiB), ожидание ограничено таймаутом запроса;
|
||
7. поток копится со счётчиком и инкрементальным SHA-256; байт `MAX_UPLOAD_BYTES + 1` → `413`, дальше не читаем
|
||
(так закрыт и chunked без `Content-Length`); обрыв клиента посреди тела → `400` в журнале, не `500`;
|
||
8. проверка изображения в потоке под семафором (`IMAGE_CHECK_CONCURRENCY=2` на воркер): `Image.open` только
|
||
PNG/JPEG читает заголовок; формат ≠ заявленному → `415` (подмена MIME); `width × height > MAX_IMAGE_PIXELS` →
|
||
`413` до декодирования (decompression bomb 100 000 × 100 000 весом 300 байт отклоняется по заголовку); PNG —
|
||
`verify()` (все чанки, CRC, `IEND`, без распаковки пикселей), JPEG — `draft` в 1/8 + `load()` (полное
|
||
декодирование потока, ≈1/64 памяти); ошибка → `415`;
|
||
9. запись (ниже); буфер тела освобождается до перевода в `ready`.
|
||
|
||
**Порядок записи PostgreSQL ↔ S3.** `INSERT attachments (status='pending')` и `COMMIT` → `PutObject` →
|
||
`UPDATE … SET status='ready'` и `COMMIT` → `201`. Намерение фиксируется до `PUT`, поэтому у любого объекта под
|
||
`attachments/` есть строка с тем же ключом; `pending` не видно ни в метаданных, ни в скачивании, а сослаться на него
|
||
нельзя — id отдаётся только в `201`.
|
||
|
||
| Сбой | Что остаётся | Ответ клиенту |
|
||
| --- | --- | --- |
|
||
| обрыв клиента, `413`, `415`, `400`, `404` | ничего: строка пишется только после чтения и проверки | ошибка или обрыв |
|
||
| `INSERT pending` | ничего | `503` |
|
||
| `PutObject` (S3 недоступен, таймаут) | невидимая строка `pending`, объект возможен (отложенная запись) | `503`; уборка после grace |
|
||
| `UPDATE ready` отклонён | компенсация сразу: объект и строка удалены | `503` |
|
||
| процесс убит между `PUT` и `COMMIT` | невидимая строка `pending` и объект | обрыв (`502` от LB); уборка после grace |
|
||
| после `COMMIT ready` | готовое вложение | `201` |
|
||
|
||
**Компенсация и уборка (уровень «4»).** Инвариант: пока объект под `attachments/` существует, существует и строка с
|
||
его ключом; строка-намерение удаляется только после объекта.
|
||
|
||
- *Компенсация.* Если `UPDATE … SET status='ready'` не зафиксирован, обработчик в новой транзакции берёт строку
|
||
`SELECT … FOR UPDATE`: `ready` (фиксация на самом деле прошла) — не трогает; `pending` — `DeleteObject`, затем
|
||
`DELETE … AND status='pending'`, `COMMIT`; строки нет — удаляет объект. Блокировка держится на время одного
|
||
`DeleteObject` (≤ 6 с < `idle_in_transaction_session_timeout` 10 с) и не даёт задержавшемуся `UPDATE ready`
|
||
проскочить между удалением объекта и строки. `UPDATE ready`, не нашедший строки (намерение уже убрано), даёт
|
||
`503` и удаление объекта, а не `201`. Сбой самого `PUT` и отмена по таймауту сразу не компенсируются: исход
|
||
`PUT` неизвестен, объект может появиться позже.
|
||
- *Уборка.* В каждом воркере `UploadSweeper` раз в `UPLOAD_SWEEP_INTERVAL_SECONDS=30` выбирает по одной строке
|
||
`WHERE status='pending' AND created_at < now − UPLOAD_GRACE_SECONDS ORDER BY created_at LIMIT 1 FOR UPDATE SKIP
|
||
LOCKED` (частичный индекс `attachments_pending_idx`), удаляет объект, затем строку, до `UPLOAD_SWEEP_BATCH=100` за
|
||
проход; `SKIP LOCKED` делит работу между 4 воркерами стенда, ошибка S3 откладывает строку до следующего прохода.
|
||
Каждое удаление — событие `audit.attachment_discarded` с причиной `compensation` или `abandoned`.
|
||
- *Grace period* `UPLOAD_GRACE_SECONDS=900` (минимум 60 в настройках): жизнь загрузки от `INSERT pending` до
|
||
`UPDATE ready` ограничена таймаутом запроса 8 с, отложенный `PUT` — таймаутами S3 6 с; запас больше 50 раз,
|
||
включая расхождение часов реплик одного хоста. Готовые строки и вложения в сообщениях не выбираются условием
|
||
`status='pending'`, а `message_attachments` ссылается на них с `ON DELETE RESTRICT`.
|
||
- *Незавершённый multipart* (сервер им не пользуется) удаляет lifecycle-правило bucket через сутки.
|
||
|
||
**Сверка хранилищ (трек 2).** Одноразовый сервис `reconciler` (образ API, профиль `reconcile`, ключ API S3)
|
||
сливает отсортированный листинг bucket и keyset-страницы `attachments` по `object_key` и находит то, что уборка
|
||
уровня «4» не видит: объект без строки, готовую строку без объекта или с другими байтами. По умолчанию только
|
||
отчёт; `--apply` удаляет старые объекты без строки и брошенные намерения, а готовые строки с расхождением не
|
||
удаляет, а помещает в карантин (миграция `0004`), `/content` такого вложения отвечает `404`. Подробно — раздел
|
||
трека ниже.
|
||
|
||
Платформа: откат транзакции раньше стирал все события команды, а шина не публиковала их при исключении — журнал
|
||
терял удаления из компенсации и уборки. Теперь откат убирает только события своей транзакции.
|
||
|
||
**Скачивание.** Строка `ready` по PK → членство → `GetObject` **до** отправки заголовков (пропавший объект → `404` с
|
||
событием `attachment.object_missing` в журнале, недоступный S3 → `503`) → `StreamingResponse` кусками 64 KiB с
|
||
`Content-Type` из метаданных, `Content-Length` из S3, `X-Content-Type-Options: nosniff`, `Cache-Control: private,
|
||
no-store`; `Accept` не учитывается, redirect нет, `X-Request-Id`/`X-Instance-Id` ставит конвейер. `variant` — только
|
||
`original`, иное → `400`.
|
||
|
||
**Клиент S3.** Один клиент aiobotocore на воркер (scope `APP` dishka): path-style, SigV4, регион `S3_REGION`,
|
||
`connect_timeout=1`, `read_timeout=2`, 2 попытки, checksum `when_required`. Обработчик botocore, добавлявший
|
||
`Expect: 100-continue` к телу `PutObject`, снят: aiohttp ждал `100 Continue`, RustFS за прокси портов его не
|
||
присылал, и запись висела до read timeout — это нашёл тест адаптера против настоящего RustFS. Ошибки соединения,
|
||
таймауты и `5xx` → `503 unavailable`; ключи S3 в журнал и ответы не попадают.
|
||
|
||
**Готовность.** `/health/ready` от S3 не зависит. Если бы зависела, при падении S3 балансировщик вывел бы все
|
||
реплики, отказали бы и тексты, а ответы LB не несут `X-Instance-Id`. Сейчас upload и скачивание получают `503` от
|
||
приложения: в новой серии upload 0,828–5,039 с, download 0,510–1,397 с
|
||
(граница проверки 6 с). Тексты и метаданные работают
|
||
(`evidence/sqlalchemy-2026-11-06/grade3/s3-outage-{1,2,3}.json`).
|
||
|
||
**Память загрузок (уровень «4»).** Пик памяти держат три настройки по всей цепочке, найденные замером (ниже):
|
||
слоты загрузки на воркер; буферы сокетов — HAProxy `tune.rcvbuf/sndbuf.client/server 65536`, у `api`
|
||
`net.ipv4.tcp_rmem`/`tcp_wmem` с максимумом 256 KiB (иначе ядро растит буфер до 6 MiB на соединение, и ожидающие
|
||
тела копятся в памяти контейнера LB); `MALLOC_MMAP_THRESHOLD_=131072` у `api` (иначе glibc после первого
|
||
освобождения поднимает порог `mmap` до 32 MiB и держит освобождённые тела в куче). Буферы сокетов нашёл первый прогон
|
||
замера, ещё без них: при 3 слотах и 40 загрузках по 10 MiB память сокетов HAProxy выросла до ≈ 110 MB, и LB с
|
||
лимитом 128 MiB убил OOM (описано в коммите `a774a2f`; сырых данных того прогона в `evidence/` нет). Влияние порога
|
||
`mmap` измерено отдельно (`evidence/upload-memory/mmap-32m/`).
|
||
|
||
**Цепочка таймаутов:** клиент smoke/resilience 10/2 с; LB `timeout server` 10 с > `REQUEST_TIMEOUT_SECONDS` 8 с >
|
||
худшая операция S3 2 × (1 + 2) = 6 с и ожидание соединения PostgreSQL + оператор 1 + 2 с. LB не повторяет upload:
|
||
`disable-l7-retry` снят только для `GET` и `POST …/messages` с ключом, повтор отказа соединения безопасен (запрос
|
||
не ушёл). Дедлайн запроса в конвейере продлевается переданными байтами тела запроса и ответа: `min(now, start +
|
||
moved / MIN_TRANSFER_RATE_BYTES) + 8 с`, по умолчанию 128 KiB/s (схема `mod_reqtimeout` с потолком). Медленная, но
|
||
идущая передача не обрывается: upload 10 MiB может идти до 80 + 8 с. Зависшее или ползущее медленнее порога тело
|
||
обрывается через 8 с плюс кредит уже переданных байтов (1 KiB даёт 8 мс). После последнего байта тела на обработку
|
||
остаётся не больше 8 с. `timeout server`/`timeout client` HAProxy — таймауты простоя одной стороны, поэтому длинная
|
||
идущая передача через LB не обрывается. Это проверено тестом стенда: 3 MiB вверх и вниз дольше 8 с.
|
||
|
||
**Роли и сервисы** (`compose.yaml`; сети `edge` и `backend` с `internal: true`):
|
||
|
||
| Роль | Сервис | Версия / digest | Health / readiness | Volume | Сеть / порт | Credentials |
|
||
| --- | --- | --- | --- | --- | --- | --- |
|
||
| load_balancer | `lb` | `haproxy:3.2.26-alpine@sha256:58938405…`, uid 99, `read_only`, буферы сокетов 64 KiB | `/healthz` :8404; реплики — `GET /health/ready` | нет | `edge` + `backend`; `127.0.0.1:${LB_HTTP_PORT:-8080}`, `127.0.0.1:${LB_STATS_PORT:-8404}` | нет |
|
||
| api ×`API_REPLICAS` | `api` | сборка из `Dockerfile`, uid 10001, `read_only` + `tmpfs /tmp`, `tcp_rmem`/`tcp_wmem` ≤ 256 KiB | `GET /health/ready` (PostgreSQL) | нет | `backend`, без портов | `database_url`, `cache_url`, `cursor_secret`, `s3_access_key_id`, `s3_secret_access_key` через `*_FILE` |
|
||
| postgres (метаданные) | `postgres` | `postgres:17.11-alpine@sha256:266d3c25…`, uid 70 | `pg_isready` | `pgdata` | `backend` | `postgres_password` через `POSTGRES_PASSWORD_FILE` |
|
||
| s3 | `s3` | `rustfs/rustfs:1.0.4@sha256:ed9210d6…`, uid 10001, `read_only`, `cap_drop: ALL`, консоль выключена | `curl /health/ready` | `s3data:/data` | `backend`, :9000 без публикации | root: `s3_root_user`, `s3_root_password` через `RUSTFS_*_FILE` |
|
||
| bootstrap S3 | `s3-init` | `rustfs/rc:v0.1.36@sha256:ab024bfe…`, uid 65534, `read_only` | код выхода 0 | нет (`infra/s3` только для чтения) | `backend` | root-ключи, ключи API и сверки (создаёт пользователей) |
|
||
| операторский CLI (профиль `tools`) | `s3-cli` | тот же `rc`, uid 65534 | нет | нет | `backend` | aliases `root`, `api`, `reconciler`, `anon` |
|
||
| сессии (кэш) | `valkey` | `valkey/valkey:8.1.11-alpine@sha256:2602ace2…`, uid 999 | `valkey-cli ping` | `valkeydata` (AOF) | `backend` | `valkey.conf` |
|
||
| bootstrap схемы | `migrate` | образ api, uid 10001, `init: true`, `restart: "no"` | код выхода 0 | нет | `backend` | `database_url` |
|
||
| сверка PostgreSQL ↔ S3 (профиль `reconcile`) | `reconciler` | образ api, uid 10001, `init: true`, `read_only`, `entrypoint` — модуль сверки | код выхода 0 / 1 | нет | `backend` | `database_url`, `s3_reconciler_access_key_id`, `s3_reconciler_secret_access_key` через `S3_*_FILE` (свой ключ, не root и не ключ API) |
|
||
| нагрузка (профиль `bench`) | `k6` | `grafana/k6:2.3.0@sha256:2dd4756e…` | нет | нет | `edge` | нет |
|
||
|
||
Приватный bucket создаёт `infra/s3/init.sh`: `rc bucket create --ignore-existing`, `rc bucket anonymous set private`,
|
||
политика `messenger-api` из `infra/s3/api-policy.json` (только `GetObject`, `PutObject`, `DeleteObject` на
|
||
`messenger-attachments/*`) и пользователь API, политика `messenger-reconciler` из `infra/s3/reconciler-policy.json`
|
||
(`ListBucket` на bucket, `GetObject`, `DeleteObject` на объекты) и пользователь сверки — оба с ключами из
|
||
`secrets/`. Дальше идёт lifecycle «незавершённый multipart старше суток удаляется» (он работает на стороне сервера,
|
||
ключам multipart-действия не нужны), самопроверка анонимной политики и привязки обеих политик. Реплики API
|
||
листинга bucket не делают и права на него не имеют, листинг есть только у ключа сверки. Root-ключи есть только у
|
||
`s3`, `s3-init` и `s3-cli` (`evidence/storage-layout.txt`, `evidence/limits.txt`).
|
||
MinIO не выбран: `minio/minio` удалён с Docker Hub, quay отдаёт 401, проект архивирован; SeaweedFS работает от
|
||
root и не читает ключи из файлов. Лимиты: lb 1/128m, api 1/512m на реплику, s3 1/512m, s3-init и s3-cli
|
||
0.5/64m, migrate 0.5/256m, reconciler 1/256m, postgres 2/1g, valkey 0.5/128m.
|
||
|
||
**Соответствие `.env.example` реальной конфигурации:**
|
||
|
||
| `.env.example` | В решении | Комментарий |
|
||
| --- | --- | --- |
|
||
| `APP_HOST`, `APP_PORT` | `HOST`, `PORT` | заданы в образе (`0.0.0.0:8080`); снаружи — порт LB |
|
||
| `APP_ENV` | не используется | режимов окружения нет |
|
||
| `SESSION_TTL_SECONDS`, `IDEMPOTENCY_TTL_SECONDS` | те же | 3600 и 86 400 |
|
||
| `DATABASE_URL_FILE`, `CACHE_URL_FILE` | те же | любой параметр читается из `<ИМЯ>_FILE` |
|
||
| `SESSION_STORE=postgres` | фиксировано | PostgreSQL — источник истины сессий, Valkey — кэш |
|
||
| `API_REPLICAS` | `deploy.replicas: ${API_REPLICAS:-2}` | число реплик `api` |
|
||
| `S3_ENDPOINT`, `S3_REGION`, `S3_BUCKET` | те же у `api`, `s3-init`, `s3-cli`; `RUSTFS_REGION` у `s3` | `http://s3:9000`, `us-east-1`, `messenger-attachments` |
|
||
| `S3_ACCESS_KEY_ID_FILE`, `S3_SECRET_ACCESS_KEY_FILE` | те же | ключ API, не root |
|
||
| `MAX_UPLOAD_BYTES`, `MAX_IMAGE_PIXELS` | те же | 10 485 760 и 40 000 000; больше контракта задать нельзя (валидация настроек) |
|
||
| — | `S3_CONNECT_TIMEOUT_SECONDS`, `S3_READ_TIMEOUT_SECONDS` | 1 и 2 с; две попытки укладываются в 8 с запроса |
|
||
| — | `IMAGE_CHECK_CONCURRENCY`, `S3_MEMORY` | параллельные проверки изображений на воркер; лимит памяти RustFS |
|
||
| — | `UPLOAD_CONCURRENCY`, `UPLOAD_GRACE_SECONDS`, `UPLOAD_SWEEP_INTERVAL_SECONDS`, `UPLOAD_SWEEP_BATCH` | 3 тела на воркер; 900 с; 30 с; 100 строк за проход (уровень «4») |
|
||
| — | `MALLOC_MMAP_THRESHOLD_` | 131 072: тела больше 128 KiB возвращаются системе при освобождении (уровень «4») |
|
||
| — | `MIN_TRANSFER_RATE_BYTES` | 131 072 B/s: каждый переданный байт тела продлевает дедлайн запроса на 1/скорость |
|
||
| — | `RECONCILE_CPUS`, `RECONCILE_MEMORY`, `RECONCILE_S3_READ_TIMEOUT_SECONDS` | 1, 256m, 10 с: лимиты сервиса сверки и таймаут чтения страницы листинга (трек 2) |
|
||
| — | `S3_CPUS`, `S3_CPUSET`, `PG_CPUSET`, `RECONCILE_CPUSET` | 1 CPU у RustFS; пусто — без закрепления; `make reconcile-cost` задаёт 2 CPU / 3 GiB RustFS и отдельные ядра на время замеров (трек 2) |
|
||
| — | `LB_HTTP_PORT`, `LB_STATS_PORT`, `API_CPUS`, `API_MEMORY`, `WEB_CONCURRENCY`, `DB_POOL_MAX_SIZE`, `API_SERVER_MAXCONN`, `DRAIN_SECONDS`, `PG_*`, `K6_*`, `CURSOR_SECRET_FILE` | как в лабе 3 |
|
||
|
||
## Доказательства критериев
|
||
|
||
Таблица ниже — историческая серия asyncpg. Актуальные результаты: `evidence/sqlalchemy-2026-11-06/grade3/NOTES.md`
|
||
и `grade4/NOTES.md`; результаты трека добавляются после его отдельного цикла. Файлы старых серий сохранены.
|
||
|
||
Уровни «3» и «4» сняты одной серией на стенде из чистого состояния (`make reset-data`, `make up`) на `81dd816`; порядок
|
||
серии — в `evidence/README.md`. Трек 2 — на `5c3c238` и `b191623`, проверка уровней после трека — на `8cb5a66`.
|
||
|
||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||
| --- | --- | --- | --- |
|
||
| Публичный smoke | `make test` | `PASS: lab4 public API scenario` (upload fixture → `201 ready`, сообщение `text=""` с `attachment_ids`, скачивание bob побайтно с `image/png`, eve `404` на метаданные и `/content`, весь минимум lab2–lab3) | `evidence/smoke.txt` |
|
||
| Запуск из чистого clone | блок «Запуск из чистого clone» дословно в каталоге `mtusi2026lab4-clean` | `valid`; `make up` за 11 с: все сервисы `healthy`, `migrate` (`0001`–`0004`) и `s3-init` `Exited (0)`, обе реплики `UP` в LB; smoke, persistence и failover (первая запись через 2,95 с, 128 записей, 0 ошибок) — `PASS`; `failover-upload` и `s3-outage` — `ok`; 23 проверки S3 — `PASS`; сверка: 5 объектов, 6 строк, расхождений нет, одно свежее намерение от `s3-outage`; повтор `migrate` — `up to date`; после `make down` 3 volume, после `make reset-data` — 0 | `evidence/clean-clone.txt` |
|
||
| `make check` / `make validate` | `make check`; `make validate` (`.venv` с `openapi-spec-validator` 0.7.2) | `PASS: offline skeleton structure…`; `PASS: full OpenAPI 3.1 and JSON Schema validation`; `git diff upstream/main` контракта, публичных тестов и задания пуст | `evidence/contract-checks.txt` |
|
||
| Собственные тесты и линтер | `make lint`; `make student-test PYTEST_ARGS=-v` | ruff, формат, ty — `All checks passed!`; `342 passed` по именам (17 проверок стенда под маркером `stack` — отдельно, `faults.txt`) | `evidence/student-tests.txt` |
|
||
| **3.1** S3 в общем стенде; метаданные в PostgreSQL, байты в приватном bucket, не в БД и не на API | `make attachments-evidence` (`ps`, `\d attachments`, `bytea` по схеме, листинг bucket, `docker inspect`); `make limits` | `s3` healthy без портов; `bytea` во всей схеме — только `sessions.token_hash` и `idempotency_keys.fingerprint`, строка `attachments` ≤ 264 B; 16 строк `ready` (и одна невидимая `pending` от `s3-outage`) и 16 объектов `attachments/<uuid>`; у реплик `ro=true`, только `tmpfs /tmp` и bind секретов; данные S3 — `volume:mtusi2026lab4_s3data:/data`; root-ключи S3 только у `s3`, `s3-init`, `s3-cli` | `evidence/storage-layout.txt`, `evidence/limits.txt` |
|
||
| **3.2** `201 ready` только после записи объекта и `COMMIT`; побайтное скачивание вторым участником, SHA-256 | smoke; `make student-test` (`test_storage_failure_leaves_nothing_visible`, `test_member_uploads_and_another_member_downloads`); сверка вне API | S3 отказал при записи → `503`, строка `pending`, вложения не видно; sha256 и размер последней строки `ready` в PostgreSQL равны sha256 и размеру объекта, прочитанного `rc` из bucket (`99ea7533…`, 111 817) | `evidence/smoke.txt`, `evidence/student-tests.txt`, `evidence/storage-layout.txt` |
|
||
| **3.3** Message с `attachment_ids` читается участниками; посторонний `404`; анонимный GET в S3 — `403` | smoke; `make student-test` (`test_message_attachments.py`, `test_attachments.py`); `make s3-check` | eve `404` на метаданные и `/content`; вложение другого чата и неизвестное → `404`, 11 и дубли → `400`, посторонний с 11 → `404`; одно вложение в нескольких сообщениях, порядок сохраняется; прямой HTTP GET объекта из отдельного контейнера → `403`, анонимные Head/List/Put → deny, политика `private` | `evidence/smoke.txt`, `evidence/student-tests.txt`, `evidence/s3-security.txt` |
|
||
| **3.4** PNG/JPEG ≤10 MiB и ≤40 MP; MIME по содержимому; опасные `filename`; лимиты до неограниченного чтения/декодирования | `make student-test` (`test_attachments.py`, `test_attachments_domain.py`); `make upload-faults` | ровно 10 485 760 B → `201`, +1 B с `Content-Length` и chunked → `413` без строки; 8000×5000 → `201`, 8001×5000 и 100 000×100 000 → `413` по заголовку; JPEG/GIF/WebP/текст как PNG, PNG как JPEG, обрезанные PNG/JPEG, пустое тело, `application/octet-stream`, без `Content-Type` → `415`; `../a.png`, `a/b.png`, `a\b.png`, `%00`, `%01`, `%7F`, пустое, пробельное, 256 символов, без параметра → `400`; кириллица и 255 символов → `201`; те же случаи через LB — в 4.1 | `evidence/student-tests.txt`, `evidence/upload-faults.txt` |
|
||
| **3.5** Upload → остановка обслужившей реплики → download через другую | `make scenario SCENARIO=failover-upload` | upload принят `899a952a5a21`, хук остановил её за 2,72 с, скачивание через `0cc3ee358e59` через 2,73 с от старта хука, SHA-256 равен, реплика возвращена | `evidence/failover-upload.json` |
|
||
| **3.5** Остановка каждой реплики под записью (публичный хук) | `make failover-evidence`, затем `make failover-evidence SHIFT=1` | `899a952a5a21`: первая запись через 2,89 с, 129 записей, 0 ошибок; `0cc3ee358e59`: 2,88 с, 128, 0; target в `exited`, сосед `running`; в журнале target — сигнал, `service.draining` (2 с), readiness `503`, выход; вложение после отказа читается bob; `PASS: failover …`; после `restore` обе `running` | `evidence/failover-899a952a5a21.txt`, `evidence/failover-0cc3ee358e59.txt` |
|
||
| **3.6** Restart с сохранением volumes сохраняет метаданные и оригинал | `make persistence-evidence` | `PASS: persistence …` (после хука один `GET` метаданных и один `/content` без повторов совпали); `StartedAt` у `lb`, обеих `api`, `postgres`, `valkey`, `s3`, `migrate`, `s3-init` новее, ID контейнеров те же | `evidence/persistence.txt` |
|
||
| **3.7** Недоступность S3: ограниченная ошибка, тексты работают, политика readiness | `make scenario SCENARIO=s3-outage` | при остановленном `s3`: upload `503` за 2,23 с, `/content` `503` за 1,99 с, метаданные `200`, текст `201`, `/health/ready` `200`; S3 снова healthy за 5,8 с, файл скачивается с тем же SHA-256 | `evidence/s3-outage.json` |
|
||
| **3.8** Закреплённая версия образа S3 и создание приватного bucket | `compose.yaml`, `infra/s3/init.sh`; `make up`; `make s3-check` | все образы по digest; `s3-init` пишет `bucket=messenger-attachments anonymous=private policy=messenger-api lifecycle=abort-incomplete-uploads`; 23/23 проверки `PASS`, включая двойной повторный bootstrap без изменений | `evidence/environment.txt`, `evidence/clean-clone.txt`, `evidence/s3-security.txt` |
|
||
| **3.9** Перенос lab3: ≥2 реплики, одна точка входа, порты только у LB, схема и миграции, KDF, общая идемпотентность, секреты вне Git | `make stack-evidence`, `make limits`, `make storage-evidence`, `make lb-check`, `make retry-check` | 2 `api` без портов, `container_name` 0, LB видит `api1/api2 UP L7OK 200`, `X-Instance-Id` чередуется; политика лимитов, портов, секретов и сетей — `PASS`; миграции `0001`–`0004`, повтор `up to date` без изменения счётчиков (66 пользователей, 288 сообщений, 17 вложений); Argon2id у всех 66, хеши токенов по 32 B; один токен на обеих репликах — 20 + 20; 20 раундов × 8 параллельных POST одним ключом — 160 × `201`, по одной копии; потерянный ответ на живой и на убитой реплике — повтор `201` с тем же сообщением, одна копия; `git ls-files secrets .env` пуст | `evidence/stack.txt`, `evidence/limits.txt`, `evidence/schema.txt`, `evidence/migrations.txt`, `evidence/kdf.txt`, `evidence/secrets.txt`, `evidence/lb-check.json`, `evidence/retry.json` |
|
||
| **4.1** Тесты: слишком большой файл, повреждённое изображение, подмена MIME, чужое `attachment_id`, вложение другого чата; пользовательская ошибка не даёт `500` | `make student-test` (`test_attachments.py`, `test_message_attachments.py`, `test_upload_consistency.py`); `make upload-faults` (`test_user_errors_never_become_500` через LB против PostgreSQL и RustFS) | `342 passed`; на стенде 36 ошибочных запросов: 16 × `400` (опасные и пустые `filename`, 11 и повторяющиеся `attachment_ids`, невалидный UUID, пустой текст без вложений, `variant=thumbnail`), 6 × `404` (upload, метаданные, `/content` и ссылка постороннего, вложение другого чата, неизвестное вложение), 4 × `413` (10 MiB + 1 с `Content-Length` — ответ до первого байта тела, chunked, бомба 100 000 × 100 000, 8001 × 5000), 10 × `415` (обрезанные PNG и JPEG, JPEG/GIF/WebP/текст как PNG, PNG как JPEG, пустое тело, чужой и отсутствующий `Content-Type`); тело ошибки по схеме, `request_id` равен заголовку; в журнале реплик за исторический прогон 53 ответа, из них `5xx` — 0; строк вложений в чате ровно 2 — по числу `201`; обрыв клиента посреди тела — `400`, не `500` | `evidence/student-tests.txt`, `evidence/upload-faults.txt` |
|
||
| **4.2** Прерывание загрузки и отказ между записью S3 и БД не оставляют вечных неучтённых объектов: компенсация и уборка с grace period | `make upload-faults` (триггеры PostgreSQL на время теста, `docker kill -s KILL` реплики); `make student-test` (`test_upload_consistency.py`) | отказ `COMMIT` после `PUT` → `503`, сразу нет ни строки, ни объекта (`HEAD` 404), в журнале `audit.attachment_discarded reason=compensation`; реплика убита между `PUT` и `COMMIT` (обе по очереди, клиент получил `502` от LB) → остались `pending` и объект (`HEAD` 200); намерение, сдвинутое за grace, уборка удалила вместе с объектом через 24,7 с, свежее осталось (`pending`, `HEAD` 200) и ушло через 1,0 с после сдвига; готовое вложение в сообщении со сдвинутым `created_at` скачивается с тем же SHA-256; обрыв после 256 KiB из 5 MiB → `400` в журнале, намерение не создавалось; зависшее тело → `503` за 8,01 с, ничего не записано. API-тесты: снятое во время `PUT` намерение → `503` и удалённый объект, сбой `PUT` оставляет `pending` до конца grace, два параллельных прохода делят 5 намерений ровно, следующий проход удаляет 0 | `evidence/upload-faults.txt`, `evidence/student-tests.txt` |
|
||
| **4.3** Лимиты, таймауты и потоковая обработка не дают одной загрузке занять неограниченную RAM; ≥10 одновременных загрузок с пиком памяти | `make upload-memory` трижды (`scripts/upload_memory.py --out evidence/upload-memory/runN`): слоты 64 и 3 × 1 и 10 MiB × 10, 20, 40 одновременных, по 2 загрузки на клиента, реплики и LB пересоздаются перед каждой точкой; отдельно порог `mmap` 32 MiB | при 3 слотах медиана пика реплики 297 / 321 / 334 MiB для 10 / 20 / 40 одновременных загрузок по 10 MiB, максимум трёх прогонов 345 MiB (простой 112–122, лимит 512), `oom_kill` 0, пик LB ≤ 31 MiB; без лимита слотов те же загрузки — 288 / 428 / 512 MiB, при 40 упор в лимит cgroup во всех трёх прогонах и 27 и 34 × `503` в двух из них; при 3 слотах и 40 клиентах p95 4,6–7,6 с, в одном прогоне 7 из 80 не уложились в таймаут 8 с (`503`); 1 MiB при любой настройке — 173–213 MiB; порог `mmap` 32 MiB — +12…35 MiB; таймауты: зависшее тело — `503` за 8,01 с (4.2), S3 — 2 × (1 + 2) с, LB `timeout server` 10 с | `evidence/upload-memory/run{1,2,3}/summary.txt` и JSON точек, `evidence/upload-memory/mmap-32m/` |
|
||
| **4.4** Идемпотентный bootstrap; отдельные ключи API с ограниченными правами; консоль не открыта; приватность bucket вне API | `make s3-check` | 23/23 `PASS`: у `s3` нет host-портов, консоль :9001 не отвечает ни внутри контейнера, ни из отдельного контейнера сети стенда (`connection refused`); `s3-init` ещё дважды — код 0, снимок IAM и bucket не изменился; ключ API: Put/Head/Get/List/Delete объектов — разрешены, CreateBucket, DeleteBucket, публичная политика, импорт lifecycle, `admin user list`, запись и листинг чужого bucket — deny; анонимные Head/List/Put — deny, прямой HTTP GET объекта из отдельного контейнера — `403`, анонимная политика `private` | `evidence/s3-security.txt` |
|
||
| Проверки стенда лаб 2–3 и «4» на итоговом коде | `make faults-evidence` (`pytest -m stack`) | `17 passed`: гонка регистрации, откат чата с неизвестным участником, одинаковый `Basic`-вызов, logout, Valkey остановлен (токен `200`, выход `503`), рестарт и `FLUSHALL` Valkey, PostgreSQL остановлен (`503` за ≤ 0,015 с и восстановление), рестарт API и всего стенда, срок сессии после рестарта, 5 сценариев вложений | `evidence/faults.txt` |
|
||
| **5 (трек 2)** Повторяемый reconciler: обнаружение каждого класса в dry-run | `make reconcile-demo` (внедрение `scripts/reconcile-inject.sh` на обеих сторонах, `--dry-run --deep`) | найдено ровно внедрённое: `orphan_stale` 3, `missing` 3, `size_mismatch` 3, `sha_mismatch` 3, `pending_stale` 6, свежих 2 + 2; объекты (24), строки (27) и классы независимой проверки до и после dry-run те же | `evidence/reconcile/dry-run.json`, `check-before.json`, `demo.json` |
|
||
| **5** Безопасное исправление, повторный запуск | `--apply --deep` дважды | 18 исправлений = найденному (3 удалённых объекта без строки, 9 строк в карантине, 6 намерений), ошибок 0; повтор — 0 действий | `evidence/reconcile/apply-1.json`, `apply-2.json` |
|
||
| **5** Свежие и используемые вложения не удаляются, в том числе под нагрузкой | независимая проверка `scripts/reconcile_check.py --deep --expect-ready` (вне API); 75 проходов `--apply` за 75 с загрузок через LB | после `apply`: `lost_ready` 0, свежие на месте, 6 ссылок сообщений и 9 строк в карантине сохранены, метаданные `200`, `/content` `404`; под нагрузкой: 3 418 × `201`, исправлены только 10 остатков внедрения, объект идущей загрузки 247 раз выглядел объектом без строки и не тронут, все SHA-256 совпали, `lost_ready` 0 | `evidence/reconcile/check-after.json`, `under-load.json`, `check-under-load.json` |
|
||
| **5** Карантин обратим, один проход за раз, отказ S3 | `make reconcile-demo` | возвращённый объект → `healed` 1, `/content` `200`; при занятой блокировке — `skipped`, код `0`; при остановленном `s3` — код `1` за 1,63 с, `reconcile.failed`, состояние то же | `evidence/reconcile/healed.json`, `lock-busy.json`, `s3-down.json` |
|
||
| **5** Стоимость обхода | `make reconcile-cost` (1k / 10k / 30k × 3 прогона, закреплённые CPU, отбраковка чужой нагрузки) | без `--deep` 0,105 / 1,000 / 3,729 с, листингов `⌈N/1000⌉`, `HEAD`/`GET` 0, RSS 82,5–83,8 MiB; `--deep` 0,49 / 5,04 / 16,15 с; отбраковано 0 из 21 | `evidence/reconcile/cost/summary.txt`, `cost/*.json`, `cost/host-docker-stats.txt` |
|
||
| **5** Тесты сверки | `make student-test` (`test_reconciler.py`, `test_s3_storage.py`) | каждый класс в dry-run без изменений, apply и повтор = 0, восстановленный объект выходит из карантина, строка после листинга сохраняет объект, второй проход пропущен, отказ хранилища посреди прохода → `Unavailable`; листинг RustFS страницами в байтовом порядке | `evidence/student-tests.txt` |
|
||
| Уровни «3» и «4» после трека 2 | стенд из чистого состояния: `make test`, `test-persistence`, `test-failover`, `restore`, `make reconcile`, `lint`, `check`, `validate`, `student-test` | все `PASS`, failover — первая запись через 2,70 с, 128 записей, 0 ошибок; dry-run после этих сценариев: 3 объекта и 3 строки, расхождений 0 | `evidence/reconcile/after-checks.txt` |
|
||
|
||
## Эксперименты и отказы
|
||
|
||
Стенд: 2 реплики `api` (1 CPU, 512 MiB, 2 воркера), RustFS 1 CPU / 512 MiB, PostgreSQL 2 CPU / 1 GiB, HAProxy
|
||
1 CPU / 128 MiB, Valkey 0,5 CPU / 128 MiB (`evidence/limits.txt`); Docker Desktop VM 16 CPU, 7,65 ГиБ на Apple M4 Max
|
||
(`evidence/environment.txt`). Во время нагрузки на VM кроме стенда работал один чужой контейнер — RabbitMQ
|
||
стенда лабы 6 (`evidence/load.txt`). Данные синтетические: пользователи и чаты сценариев, fixture
|
||
`sample.png` (111 817 B), для уровня «4» — PNG 1 и 10 MiB со случайными пикселями, для трека 2 — до 30 000 вложений
|
||
по 264 B и 3 418 загрузок PNG 8 × 8; к концу серии уровней «3» и «4» в базе 70 839 сообщений и 1 769 готовых вложений. Повторы: память и
|
||
нагрузка — по три прогона, отказы с бинарным критерием — по одному, остановка реплики под записью — по разу на каждую
|
||
реплику плюс по прогону в чистом clone и после трека, всегда без неудачных записей.
|
||
|
||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||
| --- | --- | --- | --- |
|
||
| Остановлена реплика, принявшая upload (`failover-upload`) | скачивание через другую реплику, тот же SHA-256 | upload через `899a952a5a21`, после её остановки download `200` через `0cc3ee358e59`, SHA-256 равен (`failover-upload.json`) | 2,73 с от старта хука; потерь нет |
|
||
| Остановлена реплика под записью (`make test-failover`, по очереди обе) | запись восстанавливается ≤ 10 с, дублей нет, вложение читается | 2,89 и 2,88 с до первой записи, 0 неудачных попыток, 129 и 128 записей, история без дублей, вложение байт-в-байт; target `exited`, сосед `running` (`failover-*.txt`) | ≤ 2,9 с; потерь нет |
|
||
| Перезапуск LB, API, PostgreSQL, Valkey, S3 с volumes (`restart.sh`) | метаданные, байты, сессия и история на месте | однократные `GET` метаданных и `/content` сразу после хука совпали; `StartedAt` всех контейнеров новее, ID те же (`persistence.txt`) | хук ждёт `healthy` S3; потерь нет |
|
||
| `docker compose stop s3` | upload и `/content` → `503` за ограниченное время; тексты, метаданные, readiness работают | `503` за 2,23 и 1,99 с; текст `201`, метаданные и readiness `200` (`s3-outage.json`) | S3 healthy через 5,8 с; файл тот же; неудачный upload оставил одну невидимую строку `pending` |
|
||
| `docker compose stop postgres` / `valkey` (`make faults-evidence`) | `503` без `500`; без Valkey проверка токенов через PostgreSQL | PostgreSQL: ready, me, login, register `503` за ≤ 0,015 с; Valkey: токен `200`, неизвестный `401`, вход `201`, выход `503` (`faults.txt`) | после `start` — без рестарта API; потерь нет |
|
||
| Посторонний: метаданные, `/content`, upload в чужой чат, ссылка на чужое вложение | `404` без раскрытия | `404` во всех случаях, раньше проверок содержимого (`upload-faults.txt`) | — |
|
||
| Анонимный клиент S3 из сети стенда | `403` | прямой GET `403`, Head/List/Put — deny (`s3-security.txt`) | — |
|
||
| Тело 10 485 761 B (`Content-Length` и chunked), PNG 100 000 × 100 000 | `413` до чтения сверх лимита и до декодирования | `413`; строк и объектов не появилось | — |
|
||
| Отказ `COMMIT` после записи объекта (триггер PostgreSQL, `55P03`) | `503`; объект и строка удалены сразу | `503`; строки нет, `HEAD` объекта 404, `audit.attachment_discarded reason=compensation` | сразу; вечных объектов нет |
|
||
| Реплика убита `SIGKILL` между `PUT` и `COMMIT` (обе по очереди) | обрыв запроса; невидимый остаток уходит после grace | клиент — `502` от LB; `pending` и объект на месте; после сдвига за grace убраны через 24,7 с, свежий остаток не тронут до своего сдвига | grace 900 с (в тесте — сдвиг `created_at`); реплика возвращена `up --wait` |
|
||
| Клиент оборвал тело после 256 KiB из 5 MiB | ничего не записано, не `500` | `400` в журнале реплики, намерения нет | — |
|
||
| Тело зависло после 1 KiB | `503` не позже таймаута запроса | `503` за 8,01 с, ничего не записано | слот свободен, следующий upload `201` |
|
||
| 36 ошибочных запросов к вложениям через LB | `4xx` по контракту, ни одного `5xx` | 16 × `400`, 6 × `404`, 4 × `413`, 10 × `415`; в журнале 0 × `5xx` | — |
|
||
| Потерянный ответ: клиент сдался, запись ждёт блокировку чата; повтор тем же ключом (`make retry-check`) | `201` с тем же сообщением, одна копия | реплика жива — повтор через 1,53 с, тот же `id`; реплику убили, пока запрос ждал, — повтор через 1,54 с от соседа, тот же `id`, одна копия (`retry.json`) | потерь и дублей нет |
|
||
| 40 одновременных загрузок по 10 MiB без лимита слотов (×3) | память растёт до лимита | пик 512,3 MiB = лимит cgroup во всех трёх прогонах; `201` — 53, 46 и 80 из 80, остальные `503` по таймауту запроса; `oom_kill` 0 | 67 из этих и следующих `503` оставили невидимые `pending` — см. строку ниже |
|
||
| То же с 3 слотами на воркер (×3) | пик ограничен; ожидание слота укладывается в таймаут запроса | пик 333,7–344,6 MiB, LB ≤ 31 MiB, `oom_kill` 0; `201` — 73, 80 и 80 из 80: в первом прогоне 7 загрузок не уложились в 8 с (ожидание слота плюс запись) и получили `503` во время `PutObject`; p95 4,6–7,6 с | — |
|
||
| Остатки `503` по таймауту после серии памяти | невидимы, сверка видит их свежими, уборка удаляет после grace | `make reconcile`: 1 794 объекта, 1 837 строк, `pending_fresh` 68 (67 от серии и 1 от `s3-outage`), прочих расхождений 0; уборка удалила все 68 (`audit.attachment_discarded reason=abandoned` × 68), после неё сверка: 1 769 объектов = 1 769 строк `ready`, расхождений 0 (`overload-leftovers.txt`) | grace 900 с: намерение `s3-outage` убрано через 903 с, последнее из серии — через 929 с после создания; готовые не тронуты |
|
||
| Трек 2: мусор под префикс, удалённые и перезаписанные объекты, намерения без объекта и с объектом (старше grace) | dry-run находит, `apply` чинит, повтор — 0 | так и есть: 18 найдено, 18 исправлено, повтор 0; строки `ready` не удалены, а в карантине | один проход `apply` (0,11 с); байты 9 повреждённых вложений не восстановить — второго источника нет, карантин закрывает `/content` |
|
||
| Трек 2: объект вложения в карантине вернули в bucket | карантин снят | `healed` 1, `/content` снова отдаёт исходные байты | следующий проход |
|
||
| Трек 2: сверка при остановленном S3 | код `1` за ограниченное время, ничего не меняет | код `1` за 1,63 с, `EndpointConnectionError` в журнале | повторить после возврата S3 |
|
||
| Трек 2: `--apply` подряд во время загрузок через LB | ни одно идущее или готовое вложение не удалено | 3 418 × `201`, все готовы с тем же SHA-256, `lost_ready` 0; 247 раз объект идущей загрузки выглядел объектом без строки и остался | потерь нет |
|
||
|
||
### Нагрузка записи сообщений (историческая серия asyncpg)
|
||
|
||
**Цель.** Проверить, что после переноса исправлений лабы 3 и добавления вложений запись сообщений под нагрузкой
|
||
проходит без ошибок, и снять её профиль: RPS, задержки, CPU и память. Гипотеза о пределе заранее не ставилась.
|
||
|
||
**Методика** (`evidence/load.txt`). Публичный `tests/load.py`: закрытый контур, 64 потока, 8 с, все записи прогона —
|
||
в один новый чат (одна строка `chats` под блокировкой), без повторов; 3 прогона с паузой 15 с, без прогрева
|
||
(регистрация и чат создаются до окна замера). Клиент — одноразовый контейнер в сети `edge` стенда (2 CPU, 512 MiB,
|
||
образ Python API по digest, `tests/` только для чтения, `tcp_tw_reuse`), адрес — `http://lb:8080`, как у k6 в лабе 3.
|
||
Первая попытка с хоста macOS отброшена: `load.py` открывает соединение на каждый запрос, и через прокси Docker
|
||
Desktop диапазон эфемерных портов хоста кончился (≈ 16 000 сокетов `TIME_WAIT`) — 10 045 и 6 398 клиентских ошибок
|
||
соединения при том, что реплики ответили `201` на каждый дошедший запрос (`evidence/load/host-attempt.txt`). На 4-й
|
||
секунде снимается `docker stats` стенда и клиента, после прогона — статусы `request.handled` реплик.
|
||
|
||
**Результаты** (медиана трёх прогонов, `evidence/load/run{1,2,3}.json`):
|
||
|
||
| Прогон | Успешных запросов | Ошибок | RPS | p50 / p95 / p99, мс |
|
||
| --- | ---: | ---: | ---: | --- |
|
||
| 1 | 17 199 | 0 | 2 100 | 25,9 / 68,5 / 96,6 |
|
||
| 2 | 17 386 | 0 | 2 118 | 26,4 / 66,6 / 86,2 |
|
||
| 3 | 17 332 | 0 | 2 106 | 26,6 / 67,0 / 88,4 |
|
||
| медиана | — | 0 из 51 917 | 2 106 | 26,4 / 67,0 / 88,4 |
|
||
|
||
На репликах — только `201` и `200`, ни одного `4xx`/`5xx`. CPU в середине прогона: `api` 89–98 % каждая при лимите
|
||
1 CPU, `postgres` 213–215 % при лимите 2 CPU, `lb` 79–81 %, клиент 102–106 % из 2 CPU, Valkey ≈ 6 %, RustFS < 4 %;
|
||
память `api` 215–218 MiB из 512, `postgres` 165–186 MiB. Разброс RPS между прогонами — 0,9 %.
|
||
|
||
**Вывод.** Запись идёт без ошибок, а упирается в CPU: и реплики, и PostgreSQL работают у своих лимитов, поэтому
|
||
2 100 RPS — пропускная способность этого распределения CPU для записи в один горячий чат, а не предел архитектуры.
|
||
Задержки — только успешных запросов закрытого контура (согласованные пропуски, клиент на той же VM). Загрузки
|
||
вложений нагружают другое — память и сеть, — их пропускная способность снята в эксперименте ниже: 13 загрузок по
|
||
10 MiB в секунду (≈ 130 MiB/s через LB в S3) при 10 и 20 клиентах и 3 слотах на воркер.
|
||
|
||
### Эксперимент уровня «4»: память при одновременных загрузках
|
||
|
||
**Гипотеза** (D3 в `design.md` изменения `add-lab4-upload-resilience`). Без ограничения каждая загрузка 10 MiB в
|
||
полёте держит в воркере несколько копий тела, и пик памяти реплики растёт с числом одновременных загрузок до лимита
|
||
cgroup. С `UPLOAD_CONCURRENCY` слотами на воркер пик ограничен величиной «простой + 2 воркера × слоты × память
|
||
загрузки» и от числа клиентов не зависит; лишние клиенты ждут слота — растёт задержка, а `503` получает только тот,
|
||
чьё ожидание вместе с записью дольше таймаута запроса 8 с.
|
||
|
||
**Методика.** `scripts/upload_memory.py` (цель `make upload-memory`; генератор `scripts/lab4_seed.py`), три прогона
|
||
всей матрицы подряд в `evidence/upload-memory/run{1,2,3}/`. Стенд `compose.yaml`: 2 реплики по 1 CPU и 512 MiB, 2
|
||
воркера; LB 128 MiB; RustFS 1 CPU, 512 MiB. Перед каждой точкой реплики и LB пересоздаются (`memory.peak` cgroup v2
|
||
на ядре Docker Desktop не сбрасывается) и проходит ожидание двух `UP` в LB. Затем c потоков на keep-alive
|
||
соединениях с хоста через LB делают по 2 загрузки одного PNG 1024 × h со случайными пикселями (1 048 276 или
|
||
10 485 256 B). Задержка — от отправки до ответа на клиенте, только по `201`; пик — `memory.peak` каждой реплики и LB
|
||
после точки (включает страничный кэш и память сокетов), простой — `memory.current` перед ней, `oom_kill` — из
|
||
`memory.events`. Конфигурации: 64 слота (фактически без лимита) и 3 слота; 1 и 10 MiB; c = 10, 20, 40; отдельно один
|
||
прогон 3 слота × 10 MiB с порогом `mmap` 32 MiB (`evidence/upload-memory/mmap-32m/`).
|
||
|
||
**Исторические результаты asyncpg** (медиана трёх прогонов, в скобках — разброс;
|
||
колонка LB — максимум трёх, округлённый вверх; простой реплики 112–122 MiB, лимит 512 MiB):
|
||
|
||
| Слоты | Размер | c | Ответы `201` из 2c в трёх прогонах | p50 / p95, мс | Пик реплики, MiB | Макс. пика LB из трёх, MiB |
|
||
| --- | --- | --- | --- | --- | --- | --- |
|
||
| 64 | 1 MiB | 10 / 20 / 40 | все | 111 / 156 · 161 / 214 · 263 / 398 | 176 / 189 / 212 | ≤ 26 |
|
||
| 64 | 10 MiB | 10 | 20, 20, 20 | 842 / 870 | 288 (278–291) | 24 |
|
||
| 64 | 10 MiB | 20 | 40, 40, 40 | 2 663 / 2 906 | 428 (422–503) | 24 |
|
||
| 64 | 10 MiB | 40 | 53, 46, 80 (27 и 34 × `503`) | 5 986 / 6 981 | **512 = лимит** во всех трёх | 26 |
|
||
| 3 | 1 MiB | 10 / 20 / 40 | все | 106 / 157 · 142 / 250 · 230 / 390 | 173 / 180 / 185 | ≤ 28 |
|
||
| 3 | 10 MiB | 10 | 20, 20, 20 | 822 / 1 402 | 297 (281–297) | 24 |
|
||
| 3 | 10 MiB | 20 | 40, 40, 40 | 1 020 / 2 164 | 321 (314–321) | 27 |
|
||
| 3 | 10 MiB | 40 | 73, 80, 80 (7 × `503`) | 3 644 / 7 310 | **334** (334–345) | 31 |
|
||
| 3, `mmap` 32 MiB | 10 MiB | 10 / 20 / 40 | все (один прогон) | 802 / 1 290 · 2 324 / 3 613 · 3 139 / 5 373 | 321 / 356 / 346 | ≤ 31 |
|
||
|
||
**Вывод.** Гипотеза подтверждена, с оговоркой о верхней точке. Без лимита пик 10 MiB-загрузок растёт 288 → 428 →
|
||
512 MiB и при 40 одновременных во всех трёх прогонах упирается в лимит cgroup: реплика отвечает `503` на 27, 34 и 0
|
||
загрузок из 80 (OOM-убийства в этой серии не было, но память — у самого лимита). С тремя слотами пик держится на
|
||
297–345 MiB (не больше 67 % лимита) при росте нагрузки вчетверо. Одна загрузка 10 MiB в полёте стоит ≈ 36 MiB
|
||
((334 − 120) / 6 слотов на реплику): тело, склейка кусков, копии проверки изображения и клиента S3. Цена лимита —
|
||
ожидание слота: при 40 клиентах p95 4,6–7,6 с, у самой границы таймаута запроса 8 с, и в одном прогоне из трёх 7
|
||
загрузок из 80 не уложились в него и получили `503` — слоты защищают память, но очередь за ними ограничена
|
||
таймаутом, и 40 одновременных загрузок по 10 MiB на две реплики — предел этой конфигурации. Для 1 MiB лимит не
|
||
нужен: 173–213 MiB при любой одновременности. Порог `mmap` 32 MiB вместо 128 KiB добавляет к пику 12–35 MiB (321 /
|
||
356 / 346 против 297 / 321 / 334); это один прогон, и при 40 клиентах эффект сравним с разбросом. `503` по таймауту, пришедшиеся на `PutObject` или `UPDATE`, оставили невидимые
|
||
намерения — их судьба в таблице отказов выше.
|
||
|
||
**Ограничения.** Клиент, LB, API и RustFS делят один хост и CPU; клиент работает с хоста через прокси Docker Desktop;
|
||
пик cgroup включает страничный кэш и память сокетов; распределение соединений между воркерами gunicorn
|
||
неравномерно, отсюда разброс p95 до 2,6 раза между прогонами одной точки; порог `mmap` — один прогон.
|
||
|
||
### Трек 5 — трек 2 «Согласованность двух хранилищ (reconciler)»
|
||
|
||
**Что сделано.** Одноразовая команда `python -m messenger.attachments.entrypoints.reconcile` — сервис `reconciler`
|
||
под профилем `reconcile` (`make reconcile ARGS=…`), по умолчанию `--dry-run`, `--apply` исправляет. Один проход
|
||
сливает два отсортированных потока: листинг `ListObjectsV2(Prefix="attachments/", MaxKeys=1000)` (S3 отдаёт ключи в
|
||
байтовом порядке) и keyset-страницы `SELECT … FROM attachments WHERE object_key > $1 ORDER BY object_key LIMIT 1000`
|
||
(`Index Scan` по `attachments_object_key_key`, колонка `COLLATE "C"` — тот же порядок; выбирается страница плюс одна
|
||
строка, чтобы не читать пустую последнюю страницу). Для каждой строки сначала
|
||
идут все объекты с меньшим ключом (объекты без строки), затем пара или её отсутствие. Время O(N), в памяти — по
|
||
странице каждой стороны. Порог «старого» — `now − grace − skew` (по умолчанию 3600 + 60 с, `grace` ≥ 60): по
|
||
`LastModified` объекта и `created_at` строки.
|
||
|
||
| Класс | Условие | `--apply` |
|
||
| --- | --- | --- |
|
||
| `orphan_stale` / `orphan_fresh` | объект без строки старше / моложе порога | повторный `SELECT` по ключу; строки нет → `DeleteObject` / ничего |
|
||
| `missing` | `ready`, объекта нет | `HEAD`: всё ещё 404 → карантин |
|
||
| `size_mismatch` | `ready`, `Size ≠ size_bytes` | `HEAD`: размер всё ещё другой → карантин |
|
||
| `sha_mismatch` | `--deep`: SHA-256 потока ≠ `sha256` | карантин |
|
||
| `pending_stale` / `pending_fresh` | `pending` старше / моложе порога | `FOR UPDATE SKIP LOCKED`, всё ещё `pending` и старая → объект, затем строка / ничего |
|
||
| `quarantined` / `healed` | в карантине и всё ещё расходится / размер снова совпал, и SHA-256 потока объекта равен `sha256` (хешируется и без `--deep`) | ничего / снять карантин |
|
||
|
||
Безопасность: готовая строка и её объект не удаляются никогда — строка уходит в карантин (миграция `0004`:
|
||
`quarantine_reason`, `quarantined_at`), метаданные не меняются, `/content` отвечает `404` без запроса к S3, на строку
|
||
по-прежнему ссылаются сообщения (`message_attachments → attachments ON DELETE RESTRICT`); карантин обратим, но
|
||
снимается только после того, как объект прочитан и его SHA-256 совпал с метаданными. Объект той же длины с другими
|
||
байтами строку из карантина не выпускает. Каждое действие предваряет повторная проверка той стороны, которую оно
|
||
меняет (отказ — `rechecked`). Одновременно идёт один
|
||
проход: `pg_try_advisory_lock(20260004)` на отдельном соединении на всё время прохода, второй отвечает `skipped` с
|
||
кодом `0`. `--deep` читает каждый объект потоком и хеширует кусками по 64 KiB, не больше 8 в полёте. Отчёт — JSON в
|
||
stdout (классы, исправленное, `rechecked`, до 20 примеров id, запросы, время, CPU, пик RSS), журнал — в stderr без
|
||
ключей объектов и кредов. Код `1` — любая ошибка прохода (журнал `reconcile.failed` с типом ошибки, без трассировки)
|
||
или не выполненное действие. Удаление брошенного намерения пишет `audit.attachment_discarded reason=reconcile`, как
|
||
уборка и компенсация API: события UoW идут через `EventBus` в `AttachmentsJournal`, сервис собирает dishka из
|
||
`PlatformProvider` и того же провайдера хранилища, что у API. Ключ S3 у сверки свой (`ListBucket`, `GetObject`,
|
||
`DeleteObject`), ключа API и root-ключей у сервиса нет. `init: true`: `docker stop` идущего прохода завершает его
|
||
сразу, advisory lock снимает PostgreSQL при закрытии соединения.
|
||
|
||
**Гипотезы** записаны в `design.md` изменения `add-lab4-storage-reconciler` в коммите предложения `148868b`, до первого
|
||
прогона. H1 (корректность): слияние находит каждое внедрённое расхождение в его классе, `--apply` исправляет ровно
|
||
найденное исправимое, повторный `--apply` — 0 действий; свежие объекты и намерения, готовые и используемые вложения
|
||
не удаляются, в том числе во время загрузок. H2 (стоимость), дословно из `148868b`: время прохода без `--deep` растёт
|
||
линейно (`t(100k)/t(10k) ≈ 10 ± 30 %`) и определяется числом страниц листинга; запросов листинга и SQL — `⌈N/1000⌉`,
|
||
`HEAD`/`GET` — 0; пик RSS одинаков для 1k и 100k (разница < 10 %); `--deep` на порядок дороже на объект и линеен по
|
||
объёму. История формулировки: после двух прерванных наполнений до 100k (`cost-aborted/`) H2 в `5ca2cdc` была
|
||
переписана на 30k (`t(30k)/t(10k) = 3 ± 30 %`), и прошлая версия отчёта проверяла уже её. Точка 100k в прежней серии не является доказательством SQLAlchemy;
|
||
текущий цикл повторяет исходную H2 из `148868b`. Соотношение 30k/10k приведено как дополнительное.
|
||
|
||
**Методика.**
|
||
|
||
- `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>`, 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>`, а 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 здесь — тесты файлов.
|