Files
mtusi2026lab4/REPORT.md
T

63 KiB
Raw Blame History

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

  • Автор, группа: Владимирцева, БВТ2301
  • Целевая оценка 5; выбранный трек 5: 2 «Согласованность двух хранилищ»
  • MR: TODO после публикации
  • Использованные источники, библиотеки и помощь ИИ: раздел 8 в конце отчёта

Работа выполнена в объёме требований на оценку «5», трек 2. Метаданные вложений — в PostgreSQL, байты — в приватном bucket SeaweedFS; загрузка отвечает 201 ready только после записи объекта и фиксации строки; скачивание идёт через API и только участникам чата, в том числе после остановки принявшей реплики. Прерванная загрузка и отказ между S3 и БД не оставляют вечных объектов: компенсация в загрузке, уборщик с grace 900 с и сверка bucket и БД с обеих сторон (dry-run, --apply, повтор, предел изменений, свежие и используемые вложения не трогаются). Память загрузок ограничена местами процесса, а не числом клиентов.

Все проверки без нагрузки сняты на машине разработки 23 октября 2026 (раздел 3). Замеры под нагрузкой — профили uploads (уровень 4: пик памяти при ≥ 10 одновременных загрузках) и reconcile (трек 2: стоимость обхода) — сняты на машине замеров по bench/RUNBOOK.md: TODO (Codex) — одна строка с главными числами обеих меток. Гипотезы U1–U4 и H1–H5 записаны в разделе 4 до замеров; итоги — отдельными абзацами под ними.

1. Запуск и демонстрация

Нужны Docker Compose (Docker Desktop), make и uv. API — Python 3.13.15; PostgreSQL 18.6, Valkey 9.1.2, HAProxy 3.4.6, SeaweedFS 4.48. Образы закреплены тегом и digest индекса в Dockerfile и compose.yaml, зависимости — uv.lock и requirements.txt с хешами (aiobotocore 3.10.0, botocore 1.43.117, aiohttp 3.14.5 добавлены в лабе 4).

.env.example дополнен переменными Compose лабы 4: порт API S3 на хосте и семь пустых секретов S3 (административная пара сервера, ключ подписи gRPC шлюза, пары пользователей API и уборщика). make env заполняет все пароли и ключи случайными значениями; существующий .env дополняется недостающими строками, прежние не меняются. Порты хоста меняются аргументами (make env HOST_PORT=8180 S3_HOST_PORT=8434 …).

make install                     # uv sync
make env                         # .env со случайными паролями и ключами S3 (в git нет)
make up                          # postgres, valkey, s3 → migrate, s3-bootstrap → api × 2, cleaner → haproxy
make test                        # публичный smoke через LB (вложение, SHA-256, 404 постороннему)
make s3-check                    # приватность bucket вне API
make attachment-failover         # вложение → стоп принявшей реплики → скачивание через другую
make test-persistence ACTION_SCRIPT=scripts/restart.sh
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
make replicas                    # вернуть остановленную реплику
make reconcile                   # сверка bucket и БД, dry-run (APPLY=1 — исправить)
make test-isolated               # всё выше на отдельном чистом стенде (~2 мин)
make failure-checks              # проверки отказов (~4 мин)

make up ждёт готовности хранилищ, успешного bootstrap S3 и миграций, готовности реплик и HAProxy. Единственная точка входа API — HAProxy на 127.0.0.1:${HOST_PORT} (8080). Bootstrap S3 и миграции — одноразовые сервисы: реплики и уборщик их ждут, повтор — no-op.

Сценарий защиты (README.md):

  1. make test — загрузка фикстуры, сообщение с attachment_ids, скачивание вторым участником и сверка SHA-256 (вывод).
  2. Третий пользователь — 404 на метаданные и байты (attachment-failover); прямой анонимный GET в S3 — 403 с хоста и из сети стенда (s3-check).
  3. make test-persistence ACTION_SCRIPT=scripts/restart.sh — данные, токен и оригинал после рестарта LB, реплик, PostgreSQL, Valkey и S3 (вывод); make attachment-failover [STOP_MODE=kill] — оригинал отдаёт другая реплика.
  4. На API нет локального файла оригинала: docker diff реплик пуст, файловая система только для чтения (стенд). Для 4/5 — проверки отказов и замеры (разделы 3–4).

Остановка: make stop (контейнеры остаются; S3 останавливается плавно ~15 с), make down (контейнеры удаляются, volume pgdata и s3data остаются). Удаление учебных данных — make wipe, только после ввода yes.

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

клиент → 127.0.0.1:HOST_PORT → HAProxy ─┬→ api-1 ─┬→ PostgreSQL (данные, сессии, ключи, метаданные вложений)
                                         └→ api-2 ─┼→ Valkey (кэш карточек чатов)
                                                   └→ S3 SeaweedFS (байты вложений, приватный bucket)
        migrate, s3-bootstrap (один раз на up и на замену, до реплик)
        cleaner (уборка незавершённых загрузок, сверка) → PostgreSQL, S3

Перенесено из лабы 3 без изменений поведения: REST API, слои HTTP → сервисы → хранилище (SQLAlchemy Core + asyncpg), PostgreSQL как источник истины, Basic → Bearer-сессии, кэш карточек в Valkey с обходом при отказе, ≥ 2 взаимозаменяемые реплики за HAProxy, X-Instance-Id, обязательный Idempotency-Key, цепочка таймаутов, поочерёдная замена, ранний обработчик SIGTERM.

Изменено в лабе 4:

Что Как
S3 SeaweedFS 4.48 одним процессом weed server, служебные серверы на loopback контейнера, volume s3data; приватный bucket и пользователи создаёт одноразовый s3-bootstrap
Вложения POST /chats/{id}/attachments, GET /attachments/{id}, GET /attachments/{id}/content; таблицы attachments, message_attachments (ревизия 0003, expand)
Сообщения attachment_ids (до 10, ready, из того же чата), пустой текст — только с вложением; хэш тела ключа включает attachment_ids, только если список не пуст
Согласованность строка pending до PUT, ready после; компенсация при известном сбое; уборщик cleaner (отдельный процесс) с grace 900 с
Память места загрузок на процесс (4 + очередь 16, ожидание 5 с → 429), срок тела 30 с, одна копия тела, MALLOC_MMAP_THRESHOLD_, буферы сокетов реплики и LB
Трек 2 сверка bucket и БД в процессе уборщика: разовая (make reconcile) и плановая раз в час
LB путь загрузки — timeout server 40 с, буферы tune.sndbuf.server / tune.rcvbuf.client, дренаж замены 90 с

