Files
mtusi2026lab4/REPORT.md
T

87 KiB
Raw Blame History

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

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

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

Основные проверки без нагрузки сняты на машине разработки 23 октября 2026 (раздел 3). Замеры под нагрузкой — профили uploads (уровень 4: пик памяти при ≥ 10 одновременных загрузках) и reconcile (трек 2: стоимость обхода) — сняты 27 октября 2026 по bench/RUNBOOK.md: 48 прогонов uploads, 45 проходов reconcile. При 40 клиентах и 10 MiB наблюдаемый медианный пик с лимитом — 159,8 MiB без OOM, без лимита — 509,6 MiB и OOM 3/3; пики — выборки 0,2 с. Batch на 100 000 объектах — 21,495 с; плановая конфигурация под нагрузкой — 55,499 с. Сводки подтверждают U1–U4 и H1–H3, H5; численная граница U1 проверена только для наблюдаемых выборок, H4 опровергнута. Гипотезы 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 до EOI и наличие данных каждого скана после SOS (одних маркеров перезапуска недостаточно), размеры из заголовка до любой распаковки (больше 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. Доказательства критериев

Код исторических доказательств 23–27 октября ниже — src_sha256 bc10d566e2f63173541445a2f6273b967447e13e5dd7f1fb76900934e5692cbe (при снятии этих файлов проект ещё не был под Git), машина разработки: Apple M3 Pro, macOS 26.6.2, Docker 29.9.2. На машине замеров 27 октября тот же код повторно прошёл 130 тестов через LB и 24 проверки отказов: вывод. Нагрузочные метки сняты на Apple M4 (раздел 4.4).

Критерий Результат Доказательство
Возможности лабы 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: стоимость обхода 45 проходов, model_ok везде; batch на 100 000 — 214,95 мс/1000 и 953 запроса БД за проход; head на 30 000 — 4086,50 мс/1000; p95 фона в плановой конфигурации / тихих окон 0,98 reconcile/baseline

Исправление по замечанию преподавателя, 30 октября 2026. JPEG-скан засчитывается только при наличии данных после SOS; пустой скан, одни RST или заполнители FF дают 415. Добавлены четыре отрицательных HTTP-теста: точные 27 байт из комментария и три варианта с заголовками и таблицами настоящего JPEG. До исправления все четыре получали 201; после него make test-isolated — 134 passed, все пять results равны 0; make failure-checks — 24 passed, make fmt и make lint без ошибок (вывод и хеш обновлённого кода). Нагрузочные замеры не повторялись: раздел 4 сохраняет результаты для кода до этой правки, гипотезы и метки не менялись.

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; на машине замеров сброс недоступен, используется максимум выборок 0,2 с) и закрытая модель: 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

Дополнительные метрики по COURSE.md. Источник — runs.csv. Значения ниже вычислены из трёх строк каждой ячейки: медиана (min–max); p99 здесь — медиана перцентилей отдельных повторов, а не перцентиль объединённого журнала. p50/p95/p99 загрузок считаются только по успешным ответам 201. Доля не-201 = (429 + 5xx + прочие ошибки) / число ответов на запросы, начатые в 20-секундном окне. Ответы 429 при перегрузке выделены в основной таблице. CPU генератора — процессорное время из gen_cpu_s, не загрузка реплики API; фактический CPU API в профиле памяти не снимался. Память API, S3 и LB — в основной таблице; CPU серверных компонентов измерен в профиле сверки ниже.

