45 KiB
Отчёт — лабораторная 4
Перенесено из корня репозитория lab4 при переходе на lab5 без изменений по существу. Пути
evidence/...в этом файле указывают наdocs/lab4/evidence/. Отчёт lab5 — REPORT.md.
- Автор, группа: Попов Константин Дмитриевич, группа БВТ2303
- Целевая оценка: 4; трек 5 не заявляется
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: Python 3.12, FastAPI 0.115.6, Uvicorn 0.34.0, Pydantic 2.10.4, psycopg 3.2.3 + psycopg-pool 3.2.4, redis-py 5.2.1, argon2-cffi 23.1.0, boto3 1.35.99, Pillow 11.1.0; PostgreSQL 16.4, Redis 7.4.1, HAProxy 2.8.30, SeaweedFS 4.50. Документация: Amazon S3 (PutObject, Content-MD5, ListObjectsV2), SeaweedFS wiki (Amazon S3 API, S3 credentials/identities,
weed server), спецификация PNG (ISO/IEC 15948: чанки, CRC, Adam7), JPEG (ITU T.81: маркеры SOF/SOS/EOI), Pillow (Image.open,draft), glibcmallopt(MALLOC_ARENA_MAX, MALLOC_MMAP_THRESHOLD_). Помощь ИИ (Claude) — при проектировании схемы согласованности БД/S3, проверки изображений, тестов, экспериментов и при написании отчёта.
Решения lab3 (балансировщик, реплики, идемпотентность, drain, rolling update) перенесены без изменений семантики; их отчёт и доказательства сохранены в docs/lab3/REPORT.md.
Запуск из чистого clone
Версии. API: сборка из Dockerfile на python:3.12.7-slim-bookworm; postgres:16.4-alpine; redis:7.4.1-alpine; haproxy:2.8.30-alpine; chrislusf/seaweedfs:4.50 (тег задаётся SEAWEEDFS_VERSION в .env, не latest). Нужны Docker Engine / Docker Desktop с Compose v2 и Python 3.9+ на хосте (тесты и scripts/ops.py — только стандартная библиотека). Оркестрация — Compose + HAProxy (Swarm не используется).
# 1. Секреты (один раз; каталог secrets/ в .gitignore, значения не печатаются) и .env
python scripts/init_secrets.py # + 4 файла S3-ключей и secrets/s3_config.json
cp .env.example .env # Windows: copy .env.example .env
# 2. Сборка и запуск: postgres+redis -> migrate; s3 -> s3-init (bucket) -> api x2 -> lb
docker compose --env-file .env config --quiet
docker compose --env-file .env up -d --build
# 3. Готовность: 2 реплики healthy и UP в HAProxy; S3 реально пишет/читает
python scripts/ops.py wait
python scripts/ops.py wait-s3
python scripts/ops.py ps
Прогрев: первая сборка 1–3 мин, далее стенд готов за ~30–40 с (healthcheck PostgreSQL и SeaweedFS, миграции, bootstrap бакета, start_period API, rise 2 в HAProxy).
# Публичные проверки
python scripts/check_contract.py
python tests/smoke.py --base-url http://localhost:8080
python tests/resilience.py --mode persistence --action-script scripts/restart.sh # Windows: scripts\restart.cmd
python tests/resilience.py --mode failover --action-script scripts/stop-one.sh # Windows: scripts\stop-one.cmd
python scripts/ops.py restore # вернуть реплику, затем failover повторить для второй
# Собственные проверки уровня 4 (lab4)
python student-tests/run_all.py --base-url http://localhost:8080 # lab2-3 + test_attachments.py (17 тестов)
python scripts/ops.py in-network consistency # БД<->S3: сборщик, сироты, обрыв загрузки, внедрённые отказы
python scripts/ops.py s3-check # приватный бакет вне API, права ключей, закрытые админ-порты
python scripts/ops.py reconcile # сверка БД<->S3, dry-run (--apply — исправить)
python student-tests/s3_outage.py --output evidence/s3_outage.json
python student-tests/upload_memory.py --concurrency 10 --docker --output evidence/upload_memory_c10.json
# Всё перечисленное (и проверки lab3) одной командой с записью в evidence/:
python scripts/collect_evidence.py # ~12–15 мин; --quick ~7–8 мин
Остановка. Безопасная (данные PostgreSQL и S3 сохраняются): docker compose --env-file .env --profile ttl --profile faults down. Намеренное удаление всех учебных данных (volumes pgdata, s3data) — только вручную: docker compose --env-file .env --profile ttl --profile faults down -v. Hooks и тесты volumes не удаляют.
Действия оператора. Создать секреты до первого запуска (пароль PostgreSQL задаётся только при инициализации пустого volume, поэтому init_secrets.py существующие файлы не перезаписывает; S3-ключи не связаны с данными и могут быть заменены — см. docstring скрипта). После stop-one вернуть реплику python scripts/ops.py restore. Если тег chrislusf/seaweedfs:4.50 недоступен в вашем registry-зеркале, укажите соседний проверенный тег в SEAWEEDFS_VERSION.
Архитектура и решения
127.0.0.1:8080 (единственная публичная точка входа)
Клиент ──HTTP──► lb: HAProxy 2.8 ── roundrobin, активные проверки /health/ready
│ POST .../attachments: timeout server 90 s, остальное 10 s
▼ сеть backend
┌──────── api x2 (read-only rootfs, tmpfs /tmp 16m, 0.5 CPU / 320M) ────────┐
│ загрузка: поток -> лимит 10 MiB -> проверка PNG/JPEG -> [1] pending в БД │
│ -> [2] S3 PUT (Content-MD5) -> [3] ready в БД -> 201 │
│ скачивание: проверка членства -> поток из S3 (64 KiB) -> клиент │
│ фон: сборщик pending/сирот (advisory lock, одна реплика за раз) │
└──────┬───────────────────────┬────────────────────────────┬───────────────┘
▼ backend ▼ backend ▼ storage (internal: true)
postgres 16 (pgdata) redis 7 (кэш сессий) s3: SeaweedFS 4.50 (s3data)
users, chats, messages, только S3 API :8333 в сети storage;
sessions, idempotency_keys, master/filer/volume UI — 127.0.0.1
attachments, message_attachments внутри контейнера; без анонимов
▲ ▲
migrate (one-shot) s3-init (one-shot, admin-ключи):
бакет + проверки прав и приватности
Порядок старта: postgres, redis (healthy) → migrate; s3 (healthy) → s3-init (оба service_completed_successfully) → api (healthy) → lb.
Источник истины. PostgreSQL — для всех метаданных, включая вложения (владелец, чат, имя, тип, размер, SHA-256, размеры в пикселях, ключ объекта, состояние). Байты оригинала — только в приватном бакете messenger-attachments. На API нет ни volume, ни каталога для файлов: rootfs read-only, /tmp — tmpfs 16 MiB (тело загрузки держится в памяти процесса до записи в S3, не на диске; python scripts/ops.py api-fs).
Выбор S3-сервера: SeaweedFS
MinIO с осени 2025 г. не публикует community-образы и бинарники для свежих релизов, а консоль администратора у него встроена в тот же процесс. SeaweedFS (Apache-2.0): версия закрепляется тегом, S3-identities с правами на конкретный бакет задаются статическим JSON-конфигом (-s3.config), а все административные HTTP-интерфейсы (master 9333, filer 8888, volume 8080) привязываются к 127.0.0.1 внутри контейнера (-ip.bind=127.0.0.1), наружу в сеть storage выставлен только S3 (-s3.ip.bind=0.0.0.0). Встроенный IAM API отключён (-s3.iam=false), автосоздание бакетов — тоже (-s3.autoCreateBucket=false).
| Роль | Сервис | Образ | Health/readiness | Volume | Сеть / порт | Credentials |
|---|---|---|---|---|---|---|
| LB | lb |
haproxy:2.8.30-alpine | /lb-health; бэкенды по /health/ready |
— | backend; 127.0.0.1:8080, :8404 | — |
| API ×2 | api |
сборка Dockerfile |
/health/ready (PostgreSQL + схема) |
нет (read-only) | backend + storage; без ports | secrets: database_url, cache_url, s3_access_key_id, s3_secret_access_key |
| БД | postgres |
postgres:16.4-alpine | pg_isready |
pgdata |
backend | postgres_password |
| Кэш сессий | redis |
redis:7.4.1-alpine | redis-cli ping |
нет (только кэш) | backend | redis_password |
| S3 | s3 |
chrislusf/seaweedfs:4.50 | wget /healthz (+ ops.py wait-s3) |
s3data |
storage (internal); только :8333 | secret s3_config (identities) |
| Миграции | migrate |
сборка | one-shot | — | backend | database_url |
| Bucket bootstrap | s3-init |
сборка | one-shot | — | storage | admin + api S3-ключи |
| Тестовые отказы | api-fault-* (профиль faults) |
образ API | /health/ready |
— | backend + storage | как у api |
Модель данных (migrations/004_attachments.sql)
attachments(id, chat_id, owner_id, filename, content_type, size_bytes, sha256, width, height, object_key UNIQUE, state pending|ready, created_at, updated_at). CHECK-ограничения повторяют контракт: имя 1–255, тип png/jpeg, размер 1..10 485 760,width*height ≤ 40 000 000, sha256 в нижнем регистре.object_key = "originals/" + случайный UUID. Он не совпадает сidвложения, не содержитfilenameи не раскрывается в API.message_attachments(message_id, attachment_id, chat_id, position): порядокattachment_idsсохраняется. Составные внешние ключи(message_id, chat_id) → messages(id, chat_id)и(attachment_id, chat_id) → attachments(id, chat_id)на уровне БД запрещают привязать файл чужого чата.ON DELETE RESTRICTне даёт удалить вложение, на которое ссылается сообщение.messages_text_lenрасширен до 0..4000:text=""допустим только вместе с вложениями (проверяет API). Миграция только расширяющая — реплики lab3 работают на новой схеме (rolling update).
Загрузка, 201 и границы транзакций
POST /api/v1/chats/{id}/attachments?filename=… (сырые bytes, src/main.py):
- Дешёвые проверки до чтения тела: аутентификация →
filename(400) →Content-Typeтолькоimage/png|image/jpeg(415) →Content-Length > 10 MiB→ 413 без чтения → членство в чате (404) → слот загрузки (MAX_CONCURRENT_UPLOADS=4на реплику; ожидание ≤ 5 с, иначе 503 +Retry-After). - Тело читается потоком; как только счётчик превысил 10 MiB — 413 (и для chunked без
Content-Length). Остаток тела (до 10 MiB) дочитывается в никуда, чтобы клиент получил 413, а не обрыв. Общий дедлайн приёма —UPLOAD_READ_TIMEOUT_SECONDS=60(медленный клиент → 400). Обрыв клиентом → ничего не записано. - Проверка содержимого (
src/images.py, ≤ 2 одновременных на реплику):- сигнатура PNG/JPEG; сигнатура должна совпасть с заявленным Content-Type (подмена MIME → 415);
- размеры из IHDR / SOFn до распаковки: > 40 Мп → 413 (pixel bomb 8000×6000 размером ~50 КБ отклоняется за миллисекунды);
- PNG: все CRC, порядок IHDR…IDAT…IEND, допустимые bit depth/color type, потоковая распаковка zlib с выводом кусками по 64 KiB «в никуда»: объём должен в точности совпасть с ожидаемым (с учётом Adam7). Так обнаруживаются обрезанные и испорченные данные, а zip-бомба обрывается, как только вывод превысил ожидание; память O(64 KiB) при любом размере картинки;
- JPEG: обход маркеров (длины сегментов, SOF до SOS, обязательный EOI → обрезанный файл = 415). Baseline дополнительно декодируется Pillow в режиме
draft(1/8 масштаба). Progressive Pillow не декодирует: libjpeg держит коэффициенты всего кадра, замер — 119 MiB на 39.7 Мп против 4.9 MiB у baseline; - независимый парсер Pillow должен увидеть тот же формат и размеры.
[1]INSERT attachments … state='pending'(с проверкой членства в том же операторе) — COMMIT до S3.[2]S3PutObjectсContent-MD5(S3 сам отклоняет повреждённую передачу — BadDigest; проверено) иx-amz-meta-sha256.[3]UPDATE … SET state='ready' WHERE id=… AND state='pending'— COMMIT →201 Attachment {status: ready, variants: [], error_code: null}.
Когда честно вернуть 201: только после шага [3]. Байты к этому моменту записаны в S3 (PUT подтверждён с проверкой MD5), а метаданные зафиксированы в PostgreSQL. Ответ 201 до любого из этих событий означал бы, что «готовое» вложение может не скачаться.
S3 PUT прошёл, а COMMIT [3] — нет. Остаются строка pending (не видна в API, прикрепить нельзя) и объект. При ошибке БД API сразу компенсирует: удаляет объект и пытается удалить строку, клиент получает 503. Если процесс умер (компенсации нет), строку и объект уберёт сборщик после grace period. Обе ветки проверены внедрением отказа (api-fault-db, api-fault-crash).
Согласованность БД и S3: компенсация + сборщик (src/reconcile.py)
Главный инвариант: ключ объекта записан в БД раньше, чем объект появится в бакете. Поэтому объект без строки может появиться только после того, как строку удалили. Ключ одноразовый, удалённая строка не возрождается.
| Ситуация | Кто исправляет | Как |
|---|---|---|
Ошибка S3 в [2] |
запрос | DELETE своей pending-строки, 503 |
Ошибка БД в [3] |
запрос | DELETE объекта (+ попытка DELETE строки), 503 |
Процесс умер между [1]/[2]/[3], обрыв, сеть |
сборщик, проход A | pending старше grace: сначала DELETE … WHERE state='pending' RETURNING object_key (атомарный захват; если запрос успел [3], строка уже ready и не трогается), потом DELETE объекта |
| Объект без строки (сбой удаления в A, ручная запись) | сборщик, проход B | листинг originals/ страницами; нет строки и LastModified старше grace → повторная проверка → DELETE |
| ready-строка без объекта | только отчёт (C) | байты не восстановить; авто-удаление метаданных опасно — missing_objects в отчёте |
- Grace period
ATTACHMENT_GC_GRACE_SECONDS=900(минимум 300, конфиг меньше не примет). Это намного больше самой долгой загрузки: чтение ≤ 60 с + проверка + S3 PUT (connect 2 с + read 10 с) × 2 попытки ≈ 90 с. Если загрузка всё же переживёт grace,[3]вернёт 0 строк → API удалит свой объект и ответит 503. - Свежие и используемые вложения не удаляются: сборщик трогает только
pendingстарше grace. ready-строки не удаляет никогда, а на используемые ещё и стоит FK RESTRICT. Тесты:test_fresh_pending_is_kept,test_ready_and_referenced_are_never_collected(прямойDELETEполучает ForeignKeyViolation),test_pending_cannot_be_attached. - Фоновый проход A — каждые 300 с, полный обход бакета B — раз в час. Выполняет одна реплика за раз (
pg_try_advisory_lock). Ручной запуск:python scripts/ops.py reconcile(dry-run по умолчанию, ничего не меняет) и… reconcile --apply. Повторный--apply— no-op (проверено). Стоимость обхода на стенде: 238 объектов — 0.036 с (листинг + одинSELECT … = ANYна страницу из 1000 ключей).
Ограничение памяти и потоковая обработка
- Лимит байт применяется во время чтения (на 10 MiB + 1 байт). В памяти одной загрузки — тело (≤ 10 MiB) + кратковременно куски до склейки. Проверка PNG — O(64 KiB), JPEG baseline — ≤ ~5 MiB. Тело уходит в S3 как
BytesIOповерх тех же bytes, без копии. - Одновременно на реплику ≤ 4 загрузки (
MAX_CONCURRENT_UPLOADS). Остальные ждут слот ≤ 5 с до чтения тела, поэтому их байты не накапливаются в памяти. Скачивание идёт потоком из S3 кусками по 64 KiB (StreamingResponse), без буферизации файла. - Найдено и исправлено замерами (см. «Эксперименты»):
zlib.unconsumed_tailкопировал остаток IDAT на каждом шаге (пик 2× файла и квадратичное копирование), а botocore склеивал заголовки с теломbytesв один буфер. В образе также настроен glibc malloc (MALLOC_ARENA_MAX=2, фиксированный порог mmap 1 MiB), чтобы большие буферы возвращались ОС сразу.
Безопасность бакета и ключей
- Bootstrap идемпотентен (
src/s3_bootstrap.py, сервисs3-init):CreateBucket→BucketAlreadyOwnedByYouсчитается успехом (evidence/sandbox/s3_bootstrap.txt: повторный запуск —already exists (idempotent no-op)). После создания бакета s3-init проверяет права ключей и приватность; при нарушении он завершается с ошибкой, и API не стартует. - Отдельные ключи API (
messenger_api) имеют толькоRead/Write/Listнаmessenger-attachments.CreateBucket/DeleteBucket→ AccessDenied. Admin-ключи (bootstrap_admin) смонтированы только вs3-init. Identityanonymousне объявлена. - Проверка приватности вне API (
python scripts/ops.py s3-check): из сетиstorage, без подписи, к S3 напрямую. Анонимный GET реального объекта последнего вложения → 403, анонимный листинг бакета и списка бакетов → 403. Тот же объект с ключами API → 200 и совпадающий SHA-256. - Админ-консоль не открыта в общей сети: порты 9333/8888/8080/19333/18888 с адреса
s3закрыты (проверка в том же скрипте). Сетьstorage—internal: true. LB в неё не входит, порты S3 на хост не публикуются. - Случайный ключ и приватный бакет не заменяют ACL приложения: доступ к
GET /attachments/{id}и/contentпроверяется по членству в чате на каждый запрос (посторонний → 404 без раскрытия существования). Download идёт через API без redirect и без подписанных URL. Ответ содержитX-Content-Type-Options: nosniff,Cache-Control: private, no-store,Content-Dispositionс безопасно закодированным именем.
Недоступность S3 и readiness
S3 не входит в readiness: если бы реплики при падении S3 становились not-ready, LB вывел бы обе, и вместе с файлами пропали бы чат и вход. Вместо этого файловые операции быстро отвечают 503 unavailable + Retry-After (таймауты клиента S3: connect 2 с, read 10 с, ≤ 2 попытки), а всё остальное работает. Критичные зависимости readiness — по-прежнему PostgreSQL и мигрированная схема.
Таймауты boto3 не покрывают DNS: в Docker остановленный контейнер s3 пропадает из DNS, и разрешение имени висит секундами. В первом прогоне на Docker Desktop загрузка ждала 12–13 с, а скачивание превысило timeout server HAProxy (10 с) и получило 504 от LB вместо 503. Исправление (src/main.py, s3_call; src/objectstore.py, CircuitBreaker):
- у каждого вызова S3 из запроса есть общий дедлайн: скачивание 5 с, загрузка 10 с;
- после отказа circuit breaker 5 с сразу отвечает 503, затем делает одну пробную попытку;
- у API в compose
dns_opt: timeout:1, attempts:1.
Проверено на худшем случае — S3, который принимает соединение и молчит: upload 503 за 10.0 с, download 503 за 5.0 с (evidence/sandbox/s3_outage_hang.json). При S3, который сразу отказывает: 1.8–2.3 с и 0.01 с (breaker открыт).
Особенность SeaweedFS после рестарта (замер): /healthz отвечает сразу, но первые операции блокируются. Первое чтение после рестарта шло ~15 с, первая запись ~29 с: выборы Raft-лидера (electionTimeout 10 с), затем heartbeat volume-сервера. С -master.electionTimeout=2s первая запись — ~19 с. Поэтому restart-hook и ops.py wait-s3 ждут реальной готовности: проба put/get/delete и чтение существующего объекта, каждая операция < 2 с (s3_bootstrap.py --wait-ready); на стенде готовность наступала через 14.5–17.1 с. Штатная остановка SeaweedFS длится ~22 с, поэтому stop_grace_period: 10s (как у Docker по умолчанию) и затем SIGKILL. Подтверждённые записи к этому моменту уже в page cache ОС; тест сохранности после такого рестарта проходит.
Что перенесено из lab3 и что изменено
Перенесены без изменения семантики: всё API lab2–3, HAProxy-конфигурация (обнаружение реплик через DNS, drain, retries/redispatch), идемпотентность, миграции one-shot, rolling update, hooks и собственные тесты lab2–3 (47 HTTP-тестов + 12 тестов хранилища проходят на lab4).
Изменено в lab4:
- Переход контракта 3 → 4: поля
attachment_idsв запросе и ответе сообщения (отсутствие =[]и для отпечатка идемпотентности; порядок значим), три новых endpoint. - Сервисы
s3,s3-init, volumes3data, сетьstorage; секреты S3; профильfaults. - HAProxy: для
POST …/attachments—timeout server 90s(http-request set-timeout), остальным запросам — прежние 10 с. - Лимит памяти API 256M → 320M (4 загрузки по 10 MiB, замер ниже); glibc malloc tuning в
Dockerfile. scripts/ops.py: restart включает S3 и ждёт его прогрева; новыеwait-s3,s3-check,reconcile,api-fs,in-network consistency.collect_evidence.pyдополнен проверками lab4.
Соответствие .env.example и реальной конфигурации
Переменные lab3 — без изменений (см. docs/lab3/REPORT.md). Новые:
| Переменная | Значение | Где используется |
|---|---|---|
SEAWEEDFS_VERSION |
4.50 | тег образа s3 |
S3_ENDPOINT, S3_REGION, S3_BUCKET |
http://s3:8333, us-east-1, messenger-attachments | api, s3-init, src/config.py |
S3_ACCESS_KEY_ID_FILE, S3_SECRET_ACCESS_KEY_FILE |
/run/secrets/… | ключи API (compose secrets) |
S3_CONNECT_TIMEOUT_SECONDS, S3_READ_TIMEOUT_SECONDS, S3_MAX_ATTEMPTS |
2, 10, 2 | src/objectstore.py |
S3_DOWNLOAD_DEADLINE_SECONDS, S3_UPLOAD_DEADLINE_SECONDS, S3_CIRCUIT_OPEN_SECONDS |
5, 10, 5 | общий бюджет вызова S3 (вкл. DNS), circuit breaker |
MAX_UPLOAD_BYTES, MAX_IMAGE_PIXELS |
10485760, 40000000 | не выше контракта (иначе API не стартует) |
MAX_CONCURRENT_UPLOADS, UPLOAD_QUEUE_TIMEOUT_SECONDS |
4, 5 | слоты загрузки на реплику |
UPLOAD_READ_TIMEOUT_SECONDS |
60 | дедлайн приёма тела |
IMAGE_DECODE_CONCURRENCY |
2 | разборов изображения на реплику |
ATTACHMENT_GC_INTERVAL_SECONDS, ATTACHMENT_GC_GRACE_SECONDS, ORPHAN_SWEEP_INTERVAL_SECONDS |
300, 900, 3600 | src/reconcile.py |
FAULT_INJECTION |
пусто | только сервисы api-fault-* |
Доказательства критериев
Где получены результаты. Код проверен на стенде из тех же компонентов, запущенных нативными процессами: PostgreSQL 16, Redis 7, SeaweedFS 4.50 (тот же бинарник, те же флаги), HAProxy 2.8.30 с этим haproxy.cfg (статические серверы вместо DNS-шаблона) и 2 реплики API. Среда: Windows 10, Ryzen 5 7500f, 32 GB, Python 3.12, без cgroup-лимитов. Результаты — в evidence/.
Уровень 3
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
| Публичный smoke | make test |
PASS: файл → сообщение с attachment_ids → download Бобом, SHA-256 совпал, Ева 404 | evidence/sandbox/smoke.txt; evidence/smoke.txt |
| Возможности lab3 сохранены | run_all.py, in-network storage, failover, persistence |
47 HTTP + 12 DB-тестов lab2–3 OK; failover/persistence PASS | evidence/sandbox/student-tests.txt |
| S3 в общем стенде; метаданные в PostgreSQL, байты в приватном бакете | compose.yaml, ops.py api-fs, s3-check |
API без volumes, read-only rootfs; объекты только в s3data |
evidence/s3_private.txt |
| 201 ready после сохранения; оригинал побайтно | test_png_roundtrip…, test_exactly_max_size_is_accepted |
201, status=ready, variants=[]; SHA-256 и Content-Length совпадают (вкл. ровно 10 485 760 байт) |
evidence/sandbox/student-tests.txt |
| Message с attachment_ids, посторонний без доступа | smoke, test_message_with_attachments… |
порядок id сохранён; Ева: 404 на метаданные и bytes | там же |
| PNG/JPEG ≤10 MiB, ≤40 Мп; MIME по содержимому; опасные имена; лимиты до распаковки | test_too_large_*, test_too_many_pixels, test_mime_spoofing_is_415, test_dangerous_filenames_are_400 |
413/413/415/400; 48 Мп файл 50 КБ → 413 без распаковки | там же |
| Upload → стоп обслужившей реплики → download через другую | make test-failover ×2 |
PASS, 138–139 записей, 0 ошибок; файл скачан после остановки | evidence/sandbox/failover.txt |
| Restart стенда сохраняет метаданные и оригинал | make test-persistence |
PASS; сменились PID PostgreSQL, SeaweedFS и обеих реплик; файл скачан со старым токеном | evidence/sandbox/persistence.txt |
| Недоступность S3, чужой чат, restart | s3_outage.py; test_attachment_from_other_chat…; persistence |
503 за 1.0–1.7 с, чат работает; 404; PASS | evidence/sandbox/s3_outage.json |
Уровень 4
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|---|---|---|---|
| Тесты: большой файл, повреждённое изображение, подмена MIME, чужое attachment_id, файл другого чата; нет 500 | student-tests/test_attachments.py (17 тестов) |
413 (Content-Length и chunked), 415 (обрезанный PNG/JPEG, неверный CRC, неверный объём IDAT, мусор, пустое тело, GIF), 415 (6 подмен MIME), 404 (чужое/неизвестное id, файл другого чата, Ева в своём чате), 400 (12 опасных имён); каждый негативный ответ < 500 в общем формате | evidence/sandbox/student-tests.txt |
| Обрыв загрузки и отказ между S3/БД не оставляют вечных объектов; компенсация/сверка с grace | test_attachment_consistency.py (10 тестов) в сети стенда |
обрыв → 0 строк, 0 объектов; ошибка S3 → 503 + нет строки; ошибка БД после PUT → 503 + объект удалён; падение процесса после PUT → pending + объект → сборщик удаляет оба; dry-run ничего не меняет; повтор no-op; свежие/ready/используемые не удаляются | evidence/sandbox/consistency.txt; evidence/consistency.txt |
| Лимиты/таймауты/потоковая обработка; ≥10 одновременных загрузок с замером пика | upload_memory.py --concurrency 10/20 |
10×9.5 MiB ×3 волны: 30/30 201, пик RSS 156–166 MiB на реплику (база 88–95); при 20 одновременных пик тот же (159–162); без лимитера 262–291 MiB | evidence/sandbox/upload_memory_*.json |
| Bootstrap идемпотентен | повторный s3-init |
already exists (idempotent no-op), все проверки ok |
evidence/sandbox/s3_bootstrap.txt |
| Отдельные S3 credentials с ограниченными правами | s3_bootstrap проверки |
API-ключи: put/get своего бакета — ok; CreateBucket/DeleteBucket — AccessDenied | evidence/sandbox/s3_private.txt |
| Админ-консоль не в общей сети | ops.py s3-check |
9333/8888/8080/19333/18888 закрыты, S3 :8333 — единственный | там же |
| Private bucket вне API | ops.py s3-check |
анонимный GET реального объекта → 403, листинг → 403; с ключами API тот же объект → 200, SHA-256 совпал | там же |
Эксперименты и отказы
Стенд замеров: Windows 10, Ryzen 5 7500f, 32 GB; все процессы (2 реплики API, HAProxy, PostgreSQL, Redis, SeaweedFS, генератор нагрузки) на одном хосте. Реплика: 1 процесс Uvicorn, threadpool по умолчанию. Файлы — синтетический шум, PNG без сжатия, 9.5 MiB (несжимаемые, проверка проходит по полной программе). Память — VmRSS процесса реплики (опрос каждые 20 мс) и пик RSS, который считает ядро (VmHWM, обнуляется перед прогоном). Загрузки через LB (roundrobin по двум репликам), повторы — волнами.
Гипотеза: пик памяти реплики ≈ база + MAX_CONCURRENT_UPLOADS × (~2 × размер файла) и не зависит от числа одновременных клиентов; без лимитера память растёт линейно с конкуренцией.
| Прогон | Одновременно | Загрузок | 201 / SHA ok | p50 / p95, с | База → пик RSS, MiB (реплика 1 / 2) |
|---|---|---|---|---|---|
| до исправлений (zlib tail, bytes в botocore) | 10 | 30 | 30 / 30 | 2.01 / 2.29 | 124 → 237 / 124 → 244 |
| исправления кода, malloc по умолчанию | 10 | 30 | 30 / 30 | 1.20 / 1.34 | 124 → 187 / 124 → 187 |
| + MALLOC_ARENA_MAX=2, mmap ≥ 1 MiB (итог) | 10 | 30 | 30 / 30 | 1.32 / 2.07 | 95 → 163 / 95 → 156 (пик ядра VmHWM 166 / 165) |
| итог, вдвое больше клиентов | 20 | 40 | 40 / 40 | 2.16 / 3.08 | 115 → 162 / 97 → 159 |
лимитер выключен (MAX_CONCURRENT_UPLOADS=64) |
20 | 40 | 40 / 40 | 2.90 / 3.03 | 88 → 262 / 89 → 291 |
Вывод: гипотеза подтверждена. Прирост ~61–72 MiB ≈ 4 слота × 2 × 9.5 MiB. При удвоении клиентов пик не растёт (лишние ждут слот, их тело ещё не прочитано), растёт только задержка. Без лимитера пик +170–200 MiB при той же пропускной способности: при лимите 256 MiB контейнер был бы убит OOM. Поэтому лимит API — 320M, запас ~155 MiB. Микрозамеры (tracemalloc, 9.5 MiB PNG): проверка 19 MiB → 1.5 MiB и 0.17 → 0.06 с; put_object(bytes) 25 MiB → BytesIO 0.1 MiB. Ограничения: один хост и общий CPU для клиента и сервера; RSS не включает page cache; в Docker тот же скрипт (--docker) читает VmHWM процесса API внутри контейнера, docker stats и cgroup memory.peak.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|---|---|---|---|
| SIGTERM обслужившей реплики (public failover ×2) | записи идут через другую, файл скачивается | 138/139 записей, 0 ошибок, файл совпал | первая запись после hook ≤ 4.5 с (hook ждёт drain 3 с); потерь нет |
Каждая реплика по очереди под нагрузкой (failover_series.py) |
0 ошибок, LB DOWN < 2 с | DOWN 1.30 / 1.53 с, 0 ошибок, RPS 318 → 239 / 283 → 243 | возврат в ротацию 2.9 / 3.1 с; данные целы |
| Рестарт API + PostgreSQL + Redis + S3 + LB | данные, сессия и файл сохранены | PASS, PID всех процессов сменились | ~38 с hook (из них прогрев S3 16 с); потерь нет |
| Остановка S3 | файлы → 503 быстро, остальное работает | upload 503 за 1.0–1.7 с, download 503 за 1.0 с, readiness 200, сообщения 201 | после старта S3 прогрев 17 с; старый файл побайтно цел |
| S3 «висит» (принимает соединение, не отвечает) | 503 в пределах дедлайна, не 504 | upload 503 за 10.0 с, download 503 за 5.0 с | прогрев 16 с; старый файл цел |
Ошибка S3 PUT (api-fault-s3) |
503, строки нет | 503, 0 строк | сразу |
Ошибка БД после PUT (api-fault-db) |
503, объект удалён | 503, 0 строк, число объектов не изменилось | сразу |
Падение процесса после PUT (api-fault-crash) |
pending + объект, убирает сборщик | 1 pending + объект → после grace (сдвинутого в тесте) 0 / 0 | ≤ grace + интервал (900 + 300 с по умолчанию) |
| Обрыв клиентом на 0.2 из 5 MiB | ничего не записано | 0 строк, объектов столько же | сразу |
Нагрузка lab3 (tests/load.py, 20 с, c=4) |
без регрессии | 276 RPS, 0 ошибок, p50/p95/p99 13/24/33 мс | — |
Ограничения и следующие шаги
- Один Docker-host, один PostgreSQL, один процесс SeaweedFS без репликации: отказ host/БД/S3 не переживается. S3 недоступен → файловые операции 503 (остальное работает). Восстановление S3 занимает 15–30 с прогрева.
- Тело загрузки держится в памяти процесса (≤ 10 MiB × 4 слота). Это ограничено и измерено, но не «настоящий» стриминг в S3. Следующий шаг — multipart upload кусками по 5 MiB с проверкой по частям или presigned upload (трек 1).
- Progressive JPEG проверяется структурно (маркеры, EOI), без декодирования пикселей: экономия ~115 MiB на 40 Мп. Испорченные энтропийные данные внутри структурно целого progressive-файла не обнаруживаются (их увидит lab5 при создании thumbnail →
failed). missing_objects(ready без байтов) сборщик только сообщает; решение о судьбе метаданных — за оператором.- Ключи идемпотентности, созданные репликой lab3 до обновления, имели отпечаток без
attachment_ids; повтор такого ключа на lab4 даст 409 (окно 24 ч после rolling update). - SIGKILL SeaweedFS через 10 с при остановке: безопасно для подтверждённых записей при живом ядре ОС, не при потере питания.
- Docker-прогон (
collect_evidence.py) выполняется на машине студента. Нативный прогон подтверждает код, HAProxy-конфиг и флаги SeaweedFS, но не compose-обвязку.
Вопросы защиты — кратко
- Почему файл в Docker volume одной API-реплики не равен объектному хранилищу? Volume привязан к одному контейнеру и host. Другая реплика его не видит, поэтому после остановки загрузившей реплики файл недоступен (тест failover это и проверяет). У volume нет общего API доступа, ключей с правами и проверки целостности (Content-MD5), он не масштабируется независимо от API, а с read-only rootfs его пришлось бы ещё и открывать на запись. S3 — общий сервис с собственными ACL, его читают все реплики.
- Когда можно честно вернуть 201? Только после того, как S3 подтвердил PUT (с проверкой MD5) и COMMIT перевёл строку в
ready. Раньше — нельзя: «готовое» вложение могло бы не скачаться. - S3 PUT прошёл, COMMIT — нет? Остаются невидимая pending-строка и объект. Ошибку БД API компенсирует сам (удаляет объект, 503). Если процесс умер, сборщик после grace сначала атомарно удаляет pending-строку, потом объект. Объект без строки убирает проход по бакету. Строка всегда создаётся раньше объекта, поэтому «вечных» объектов нет.
- Почему случайный ключ и приватный бакет не заменяют ACL приложения? Приватный бакет защищает от анонимного доступа к S3, но клиенты в него и не ходят: все запросы идут через API с ключами API, которые читают любой объект бакета. Кто из пользователей что может скачать, знает только приложение (членство в чате). Случайный ключ — защита «неугадываемостью»: он может утечь (лог, ссылка), а доступ после выхода из чата или для чужого пользователя он не ограничивает. Поэтому каждый запрос проверяет членство и отвечает 404 постороннему.