S3: выбор и приватность

Почему SeaweedFS. Из трёх серверов skeleton он запускается одним процессом и одним образом с закреплённым digest для amd64 и arm64, а пользователей и политики настраивает weed shell того же образа (bootstrap без отдельного клиента и без консоли). MinIO и RustFS в этой работе не сравнивались.

Приватность с первой секунды: административная пара задаётся серверу окружением — учётная запись есть до первого запроса, анонимного окна нет. Master, volume и filer слушают только 127.0.0.1 контейнера; в сеть выходят API S3 (8333) и gRPC шлюза (18333, закрыт ключом подписи WEED_JWT_FILER_SIGNING_KEY, без него gRPC принял бы учётную запись администратора от любого контейнера сети). На хост публикуется только API S3 и только на loopback. Консоли нет.

s3-bootstrap (одноразовый, network_mode: service:s3) создаёт bucket, ставит анонимному доступу none, создаёт пользователей и политики: API — чтение, запись и удаление объектов своего bucket; уборщик — чтение, удаление и список только с префиксом <база>/attachments/. Затем сам проверяет приватность обоими ключами и без ключа. Повтор сводит состояние к .env (bootstrap). Административная пара — только у сервера, ключи каждого пользователя — только у своего процесса (стенд).

Вложения: модель и путь загрузки

Ключ объекта назначает сервер: <имя базы>/attachments/<id>/original (id — UUID v4 сервера); filename хранится только для показа (1–255 code points, без /, \ и управляющих символов). Байтов в БД нет: строка хранит размер, SHA-256, тип, статус, ключ, lost_at.

Загрузка (AttachmentService.upload), до чтения тела и без места: 401 (middleware) → 400 (chat_id, filename, строгий UTF-8) → 404 (не участник) → 415 (Content-Type не PNG/JPEG) → 413 (Content-Length больше 10 MiB). Затем место загрузки (иначе очередь до 5 с и 429 с Retry-After), тело потоком в один BytesIO со счётчиком (больше 10 MiB — 413 сразу) и сроком 30 с (400); структурная проверка PNG/JPEG без декодирования пикселей: чанки и CRC PNG, маркеры JPEG до SOS и EOI, размеры из заголовка до любой распаковки (больше 40 млн пикселей — 413, повреждено, не тот формат, MIME не совпал с содержимым — 415). Потом строка pending → PUT → ready → 201.

Когда 201 честен: только после того, как S3 подтвердил PUT и строка ready зафиксирована — тогда оригинал есть и его метаданные видит любая реплика. Скачивание — потоком через API (блоки 64 KiB из S3), Content-Type оригинала, nosniff; адрес и ключи S3 клиенту не отдаются, redirect нет. Чужое, неизвестное, незавершённое и потерянное — 404 одинаково.

Согласованность БД и S3 (уровень 4)

Порядок записи — строка раньше объекта: у любого объекта есть строка, по которой его найдёт уборщик.

Сбой Что происходит Остаток
до строки (тело, проверка, место) ответ 4xx/429/503, в S3 ничего нет нет
PUT не прошёл (S3 недоступен, срок 5 с) 503 строка pending (и, возможно, поздний объект) — уборщик через grace
сбой ready до отправки COMMIT компенсация: объект удаляется до ответа, 503 строка pending — уборщик
сбой на самом COMMIT исход неизвестен (OutcomeUnknown): объект не трогается, 503 ready (тогда всё цело) или pending — уборщик
процесс убит между PUT и ready ответа нет строка pending с объектом — уборщик

Уборщик — отдельный сервис cleaner (python -m src.cleaner), а не задача реплик: N реплик были бы N уборщиками, а остановка реплики обрывала бы проход. Раз в 60 с он берёт строки pending старше CLEANER_GRACE (900 с) по частичному индексу и убирает каждую в два шага под FOR UPDATE SKIP LOCKED: пометка (updated_at, commit), затем удаление объекта и строки в одной транзакции (объект раньше строки: упал S3 — строка остаётся, повтор безопасен). Помеченную строку загрузка в ready уже не переведёт (UPDATE … WHERE updated_at = created_at), а ответит 503 и удалит объект. Grace безопасен: живая загрузка держит строку pending не дольше 2 × (DB_OPERATION_TIMEOUT 6 + закрытие 2) + S3_TIMEOUT 5 = 21 с; уборщик с grace не больше этой границы не стартует (код 2). ready уборщик не трогает никогда.

Память и сроки загрузки

  • Места загрузок процесса (UPLOAD_MAX_CONCURRENT 4): тело читается только на месте. Без места — очередь (UPLOAD_MAX_WAITING 16) не дольше UPLOAD_WAIT_TIMEOUT 5 с, затем 429 rate_limited с Retry-After: 1; тело ожидающего не читается и копится только в буфере сокета.
  • Одна копия тела: BytesIO → getvalue() (bytes над тем же буфером) для проверки и SHA-256 → ссылка удаляется → PUT отправляет тот же буфер. MALLOC_MMAP_THRESHOLD_=131072: буфер больше 128 KiB — свой mmap, после ответа возвращается ядру.
  • Буферы: приём сокетов реплики до 512 KiB (net.ipv4.tcp_rmem), LB — tune.sndbuf.server 256 KiB к реплике, tune.rcvbuf.client 128 KiB от клиента: ожидающая загрузка не держит мегабайты в ядре.
  • Сроки: тело — 30 с с момента места (иначе 400, место освобождается); timeout server LB пути загрузки — 40 с (ожидание 5 + тело 30 + запись); вызов S3 — 5 с целиком и на каждый блок (asyncio.timeout; read_timeout aiohttp выключен: он переживал ответ и портил соединение в пуле); повторов S3 нет.

