Evidence comes from the running stand at a774a2f: upload-faults.txt
with the negative suite through the balancer (36 user errors, no 5xx
in the replica logs) and the compensation, crash, sweep, abort and
stall checks; upload-memory with per-run JSON and a summary for 64
and 3 slots, 1 and 10 MiB and 10, 20 and 40 concurrent uploads plus
the mmap threshold comparison; s3-security.txt with 23 checks; and
regression-level4.txt showing that smoke, persistence, failover of
each replica, the upload failover, S3 outage and abort scenarios, the
limits policy and all 15 stand checks still pass. The lint and own
test log now counts 335 tests. The upload-faults target stamps its
output with the date and commit.
REPORT.md gains rows 4.1 to 4.4 and a regression row, the compensation
and sweep mechanism with its grace period, where each upload limit and
buffer cap applies, the new variables, level 4 failure rows and the
memory experiment with hypothesis, method, results and limits. AGENTS
lists the new targets.
Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V1d3RLHNBBMA6UqBLLJv27
356 lines
53 KiB
Markdown
356 lines
53 KiB
Markdown
# Отчёт — лабораторная 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 собирается из исходников.
|
||
|
||
```sh
|
||
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 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`.
|
||
|
||
Собственные проверки и тулчейн:
|
||
|
||
```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 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`.
|
||
|
||
**Upload: где применяется каждый лимит.** Тело читается потоком, FastAPI его не разбирает.
|
||
|
||
1. `401` — guard конвейера;
|
||
2. объявленный `Content-Length` > `MAX_UPLOAD_BYTES` → `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 через сутки.
|
||
|
||
Платформа: откат транзакции раньше стирал все события команды, а шина не публиковала их при исключении — журнал
|
||
терял удаления из компенсации и уборки. Теперь откат убирает только события своей транзакции.
|
||
|
||
**Скачивание.** Строка `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` |
|
||
| нагрузка (профиль `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, 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») |
|
||
| — | `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` |
|
||
| Трек 2 | — | заполняется изменением трека 2 (reconciler) | — |
|
||
|
||
## Эксперименты и отказы
|
||
|
||
Стенд: 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 (раздел ниже).
|
||
|
||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||
| --- | --- | --- | --- |
|
||
| Остановлена реплика, принявшая 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 |
|
||
|
||
### Эксперимент уровня «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 включает
|
||
страничный кэш и память сокетов; параллельно работали стенды других лаб.
|
||
|
||
## Ограничения и следующие шаги
|
||
|
||
- Один 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`, повтор клиента создаёт новое вложение.
|
||
- Слоты защищают память ценой ожидания: при 40 одновременных загрузках по 10 MiB p95 — 5,3 с, а при ещё большей
|
||
нагрузке хвост очереди упрётся в таймаут запроса 8 с и получит `503`; правильная реакция клиента — повтор позже.
|
||
Пик памяти снят на одном хосте, клиент и стенд делят CPU, по одному прогону на точку.
|
||
- Тело всё ещё собирается в памяти целиком (до ~34 MiB на загрузку 10 MiB с учётом копий проверки и клиента S3):
|
||
потоковая запись в S3 без буфера потребовала бы multipart и проверки изображения после записи.
|
||
- Ранний `413`/`404` до конца тела: клиент, ещё отправляющий 10 MiB, может получить reset вместо ответа; собственные
|
||
тесты проверяют `413` через `Content-Length`.
|
||
- Подтверждено прогонами: всё в таблице доказательств, включая уровень «4». Гипотеза до трека 2: стоимость сверки
|
||
хранилищ растёт линейно с числом объектов.
|