Вариант Тело C p99, мс Не-201, % CPU генератора, с
с лимитом 10mib 1 253.01 (252.43–294.05) 0.00 (0.00–0.00) 0.418 (0.414–0.419)
с лимитом 10mib 10 1100.11 (1072.86–1113.29) 0.00 (0.00–0.00) 0.586 (0.575–0.593)
с лимитом 10mib 20 1923.36 (1867.91–1979.04) 0.00 (0.00–0.00) 0.622 (0.590–0.631)
с лимитом 10mib 40 2043.29 (1970.94–2199.81) 62.02 (61.73–62.70) 0.904 (0.877–0.905)
с лимитом 1mib 1 26.05 (25.58–26.73) 0.00 (0.00–0.00) 1.010 (0.999–1.018)
с лимитом 1mib 10 103.77 (102.58–104.87) 0.00 (0.00–0.00) 2.001 (1.995–2.004)
с лимитом 1mib 20 187.68 (176.03–334.20) 0.00 (0.00–0.00) 1.981 (1.950–2.161)
с лимитом 1mib 40 185.70 (184.28–191.14) 12.20 (12.12–12.52) 2.228 (2.214–2.280)
без лимита 10mib 1 282.44 (270.56–287.06) 0.00 (0.00–0.00) 0.424 (0.402–0.429)
без лимита 10mib 10 1403.65 (1398.16–1422.65) 0.00 (0.00–0.00) 0.515 (0.505–0.517)
без лимита 10mib 20 2383.61 (2359.48–2556.22) 0.00 (0.00–0.00) 0.532 (0.527–0.539)
без лимита 10mib 40 — 100.00 (100.00–100.00) 0.553 (0.541–0.593)
без лимита 1mib 1 25.65 (25.56–26.29) 0.00 (0.00–0.00) 1.002 (0.995–1.008)
без лимита 1mib 10 117.03 (105.50–227.44) 0.00 (0.00–0.00) 2.050 (2.027–2.053)
без лимита 1mib 20 264.20 (245.80–267.74) 0.00 (0.00–0.00) 1.963 (1.901–1.989)
без лимита 1mib 40 382.71 (361.82–430.54) 0.00 (0.00–0.00) 2.181 (2.129–2.223)

Итог 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 столько же (перепроверка всех кандидатов делается до решения об отказе).

Результаты. Полная сводка и исходные данные: 45 проходов, 15 ячеек по 3 повтора; во всех строках model_ok=True, пометок и предупреждений о хосте нет. Для 12 проходов под нагрузкой сохранены все 108 строк окон: три окна × три вида запросов. Ниже таблицы сводки перенесены без пересчёта.