Ожидаемая граница памяти реплики «с лимитом»: 4 тела по 10 MiB + базовая память процесса (~100 MiB) + буферы ожидающих (≤ 16 × 0,5 MiB) — далеко ниже лимита 512 MiB. Проверка — профиль uploads (раздел 4.2).

Сверка bucket и БД (трек 2)

Уборщик видит только строки pending. Объект без строки (PUT пережил свою строку, объект мимо API) и строку ready без объекта (удалён мимо API) находит сверка — в том же процессе: разовая (make reconcile, по умолчанию dry-run) и плановая (при старте и раз в RECONCILE_INTERVAL 3600 с, batch, с исправлением).

Класс Что найдено Действие с --apply
orphan_object объект старше grace, строки нет, ссылок нет объект удаляется
stale_pending строка pending старше grace шаг уборщика (пометка, объект и строка)
missing_object строка ready, объекта нет, bucket на месте оригинал помечается потерянным (lost_at): скачивание 404, метаданные 200
size_mismatch размер объекта ≠ строке помечается, объект не трогается
checksum_mismatch только --deep: SHA-256 содержимого другой помечается
restored_object помеченный оригинал снова на месте с тем же SHA-256 пометка снимается
foreign_object ключ, которого API не пишет; строка с ключом вне префикса только отчёт, код 3

Безопасность. Удаляется только объект без строки и зависшая загрузка; строки ready, объект, на который ссылается строка, свежее (моложе grace по LastModified объекта и created_at строки) и чужой ключ — никогда. Перед каждым действием — перепроверка в БД и HEAD; «объекта нет» — только после проверки, что bucket на месте (иначе удалённый bucket пометил бы все оригиналы). Больше RECONCILE_MAX_CHANGES (100) изменений — ни одного и код 3: массовое «расхождение» скорее значит подменённую базу или bucket. Сигнал остановки — перед каждым вызовом хранилища. Коды разового прохода: 0 — расхождений нет, 3 — остались, 1 — прервана, 2 — конфигурация.

Стоимость обхода — в итоговой строке каждого прохода (reconcile pass finished …): вызовы S3 по операциям, ключи списка, прочитанные байты, запросы к PostgreSQL, длительность шагов, CPU прохода, пик RSS процесса. Стратегии: batch — страница списка (1000 ключей) и одна выборка строк на страницу, ключи в памяти; head — выборка на объект и HEAD на строку, без множества ключей; --deep — GET и SHA-256 каждого согласованного оригинала. Предел скорости RECONCILE_RATE (2000 объектов S3/с) — пауза после каждого вызова S3. Замер стоимости — профиль reconcile (раздел 4.3).

Лимиты, пулы, порты и сроки

Сервис CPU Память Порт на хосте Секреты
api × 2 1 512 МиБ нет пароли PostgreSQL и Valkey, ключи пользователя API S3
cleaner 0,25 256 МиБ нет пароль PostgreSQL, ключи пользователя уборщика S3
haproxy 1 256 МиБ 127.0.0.1:HOST_PORT нет
postgres 2 1 ГиБ 127.0.0.1:POSTGRES_HOST_PORT (для make run) свой
valkey 0,5 128 МиБ 127.0.0.1:VALKEY_HOST_PORT (для make run) свой
s3 1 512 МиБ 127.0.0.1:S3_HOST_PORT, только API S3 административная пара, ключ подписи
s3-bootstrap 0,5 128 МиБ нет ключ подписи, ключи обоих пользователей
migrate 0,5 256 МиБ нет пароль PostgreSQL

Соединения PostgreSQL: 2 × 15 + migrate + cleaner = 32 ≤ 100, на пике замены 47. Сроки, которые меняются только вместе: обнаружение отказа реплики ≤ 6,5 с (как в лабе 3); timeout server 10 с, пути загрузки — 40 с; S3_TIMEOUT 5 с; граница живой загрузки 21 с < CLEANER_GRACE 900 с; ROLLOUT_DRAIN_TIMEOUT 90 с — дренаж замены дольше самой долгой загрузки.

Миграции и совместимость

0003 — только расширение: две новые таблицы, частичный индекс pending, lost_at; ck_messages_text_length ослаблен до char_length(text) <= 4000 (пустой текст — только с вложением, это правило API) и добавлен NOT VALID — старые строки удовлетворяют прежнему, более строгому условию, полный обход messages под блокировкой не нужен. Ревизия начинается с SET LOCAL lock_timeout = '2s'. Реплики лабы 3 работают на схеме 0003: новых обязательных колонок в их таблицах нет (migrations).

Конфигурация: логические имена .env.example

Имя skeleton Реализация
APP_HOST, APP_PORT те же имена; в образе 0.0.0.0:8080; на хосте — HOST_PORT у HAProxy
APP_ENV не используется: режим один
SESSION_TTL_SECONDS, IDEMPOTENCY_TTL_SECONDS, API_REPLICAS те же имена
DATABASE_URL_FILE, CACHE_URL_FILE не используются: DB_* и CACHE_*, пароли из .env через environment compose
SESSION_STORE postgres
S3_ENDPOINT, S3_REGION, S3_BUCKET те же имена; контейнерам compose задаёт http://s3:8333, make run — 127.0.0.1:S3_HOST_PORT
S3_ACCESS_KEY_ID_FILE, S3_SECRET_ACCESS_KEY_FILE не используются: S3_ACCESS_KEY_ID / S3_SECRET_ACCESS_KEY каждому процессу — ключи своего пользователя (S3_API_* у реплик, S3_CLEANER_* у уборщика из .env)
MAX_UPLOAD_BYTES, MAX_IMAGE_PIXELS не используются: лимиты контракта (10 MiB, 40 млн пикселей) — константы src/constants.py, окружение их не меняет (проверяет стенд отказов)

Новые настройки: S3_TIMEOUT, S3_CONNECT_TIMEOUT, S3_MAX_CONNECTIONS, UPLOAD_*, CLEANER_*, RECONCILE_*. Полная таблица — src/AGENTS.md.

Согласования с преподавателем

Дата Договорённость Где учтено
2026-10-20 «Пустой текст» сообщения — и "", и строка только из пробельных символов. " " с ≥ 1 вложением — 201, без вложений — 400 CreateMessage (src/api/schemas.py), тесты test_attachments.py

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

Код всех файлов ниже — src_sha256 bc10d566e2f63173541445a2f6273b967447e13e5dd7f1fb76900934e5692cbe (проект не под git), машина разработки: Apple M3 Pro, macOS 26.6.2, Docker 29.9.2.

Критерий Результат Доказательство
Возможности лабы 3 сохранены smoke, свои тесты лаб 1–3, test-failover, test-persistence на отдельном стенде с двумя репликами test-isolated
S3 в общем стенде; метаданные в PostgreSQL, байты в приватном bucket, не в БД и не на диске API 35 оригиналов (14 MB) в S3, таблица метаданных 96 kB; docker diff реплик пуст стенд, migrations
Публичный smoke: 201 ready, оригинал побайтно, checksum, 404 постороннему PASS: lab4 public API scenario smoke
Реальные PNG/JPEG ≤ 10 MiB и ≤ 40 млн пикселей; MIME по содержимому; опасный filename; лимит до чтения/декодирования ровно 10 MiB — 201; 10 MiB + 1 (заявлено и потоком) — 413; бомба PNG, огромные размеры — 413 без декодирования; text, webp, обрезка, порча CRC, MIME не совпал — 415; /, \, NUL, Cc, не-UTF-8 — 400 тесты через LB (test_attachments.py)
Upload → остановка обслужившей реплики → download через другую stop и kill: 200 от другой реплики через 0,53 с, тот же SHA-256, посторонний — 404 attachment-failover
Restart с volumes сохраняет метаданные и оригинал make test-persistence: PASS, рестарт LB, реплик, PostgreSQL, Valkey, S3 persistence
Тесты: большой файл, повреждённое изображение, подмена MIME, чужое attachment_id, вложение другого чата; 4xx не превращаются в 500 130 passed через LB, 46 из них — вложения тесты через LB
Прерывание и отказ между S3 и БД не оставляют вечных объектов сбой ready — объект удалён сразу, строка — уборщиком через 25,8 с (grace 25 с стенда); API убит между PUT и ready — уборщик убрал строку и объект; 24 passed failure-checks
Лимиты и сроки не дают одной загрузке занять неограниченную RAM полная очередь — 429 за 0,005 с с Retry-After: 1; медленное тело — 400 по сроку, место освобождено failure-checks
Недоступность S3 остановлен — 503 за 0,04 с; заморожен — 503 за 5,01 с; текст и готовность работают failure-checks
Эксперимент ≥ 10 одновременных загрузок с пиком памяти 48 прогонов; 10 MiB, C = 10/20/40: с лимитом 154,1/155,9/159,8 MiB, без лимита 213,6/319,5/509,6 MiB; OOM только без лимита при C = 40 (3/3); пики по выборкам 0,2 с uploads/baseline
Bootstrap идемпотентен; отдельные ключи с ограниченными правами первый запуск — created, повторы — exists, код 0 bootstrap, стенд
Консоль не в общей сети; проверка private bucket вне API 63 проверки, 0 нарушений; из сети открыты только 8333 и 18333 s3-check
Трек 2: обнаружение и безопасное исправление с обеих сторон, dry-run и повтор 5 классов внесены и найдены dry-run без изменений; --apply исправил безопасное, чужой объект оставил (код 3); повтор — только он; вернувшийся оригинал снял пометку (код 0); на согласованном рабочем стенде все виды прохода — 0 находок failure-checks, рабочий стенд
Трек 2: свежие и используемые вложения не удаляются --apply трижды во время 2 023 загрузок и отправок 4 клиентов — ни одно 201 не удалено и не помечено; строка без объекта, на которую ссылается сообщение, только помечена; глубокая не читает вложения моложе grace failure-checks, рабочий стенд
Трек 2: стоимость обхода TODO (Codex): мс и запросы на 1 000 объектов по стратегиям, p95 фона TODO (Codex): evidence/reconcile/baseline/summary.md

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

4.1. Проверки отказов без нагрузки

make failure-checks FAULT_ARGS=-rP — 24 passed за 3 мин 38 с на отдельном стенде (S3 с bootstrap, три процесса API: обычный, «тесный» и «узкий по загрузкам» — 1 место, очередь 1, ожидание 1 с, срок тела 2 с; уборщик с grace 25 с и проходом раз в секунду). Машина разработки, 23 октября 2026 (вывод).

Воздействие Что ожидали Что наблюдали Восстановление / потеря данных
S3 остановлен, загрузка 503 быстро, без деталей S3; текст и готовность работают 503 за 0,040 с; текст 201, /health/ready 200 строка pending остаётся уборщику; тот же файл после возврата — 201
S3 заморожен, загрузка и скачивание 503 не дольше срока вызова S3 (5 с) 503 за 5,01 с и 5,01 с; метаданные и ссылка в сообщении работают после разморозки — тот же оригинал
Объект записан, сбой перевода в ready (триггер в БД) 503, компенсация удаляет объект, строку убирает уборщик 503; объектов столько же, сколько до загрузки; строка убрана через 25,8 с объектов без строки нет
Процесс API убит между PUT и ready 201 нет; строку и объект убирает уборщик после grace клиент — обрыв соединения; строка и объект убраны через 19,3 с после проверки объектов без строки нет
Место занято и очередь полна 429 сразу с Retry-After; ожидавший — 429 по сроку ожидания 429 за 0,005 с, Retry-After: 1; ожидавший — 429; занявший место — 201 у отказов нет ни строки, ни объекта
Тело не приходит дольше срока 400, место освобождается 400 за 3,01 с (срок тела 2 с + отправка половины) следующая загрузка — 201
Расхождения с обеих сторон (5 классов) dry-run находит и ничего не меняет; --apply — безопасное; чужое — только отчёт dry-run — все 5, объектов и строк столько же; --apply — код 3 (чужой объект); повтор — только чужой; возврат оригинала — пометка снята, код 0 потерянный оригинал: метаданные 200, байты 404, сообщение со ссылкой живо
--apply во время загрузок 4 клиентов ни одно подтверждённое вложение не тронуто 3 прохода с кодом 0 за 15 с, 2 023 загрузки и отправки без ошибок каждое 201 скачивается с тем же SHA-256
PostgreSQL остановлен / заморожен, пул из 1 (лаба 2–3) 503 быстро / за срок операции 503 за 0,008 с; заморожен — 4,01 с, второй запрос 1,01 с (ожидание пула) —
Valkey остановлен / заморожен (лаба 2) ответы из PostgreSQL, одна задержка ≤ 0,2 с 200 за 0,012 с; заморозка — +0,205 с у первого чтения кэш возвращается без рестарта API