Этап N Размер Ячейка Время, мс мс на 1 000 LIST HEAD GET Запросов БД Прочитано, MiB CPU, мс RSS, MiB S3 CPU Пометки
a 1000 1024 KiB deep 6796 (5926–6797) 6796.00 (5926.00–6797.00) 5 (5–5) 9 (9–9) 988 (988–988) 12 (12–12) 988.0 (988.0–988.0) 1691 (1491–1691) 95.3 (95.3–95.4) 0.15 (0.14–0.15) —
a 1000 1024 KiB batch 408 (406–413) 408.00 (406.00–413.00) 5 (5–5) 9 (9–9) 0 (0–0) 12 (12–12) 0.0 (0.0–0.0) 103 (101–105) 94.2 (94.2–94.3) 0.08 (0.07–0.08) —
a 1000 1024 KiB deep-fast 2111 (2092–2237) 2111.00 (2092.00–2237.00) 5 (5–5) 9 (9–9) 988 (988–988) 12 (12–12) 988.0 (988.0–988.0) 1331 (1322–1350) 95.4 (95.3–95.4) 0.32 (0.32–0.39) —
b 10000 4 KiB head 40806 (40703–41894) 4080.60 (4070.30–4189.40) 36 (36–36) 10025 (10025–10025) 0 (0–0) 10061 (10061–10061) 0.0 (0.0–0.0) 10199 (10172–10463) 95.2 (95.1–95.3) 0.06 (0.06–0.06) —
b 10000 4 KiB deep 27790 (27093–30904) 2779.00 (2709.30–3090.40) 36 (36–36) 75 (75–75) 9900 (9900–9900) 96 (96–96) 38.7 (38.7–38.7) 6939 (6762–7720) 98.2 (98.2–98.4) 0.11 (0.11–0.13) —
b 10000 4 KiB batch 2398 (2386–2411) 239.80 (238.60–241.10) 36 (36–36) 75 (75–75) 0 (0–0) 96 (96–96) 0.0 (0.0–0.0) 596 (584–606) 97.9 (97.7–98.1) 0.14 (0.14–0.15) —
c 30000 4 KiB head 122595 (122323–123610) 4086.50 (4077.43–4120.33) 106 (106–106) 30075 (30075–30075) 0 (0–0) 30181 (30181–30181) 0.0 (0.0–0.0) 30642 (30592–30909) 95.6 (95.4–95.7) 0.06 (0.06–0.06) —
c 30000 4 KiB batch 6683 (6621–6807) 222.77 (220.70–226.90) 106 (106–106) 225 (225–225) 0 (0–0) 286 (286–286) 0.0 (0.0–0.0) 1663 (1662–1701) 101.8 (101.6–101.9) 0.17 (0.16–0.17) —
d 100000 4 KiB batch 21495 (21404–21785) 214.95 (214.04–217.85) 351 (351–351) 750 (750–750) 0 (0–0) 953 (953–953) 0.0 (0.0–0.0) 5369 (5348–5437) 112.2 (112.0–112.4) 0.18 (0.18–0.18) —
d 100000 4 KiB load-fast 8448 (8434–8578) 84.48 (84.34–85.78) 351 (351–351) 750 (750–750) 0 (0–0) 953 (953–953) 0.0 (0.0–0.0) 4728 (4721–4756) 112.2 (112.1–112.2) 0.51 (0.49–0.52) —
d 100000 4 KiB load-fast-limited 51334 (51327–51345) 513.34 (513.27–513.45) 351 (351–351) 750 (750–750) 0 (0–0) 953 (953–953) 0.0 (0.0–0.0) 4783 (4779–4839) 112.4 (112.4–112.6) 0.14 (0.14–0.15) —
d 100000 4 KiB load-unlimited 19316 (19196–20709) 193.16 (191.96–207.09) 351 (351–351) 750 (750–750) 0 (0–0) 953 (953–953) 0.0 (0.0–0.0) 4833 (4795–5181) 112.0 (111.7–112.4) 0.26 (0.26–0.27) —
d 100000 4 KiB load-stand 55499 (55116–55788) 554.99 (551.16–557.88) 351 (351–351) 750 (750–750) 0 (0–0) 953 (953–953) 0.0 (0.0–0.0) 5036 (4885–5070) 112.1 (111.9–112.2) 0.14 (0.13–0.14) —
e 10000 4 KiB batch 8194 (8088–8404) 819.40 (808.80–840.40) 1011 (1011–1011) 1000 (1000–1000) 0 (0–0) 1023 (1023–1023) 0.0 (0.0–0.0) 2034 (2017–2097) 97.9 (97.8–97.9) 0.10 (0.10–0.11) —
e 10000 4 KiB refuse 8213 (8093–8303) 821.30 (809.30–830.30) 1011 (1011–1011) 1000 (1000–1000) 0 (0–0) 1023 (1023–1023) 0.0 (0.0–0.0) 2063 (2013–2073) 97.9 (97.9–97.9) 0.10 (0.10–0.11) —

Фоновая нагрузка

Ячейка Окно Скачиваний p95 скачиваний, мс p95 записи, мс Ошибок p95 прохода / тихих
load-stand before 4068 (4053–4069) 5.6 (5.4–5.9) 6.3 (6.0–6.7) 0 —
load-stand pass 11100 (11023–11158) 5.5 (5.4–5.9) 6.3 (6.1–6.6) 0 0.98 (0.98–1.00)
load-stand after 4156 (4146–4187) 5.9 (5.5–6.0) 6.6 (6.2–6.7) 0 —
load-unlimited before 4086 (4053–4097) 5.9 (5.3–5.9) 6.5 (6.1–6.6) 0 —
load-unlimited pass 3863 (3839–4142) 5.8 (5.2–6.7) 6.4 (5.9–8.2) 0 0.98 (0.98–1.14)
load-unlimited after 4153 (4142–4177) 5.9 (5.3–6.0) 6.5 (5.9–6.6) 0 —
load-fast before 3750 (3720–3755) 6.0 (5.5–6.0) 6.6 (6.2–6.7) 0 —
load-fast pass 1690 (1686–1715) 5.7 (5.6–5.8) 6.6 (6.3–6.7) 0 0.97 (0.95–1.00)
load-fast after 4082 (4069–4086) 5.9 (5.8–6.0) 6.5 (6.4–6.7) 0 —
load-fast-limited before 3724 (3720–3726) 5.9 (5.3–6.1) 6.5 (6.0–6.7) 0 —
load-fast-limited pass 10267 (10265–10269) 5.8 (5.3–5.8) 6.5 (6.0–6.5) 0 0.98 (0.98–1.00)
load-fast-limited after 4091 (4078–4100) 5.6 (5.3–5.8) 6.2 (6.0–6.4) 0 —