Остальные 11 проверок печатей времени не дают, только утверждения: срок сессии и отсутствие продления, токен при остановленной БД — 503, откаты составных операций (чат, ключ идемпотентности), 503 не сохраняется результатом ключа, срок ключа, готовность без Valkey и без S3, восстановление кэша после FLUSHALL и возврата Valkey.

4.2. Память при одновременных загрузках (уровень 4)

Методика (make bench-uploads, профиль uploads, bench/AGENTS.md): свой проект compose vlad-bench — LB, одна реплика API 1 CPU / 512 МиБ без swap (OOM-kill виден, а не прячется в swap), PostgreSQL, Valkey и S3 с лимитами рабочего стенда; генератор на stdlib внутри сети стенда (2 CPU / 1 ГиБ), только через LB. Тела — настоящие PNG из шума (loadgen.py body, зерно 20261023): ~1 MiB и 10 485 256 байт (≤ лимита контракта). Варианты: «с лимитом» — значения по умолчанию (4 места, очередь 16, ожидание 5 с); «без лимита» — UPLOAD_MAX_CONCURRENT=1000, UPLOAD_MAX_WAITING=0 (override только этого варианта). Прогон — вариант × тело × C ∈ {1, 10, 20, 40} × 3 повтора, порядок — круги с перестановкой по зерну; на каждый прогон — новый S3 на пустом volume и новая реплика, разогревающая загрузка, затем сброс memory.peak cgroup реплики, S3 и LB своим дескриптором (ядро ≥ 6.12) и закрытая модель: C клиентов шлют загрузку за загрузкой 3 с разгона + 20 с окна (на 429 — пауза Retry-After, на прочие ошибки — 1 с). Пик окна — memory.peak через тот же дескриптор; раз в 0,2 с — memory.current, anon, sock, oom_kill. Загрузок/с и перцентили — по загрузкам, начатым в окне.

Гипотезы (записаны до замеров). Пороги — константы U* в bench/uploads.py, вердикт считает summary.md.

  • U1 — память «с лимитом» ограничена местами, а не клиентами. При теле 10 MiB и C = 10, 20, 40 пик окна реплики ≤ половины лимита (256 MiB), рост пика сверх C = 10 — не больше 1 MiB на клиента, OOM и 5xx нет ни в одном прогоне «с лимитом». Основание: на местах не больше 4 тел (≈ 40 MiB) поверх ~100 MiB процесса, ожидающие держат только буфер сокета (≤ 512 KiB), остальные получают 429.
  • U2 — без лимита память растёт с клиентами. При C = 10 рост пика — не меньше 0,8 тела на клиента; при C = 40 × 10 MiB — OOM-kill или пик ≥ 90 % лимита. Основание: каждая одновременная загрузка держит своё тело.
  • U3 — лимит не стоит пропускной способности. Загрузок 201 в секунду при C ≥ 10 у «с лимитом» — не меньше 90 % «без лимита» на тех же C и теле, пока у того нет OOM. Основание: предел задают CPU одного процесса и S3 (1 CPU, запись шлюза до 64 МБ одновременно), а не число параллельных тел.
  • U4 — граница очереди. У «с лимитом» при C ≤ 20 (4 места + 16 в очереди) 429 нет, при C = 40 — есть в каждом прогоне. Основание: ожидание места при 16 в очереди — около 4 оборотов по ~0,3–0,5 с, меньше 5 с срока ожидания.

Результаты. Полная сводка и исходные данные: 48 прогонов, по 3 повтора в каждой ячейке; предупреждений о хосте нет, выгрузки страниц и сна за опыт не было. Значения ниже перенесены из сводки без пересчёта: медиана (min–max). На этой машине все пики окна получены выборками раз в 0,2 с (peak_sampled), поскольку Linux 6.10.14 не поддерживает сброс memory.peak. Это наблюдаемые максимумы, которые могут пропускать более короткие всплески.

Вариант Тело C Пик старта, MiB До окна, MiB Пик, MiB anon, MiB sock, MiB OOM 201 429 5xx прочие Загрузок/с p50, мс p95, мс S3 пик / anon, MiB LB пик, MiB Пометки
с лимитом 10mib 1 170.7 (159.5–172.7) 97.2 (97.2–97.2) 114.4 (113.4–114.6) 106.1 (105.6–106.2) 4.1 (4.1–4.1) 0/3 217 (216–225) 0 (0–0) 0 (0–0) 0 (0–0) 10.85 (10.80–11.25) 72 (72–73) 241 (240–247) 515.4 (514.9–516.1) / 238.4 (238.1–239.4) 20.0 (19.9–20.6) peak_sampled
с лимитом 10mib 10 171.7 (171.5–172.0) 97.2 (97.2–97.2) 154.1 (153.4–155.0) 138.8 (137.6–139.0) 12.9 (11.4–12.9) 0/3 245 (244–249) 0 (0–0) 0 (0–0) 0 (0–0) 12.25 (12.20–12.45) 797 (784–797) 1015 (998–1047) 515.5 (512.5–517.6) / 288.7 (288.4–292.4) 25.4 (25.3–26.0) peak_sampled
с лимитом 10mib 20 171.7 (171.3–172.3) 97.2 (97.2–97.2) 155.9 (153.9–159.1) 139.9 (138.8–140.0) 12.1 (11.8–14.1) 0/3 251 (244–252) 0 (0–0) 0 (0–0) 0 (0–0) 12.55 (12.20–12.60) 1605 (1596–1622) 1841 (1770–1886) 513.5 (513.0–513.9) / 287.0 (284.3–300.2) 32.1 (30.9–32.9) peak_sampled
с лимитом 10mib 40 171.7 (171.5–172.0) 97.2 (97.2–97.9) 159.8 (156.1–161.6) 141.0 (140.3–141.6) 14.6 (11.4–16.6) 0/3 245 (238–248) 400 (400–400) 0 (0–0) 0 (0–0) 12.25 (11.90–12.40) 1621 (1604–1686) 1876 (1774–1957) 512.5 (512.4–514.2) / 294.8 (281.5–296.7) 41.7 (40.2–43.0) peak_sampled
с лимитом 1mib 1 171.5 (159.9–172.4) 97.3 (97.3–97.3) 121.4 (121.4–121.7) 116.4 (116.3–116.8) 0.9 (0.9–0.9) 0/3 1599 (1590–1621) 0 (0–0) 0 (0–0) 0 (0–0) 79.95 (79.50–81.05) 12 (12–12) 14 (13–14) 512.7 (512.0–512.8) / 219.3 (218.0–221.7) 20.1 (20.1–20.2) peak_sampled
с лимитом 1mib 10 172.2 (172.0–172.4) 97.3 (97.3–97.3) 147.2 (146.8–147.3) 141.0 (140.9–141.2) 2.7 (2.1–3.4) 0/3 2920 (2915–2922) 0 (0–0) 0 (0–0) 0 (0–0) 146.00 (145.75–146.10) 68 (68–69) 93 (92–93) 514.0 (512.3–514.1) / 227.2 (226.3–228.7) 24.2 (23.6–24.5) peak_sampled
с лимитом 1mib 20 171.9 (171.8–172.8) 97.3 (97.2–97.3) 150.2 (148.6–150.3) 142.6 (140.9–142.9) 4.1 (3.1–4.4) 0/3 2894 (2801–2910) 0 (0–0) 0 (0–0) 0 (0–0) 144.70 (140.05–145.50) 135 (134–139) 165 (159–172) 512.9 (512.6–513.9) / 227.0 (224.4–233.1) 29.9 (28.6–30.4) peak_sampled
с лимитом 1mib 40 171.8 (160.0–172.5) 97.3 (97.3–97.3) 149.2 (148.7–149.9) 141.7 (141.1–142.3) 4.0 (3.7–4.1) 0/3 2879 (2843–2899) 400 (400–407) 0 (0–0) 0 (0–0) 143.95 (142.15–144.95) 137 (137–139) 165 (162–167) 512.6 (512.1–512.8) / 234.8 (234.3–234.9) 37.1 (37.1–41.3) peak_sampled
без лимита 10mib 1 172.0 (171.7–172.4) 97.2 (97.2–97.2) 113.1 (112.8–113.9) 105.8 (105.7–105.8) 4.1 (4.0–4.1) 0/3 222 (215–224) 0 (0–0) 0 (0–0) 0 (0–0) 11.10 (10.75–11.20) 73 (73–74) 239 (235–241) 515.1 (514.0–515.9) / 237.7 (236.8–238.6) 20.0 (19.5–20.4) peak_sampled
без лимита 10mib 10 171.6 (171.1–171.7) 97.2 (97.2–97.2) 213.6 (213.4–218.6) 198.3 (197.6–199.0) 16.3 (11.1–18.1) 0/3 218 (217–222) 0 (0–0) 0 (0–0) 0 (0–0) 10.90 (10.85–11.10) 892 (888–905) 1261 (1261–1292) 512.3 (512.0–514.5) / 362.6 (347.8–388.6) 23.4 (21.6–24.4) peak_sampled
без лимита 10mib 20 171.5 (159.3–171.8) 97.2 (97.2–97.2) 319.5 (317.9–323.9) 300.2 (300.0–301.5) 18.1 (17.9–18.6) 0/3 218 (217–224) 0 (0–0) 0 (0–0) 0 (0–0) 10.90 (10.85–11.20) 1825 (1808–1828) 2224 (2136–2252) 513.3 (512.1–514.0) / 359.5 (346.7–399.4) 31.0 (30.8–31.6) peak_sampled
без лимита 10mib 40 171.9 (160.0–172.5) 97.2 (97.2–97.2) 509.6 (508.7–510.7) 503.6 (501.7–504.0) 18.6 (18.5–18.8) 3/3 0 (0–0) 0 (0–0) 720 (720–720) 0 (0–0) 0.00 (0.00–0.00) — — 394.2 (352.5–488.4) / 234.4 (227.3–290.7) 44.7 (44.0–46.9) oom peak_sampled
без лимита 1mib 1 171.8 (171.0–172.4) 97.3 (97.3–97.3) 121.8 (121.6–121.9) 116.7 (116.5–116.7) 0.8 (0.8–0.9) 0/3 1609 (1598–1613) 0 (0–0) 0 (0–0) 0 (0–0) 80.45 (79.90–80.65) 12 (12–12) 13 (13–13) 512.6 (512.5–512.7) / 214.5 (189.8–228.3) 20.0 (19.7–20.2) peak_sampled
без лимита 1mib 10 172.1 (170.4–172.2) 97.3 (97.3–97.3) 154.6 (153.8–155.2) 148.2 (148.0–149.1) 3.3 (1.7–4.1) 0/3 2977 (2883–2982) 0 (0–0) 0 (0–0) 0 (0–0) 148.85 (144.15–149.10) 69 (67–69) 99 (98–101) 512.7 (512.5–513.3) / 232.8 (229.2–245.7) 23.6 (20.3–25.1) peak_sampled
без лимита 1mib 20 170.4 (159.8–171.9) 97.3 (97.3–97.3) 156.8 (155.7–157.6) 149.9 (149.7–151.0) 3.9 (3.2–5.1) 0/3 2467 (2413–2530) 0 (0–0) 0 (0–0) 0 (0–0) 123.35 (120.65–126.50) 157 (155–160) 224 (210–226) 514.7 (512.0–514.7) / 232.6 (223.5–232.8) 27.6 (26.6–29.1) peak_sampled
без лимита 1mib 40 172.2 (159.1–172.4) 97.3 (97.3–97.3) 188.6 (184.7–189.0) 181.2 (178.9–182.8) 5.2 (4.8–5.5) 0/3 2892 (2811–2921) 0 (0–0) 0 (0–0) 0 (0–0) 144.60 (140.55–146.05) 273 (270–279) 342 (335–388) 512.5 (512.5–512.7) / 226.6 (222.1–235.0) 33.2 (30.0–34.1) peak_sampled