Дополнительные метрики фоновой нагрузки. Источник — windows.csv; показано окно самого прохода. Успешных запросов/с = ok / seconds, ошибки = errors / requests; медиана (min–max) трёх повторов. Это отдельные перцентили повторов, без объединения журналов. Все окна before/pass/after с p50/p95/p99 и счётчиками сохранены в CSV.

Ячейка Запрос Успешных/с p50, мс p95, мс p99, мс Ошибки, %
load-stand download 200.00 (199.98–200.00) 3.90 (3.80–4.00) 5.50 (5.40–5.90) 15.90 (6.10–93.30) 0.00 (0.00–0.00)
load-stand read 49.99 (49.98–50.00) 3.50 (3.00–3.50) 4.80 (4.40–5.10) 15.10 (5.20–77.70) 0.00 (0.00–0.00)
load-stand write 49.99 (49.98–50.00) 5.00 (4.70–5.10) 6.30 (6.10–6.60) 19.70 (6.90–116.80) 0.00 (0.00–0.00)
load-unlimited download 199.95 (199.95–200.00) 3.90 (3.90–4.10) 5.80 (5.20–6.70) 7.40 (5.90–10.70) 0.00 (0.00–0.00)
load-unlimited read 50.00 (49.95–50.02) 3.50 (3.40–3.50) 5.00 (4.50–6.20) 5.70 (4.90–10.30) 0.00 (0.00–0.00)
load-unlimited write 50.00 (49.95–50.02) 5.10 (5.10–5.20) 6.40 (5.90–8.20) 7.60 (6.50–13.50) 0.00 (0.00–0.00)
load-fast download 200.00 (199.88–200.00) 3.90 (3.80–4.00) 5.70 (5.60–5.80) 6.60 (6.60–6.60) 0.00 (0.00–0.00)
load-fast read 50.00 (49.94–50.06) 3.40 (3.20–3.50) 4.70 (4.60–5.10) 5.40 (5.10–5.60) 0.00 (0.00–0.00)
load-fast write 50.00 (49.94–50.06) 5.10 (4.90–5.10) 6.60 (6.30–6.70) 7.30 (7.10–7.50) 0.00 (0.00–0.00)
load-fast-limited download 200.02 (199.98–200.02) 4.00 (3.90–4.00) 5.80 (5.30–5.80) 6.90 (5.80–7.30) 0.00 (0.00–0.00)
load-fast-limited read 50.00 (49.99–50.01) 3.40 (3.20–3.50) 4.80 (4.60–5.00) 5.70 (5.10–6.40) 0.00 (0.00–0.00)
load-fast-limited write 50.00 (49.99–50.01) 4.80 (4.80–5.10) 6.50 (6.00–6.50) 7.80 (6.70–7.90) 0.00 (0.00–0.00)

CPU серверных компонентов. Источник — passes.csv, этап d (100 000 объектов): среднее число занятых ядер за окно прохода, затем медиана (min–max) повторов. 1,00 означает загрузку одного ядра; API — сумма двух реплик. CPU и RSS самого уборщика уже приведены в таблице проходов.

Ячейка S3, ядра PostgreSQL, ядра API, ядра
batch 0.180 (0.179–0.184) 0.018 (0.017–0.026) 0.004 (0.004–0.004)
load-stand 0.135 (0.133–0.142) 0.071 (0.062–0.073) 0.566 (0.539–0.568)
load-unlimited 0.258 (0.256–0.267) 0.069 (0.067–0.077) 0.558 (0.556–0.617)
load-fast 0.509 (0.493–0.522) 0.087 (0.083–0.088) 0.605 (0.599–0.605)
load-fast-limited 0.137 (0.135–0.149) 0.062 (0.061–0.065) 0.553 (0.536–0.573)