Итог U1. Сводка: подтверждена — пик, MiB: C=10 154.1, C=20 155.9, C=40 159.8 (половина лимита 256); сверх C=10, MiB на клиента: C=20 0.18, C=40 0.19; OOM 0, 5xx 0 во всех прогонах «с лимитом».

Четыре места допускают чтение только четырёх тел одновременно; ожидающие клиенты занимают буферы сокетов, а не полные тела. Освобождение BytesIO с MALLOC_MMAP_THRESHOLD_=131072 возвращает большой буфер ядру. Это согласуется с почти постоянным наблюдаемым пиком при росте C. На ядре этой машины сброс memory.peak недоступен: вывод о численной границе пика относится к выборкам раз в 0,2 с; короткие промежуточные пики этим опытом не исключены.

Итог U2. Сводка: подтверждена — C=10: 1.16 тела на клиента (порог 0.8); C=40: OOM 3/3, пик 509.6 (508.7–510.7) MiB (90 % лимита 460.8).

Каждая одновременно читаемая загрузка держит собственный буфер; при увеличении C растут тела, служебная память и буферы сокетов. На 40 больших тел лимита контейнера 512 MiB не хватило во всех трёх повторах. OOM подтверждён флагом State.OOMKilled и кодом выхода 137 независимо от дискретности измерения памяти. Поле oom_kill в выборках осталось нулевым: после гибели контейнера его cgroup уже недоступна сэмплеру.

Итог U3. Сводка: подтверждена — 10mib C=10: 12.25 / 10.90 = 112%; 10mib C=20: 12.55 / 10.90 = 115%; 1mib C=10: 146.00 / 148.85 = 98%; 1mib C=20: 144.70 / 123.35 = 117%; 1mib C=40: 143.95 / 144.60 = 100%.

Во всех сравнимых ячейках медиана успешных загрузок с лимитом составляет не меньше 98 % варианта без лимита. Для 10 MiB она выше на 12–15 %: дополнительные одновременные тела увеличили память, но не дали больше успешных загрузок через тот же процесс API и S3. Ячейка без лимита с OOM в это сравнение не включается.

Итог U4. Сводка: подтверждена — 429 при C ≤ 20: 0 в 18 прогонах; при C = 40: 400, 400, 400, 400, 400, 407.

При C ≤ 20 все клиенты помещались в четыре места и очередь из 16, ожидание не превысило 5 с. При C = 40 лишние клиенты получали 429 с Retry-After и повторяли запросы; ни в одном прогоне с лимитом перегрузка не превратилась в 5xx.

4.3. Стоимость сверки (трек 2)

Методика (make bench-reconcile, профиль reconcile): стенд vlad-bench с LB, двумя репликами, PostgreSQL, Valkey и S3 рабочего стенда. Набор — мимо API (исключение чёрного ящика только этого профиля): метаданные COPY attachments FROM STDIN, объекты — PUT загрузчиком bench/fill_objects.py ключами пользователя API. Объект i: id и содержимое — из SHA-256 <зерно>:<i>, класс — i mod 400 (по 0,25 %: объект без строки, строка без объекта, другой размер, зависшая загрузка), строки — сутки назад. Проход — разовый cleaner reconcile … (docker compose run, grace 30 с, лимит CPU ячейки), через grace + 2 с после последнего PUT; результат — его итоговая строка. Каждый проход сверяет найденное с моделью набора (иначе профиль падает): это и проверка корректности сверки на 100 000 объектов. Этапы: A — 1 000 × 1 MiB (batch, deep, deep-fast); B — 10 000 × 4 KiB (batch, head, deep); C — тот же стенд + 20 000 (batch, head); D — + 70 000 (batch и под фоновой нагрузкой: load-stand — предел 2000/с и 0,25 CPU, load-unlimited — без предела, load-fast — без предела и 1 CPU, load-fast-limited — с пределом и 1 CPU); E — свежий стенд, 10 000 согласованных + 1 000 строк без объекта (batch и refuse — --apply --max-changes 100). 3 повтора кругами. Фоновая нагрузка — 200 скачиваний, 50 записей и 50 чтений истории в секунду через LB, тихие окна 20 с до и после прохода. CPU S3, PostgreSQL и реплик за окно прохода — сэмплер cgroup раз в 0,5 с.

Гипотезы (записаны до замеров). Пороги — константы H*_ в bench/reconcile.py, вердикт считает summary.md.

  • H1 — batch линейна. На наборах 4 KiB (10 000, 30 000, 100 000) время на 1 000 объектов различается не больше чем на 30 %, рост пика RSS — не больше 300 байт на ключ (множество ключей страниц). Основание: на страницу из 1 000 ключей — один LIST и одна выборка строк; кандидатов 0,75 % с перепроверкой.
  • H2 — head стоит круга на объект. На 10 000 и 30 000 время head — не меньше 5 × batch на том же наборе, запросов к БД не меньше, чем объектов, а пик RSS от 10 000 к 30 000 растёт не больше чем на 5 MiB (множества ключей нет).
  • H3 — глубокая сверка упирается в байты и CPU уборщика. Прочитано ровно (согласованных объектов × размер) во всех глубоких проходах; на 1 000 × 1 MiB deep дольше batch не меньше чем в 5 раз, а на 1 CPU (deep-fast) быстрее, чем на 0,25, не меньше чем в 1,5 раза.
  • H4 — предел скорости защищает фон. В ячейках с пределом (2000 объектов/с) p95 фоновых скачиваний в окне прохода — не больше 1,5 × p95 тихих окон, 5xx нет ни в одном окне, генератор отправил всё по расписанию, затронуто объектов в секунду — не больше предела / 0,9; без предела при 1 CPU отношение p95 больше, чем с пределом при 1 CPU.
  • H5 — отказ по пределу ничего не меняет и стоит как dry-run. При 1 000 кандидатах --apply --max-changes 100 исправляет 0, код 3, refused во всех повторах; время — в пределах ±20 % dry-run того же набора, HEAD столько же (перепроверка всех кандидатов делается до решения об отказе).

Результаты. TODO (Codex): таблицы «Проходы» и «Фоновая нагрузка» из evidence/reconcile/baseline/summary.md как есть и ссылка на метку.

Итог H1. TODO (Codex): строка вердикта из summary.md и абзац объяснения.

Итог H2. TODO (Codex).

Итог H3. TODO (Codex).

Итог H4. TODO (Codex).

Итог H5. TODO (Codex).

Что это значит для плановой сверки. TODO (Codex): по ms_per_1k batch при 0,25 CPU — сколько займёт плановая сверка (раз в час, предел 2000/с) на 100 000 и 1 000 000 объектов (экстраполяция, оговорить) и какую долю часа она занимает.

4.4. Железо и стенд замеров

TODO (Codex): по meta.json меток uploads/baseline и reconcile/baseline — host (модель CPU, ядра, память, питание), docker (версии, CPU и память ВМ, ядро), image.versions, budget, host_warnings, src_sha256 (должен совпадать с разделом 3).

5. Ограничения

  • Один Docker-host, один HAProxy, одна PostgreSQL, один Valkey и один узел S3 без репликации. Выдерживается отказ процесса API (любой одной реплики при ≥ 2 живых) и уборщика. Отказ S3 — 503 на загрузке и скачивании (текст работает); отказ хоста, LB и PostgreSQL не выдерживается.
  • Оригинал хранится в одном экземпляре на volume s3data; резервной копии bucket и восстановления в стенде нет. На время восстановления базы из backup уборщик нужно остановить: сверка сочла бы объекты новее backup «без строки» и после grace удалила бы их.
  • Окно уборки — CLEANER_GRACE 900 с: незавершённая загрузка держит объект до 15 минут плюс интервал прохода. Сверка с --deep читает все байты — её стоимость растёт с объёмом bucket (раздел 4.3).
  • Лимиты загрузок — на процесс: при N репликах одновременно в памяти до 4 × N тел; общей очереди между репликами нет (её роль играет 429 и повтор клиента).
  • Проверка изображения — структурная, без декодирования пикселей: повреждение внутри сжатых данных при правильных CRC и маркерах не обнаруживается (превью и декодирование — лаба 5).
  • Presigned upload (трек 1) не делался; обязательный путь через API — единственный.
  • Замеры под нагрузкой — на одной машине замеров (раздел 4.4); числа с машины разработки в отчёт не ставятся.
  • TODO (Codex): что обнаружено при замерах (пометки, предупреждения о хосте, опровергнутые гипотезы).

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

  • Почему файл в Docker volume одной API-реплики не равен объектному хранилищу? Volume принадлежит одному контейнеру на одном хосте: другая реплика его не видит, при остановке или пересоздании реплики (замена, отказ) файл недоступен или пропадает, доступ к нему никто не проверяет, его нельзя масштабировать и резервировать отдельно от реплики. S3 — общая служба с собственными правами доступа и долговечностью, к которой обращаются все реплики: после остановки принявшей реплики оригинал отдала другая (attachment-failover).
  • Когда можно честно вернуть 201? Только когда оригинал записан в S3 (PUT подтверждён) и строка ready зафиксирована в PostgreSQL: тогда любой участник через любую реплику получит метаданные и те же байты. Раньше нельзя: после ответа отказ одного из хранилищ потерял бы принятое вложение.
  • Что произойдёт, если S3 PUT прошёл, а COMMIT в PostgreSQL — нет? Строка pending с ключом записана до PUT, поэтому объект не «потерян»: если сбой был до отправки COMMIT, загрузка сама удаляет объект и отвечает 503; если исход COMMIT неизвестен, объект не трогается (строка могла стать ready) и ответ — 503. В обоих случаях остаток — строка pending (и, возможно, объект); через grace 900 с уборщик убирает их вместе, а сверка находит и объекты, у которых строки нет вовсе. Клиент повторяет загрузку.
  • Почему случайный object key и приватный bucket не заменяют ACL приложения? Приватный bucket закрывает анонимный доступ, но S3 не знает пользователей мессенджера и их чатов: кто может видеть вложение, решает только членство в чате, и проверяет его API на каждом запросе (посторонний — 404). Случайный ключ — не право доступа: он попадает в журналы, ответы, копии и не отзывается, когда пользователь выходит из чата; ключи S3 есть у процессов, а не у пользователей.

7. Что ещё проверить на защите

  • make reconcile на рабочем стенде после ручного удаления объекта или строки — сценарии те же, что в проверках отказов (test_reconcile_*).
  • make bench-uploads-quick (~5 мин) — пик памяти «с лимитом» и OOM «без лимита» при 40 × 10 MiB.

8. Источники и помощь ИИ

  • Amazon S3: загрузка объектов, presigned URLs (почему трек 1 не выбран).
  • SeaweedFS: weed server, S3 API, IAM через weed shell, ключ подписи filer.
  • aiobotocore, документация botocore (конфигурация повторов и сроков).
  • Спецификации PNG (W3C, чанки и CRC) и JPEG (ITU T.81, маркеры) — для структурной проверки без декодирования.
  • Документация ядра Linux, cgroup v2: memory.peak, memory.stat, memory.events — для замера пика памяти.
  • Документация HAProxy 3.4 (http-request set-timeout, tune.*buf), PostgreSQL 18 (FOR UPDATE SKIP LOCKED, частичные индексы, NOT VALID).

Помощь ИИ. Перенос кода лабы 3 на skeleton лабы 4, реализация вложений, уборщика, сверки, тестов, стенда bench/ и этого отчёта сделаны с Claude (Anthropic, Claude Code) по решениям и проверкам автора; каждое изменение проверено командами из раздела 3 на реальном стенде. Замеры под нагрузкой на машине замеров выполняет Codex (OpenAI) по bench/RUNBOOK.md — без права менять код, гипотезы и методику; числа в отчёт — только из файлов меток.