Итог H1. Сводка: подтверждена — мс на 1 000 объектов: 10000 — 239.80, 30000 — 222.77, 100000 — 214.95 (разброс 12%, порог 30%); рост RSS 167 Б на ключ (10000 → 100000, порог 300).

Выборка метаданных на страницу списка сокращает число обращений к PostgreSQL; память растёт из-за множества ключей. На измеренных 10–100 тысячах объектов нормированная стоимость и рост RSS укладываются в заранее заданные пороги. Это проверка на трёх размерах набора, а не доказательство линейности для произвольного bucket.

Итог H2. Сводка: подтверждена — N=10000: head 40806 мс / batch 2398 мс = 17.0×, запросов БД 10061 на 9975 объектов; N=30000: head 122595 мс / batch 6683 мс = 18.3×, запросов БД 30181 на 29925 объектов; рост RSS head 10000 → 30000: 0.4 MiB (порог 5).

Стратегия head заменяет множество ключей отдельными обращениями к БД и HEAD для строк. Память почти не растёт, но сетевые обращения и обработка каждого объекта в квоте 0,25 CPU делают проход в 17–18 раз дольше batch. В плановой сверке поэтому выбран batch.

Итог H3. Сводка: подтверждена — N=1000 × 1024 KiB: read_bytes = 1035993088 во всех 6 проходах; deep / batch = 16.7× (порог 5); 0,25 CPU / 1 CPU = 3.22× (порог 1.5), CPU уборщика / время при 0,25 CPU = 0.25; N=10000 × 4 KiB: read_bytes = 40550400 во всех 3 проходах.

Глубокий проход прочитал ровно байты согласованных оригиналов; при 0,25 CPU он использует всю квоту. Увеличение квоты ускорило проход большого содержимого в 3,22 раза. Число GET тоже существенно: 10 тысяч маленьких объектов заняли 27,79 с при чтении 38,7 MiB, тогда как тысяча больших — 6,80 с при чтении 988 MiB. Стоимость deep определяется и числом запросов, и объёмом чтения и SHA-256.

Итог H4. Сводка: опровергнута — p95 скачиваний в проходе / в тихих окнах: load-stand 0.98, load-unlimited 0.98, load-fast 0.97, load-fast-limited 0.98 (порог для ячеек с пределом 1.5); 5xx во всех окнах: 0; проходов с bg_dropped: 0; затронуто объектов/с с пределом: 1962, 1828, 1963, 1815, 1963, 1806.

Гипотеза опровергнута целиком: ограниченные ячейки прошли пороги задержки, ошибок и скорости, но последний сравнительный критерий не выполнен. При 1 CPU без предела отношение p95 равно 0,97, с пределом — 0,98; ухудшения без предела этот опыт не показал. Вероятное объяснение — запас ресурсов машины при выбранной фоновой нагрузке. Ограничение растянуло обход и уменьшило интенсивность работы, однако его преимущество для p95 здесь не доказано. Для большей нагрузки или более тесного S3 нужен отдельный эксперимент; гипотеза и пороги после замера не менялись.

Итог H5. Сводка: подтверждена — исправлено 0, коды [3], refused во всех: True; время отказа 8213 мс / dry-run 8194 мс; HEAD 1000 / 1000.

Предел изменений проверяется после полного поиска и перепроверки кандидатов. Поэтому отказ не экономит HEAD и проверочные LIST: он стоит почти как dry-run, зато не исправил ни одной записи или объекта. Повторные проходы на том же наборе находят прежние расхождения.

Что это значит для плановой сверки. Без предела скорости batch при 0,25 CPU дал 214,95 мс на 1000 объектов на самом большом наборе: 21,495 с на 100 000 и, при линейном переносе, 214,95 с на 1 000 000 (0,60 % и 5,97 % часа). Эти числа нельзя напрямую выдавать за время планового прохода с пределом 2000/с: один только предел задаёт минимум 50 и 500 с. В измеренной плановой конфигурации load-stand получено 554,99 мс на 1000, то есть медиана 55,499 с на 100 000 (1,54 % часа); экстраполяция на миллион — 554,99 с, около 9,25 мин или 15,42 % часа. Интервал RECONCILE_INTERVAL=3600 с на этих объёмах имеет запас. Миллион объектов не измерялся: перенос предполагает те же размеры объектов, доли расхождений, ресурсы и фоновую нагрузку.

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

Паспорта: uploads, reconcile. Оба опыта сняты 27 октября 2026 в одной сессии машины, без перезагрузки. Apple M4, 10 ядер, arm64, 16 GiB RAM; macOS 26.6.2; питание AC Power. Docker Desktop 28.0.4, Compose 2.34.0-desktop.1, ВМ aarch64: 10 CPU, 8 218 034 176 байт (7,65 GiB), Linux 6.10.14-linuxkit, cgroup v2/cgroupfs. Python хоста 3.13.7.

Сумма лимитов профиля uploads — 8 CPU / 3,88 GiB; reconcile на пике — 9,75 CPU / 4,88 GiB; проверка бюджета добавляет 1,5 GiB резерва. Лимиты отдельных сервисов — в разделе 2 и профилях паспортов. Рабочий стенд до задачи не был запущен, посторонних работающих контейнеров не было. В обоих паспортах host_warnings=[], прирост swapouts 0; признаков сна нет (расхождение часов 0,0/0,1 с).

Версии пакетов внутри образа: python 3.13.15; fastapi 0.142.1; starlette 1.7.0; uvicorn 0.54.0; pydantic 2.13.5; sqlalchemy 2.1.1; asyncpg 0.31.0; alembic 1.20.0; redis 8.1.0; argon2-cffi 25.1.0; aiobotocore 3.10.0; botocore 1.43.117; aiohttp 3.14.5. PostgreSQL 18.6, Valkey 9.1.2, HAProxy 3.4.6, SeaweedFS 4.48 — закреплённые образы общего compose.

В обоих образах src_sha256=bc10d566e2f63173541445a2f6273b967447e13e5dd7f1fb76900934e5692cbe, как в доказательствах разработки. Git подключён перед опытами; ветка solution/bvt2301-vladimirceva. Оба паспорта указывают коммит e4cc7ee32fbf0abaf8e15c42370ed1c6c01e4002; у reconcile git_dirty=True, поскольку при его старте ещё не были закоммичены результаты uploads. На момент замеров git diff e4cc7ee -- src migrations был пуст: измеренный код не менялся.

Ограничение ядра: сброс memory.peak появился позже версии 6.10.14, поэтому у всех 48 прогонов uploads источник пика — sampled, интервал 0,2 с. Точное максимальное значение между выборками не проверено. Это явно отмечено в таблице, выводе U1 и ограничениях; для точной повторной проверки нужен Docker с ядром не ниже 6.12.

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); числа с машины разработки в отчёт не ставятся.
  • В профиле uploads фактический CPU API/S3/LB не измерялся: целью был пик RAM; измерены CPU генератора и лимиты CPU, а фактический CPU серверов — в профиле reconcile.
  • Все пики окна uploads получены выборками 0,2 с: возможны пропущенные краткие всплески; строгая граница U1 между выборками не проверена. OOM установлен по State.OOMKilled и коду 137.
  • H4 опровергнута: под выбранной фоновой нагрузкой снятие предела скорости не ухудшило p95. Результат не переносится на более тесный S3 или более высокую нагрузку без нового опыта.
  • Перед опытами один uploads-quick прерван до измерений из-за зависшего docker-credential-desktop (quick-uploads-20261027T192321Z). Метка сохранена с aborted, в итоговые таблицы не входит. После анонимной загрузки того же публичного образа повторная самопроверка и оба полных профиля завершились.
  • Экстраполяция на миллион объектов не заменяет замер этого объёма; deep зависит также от количества GET. Предупреждений о хосте, сна и выгрузки страниц в полных метках нет.

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) 27 октября 2026 по bench/RUNBOOK.md — без права менять код, гипотезы и методику; числа в отчёт — только из файлов меток.

30 октября 2026 Codex (OpenAI) исправил проверку пустого JPEG-скана по замечанию преподавателя, добавил четыре HTTP-теста и выполнил проверки, записанные в evidence/tests/jpeg-validation.txt.