Files
mtusi2026lab6-fork/docs/lab4/REPORT.md
T

274 lines
45 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Отчёт — лабораторная 4
> Перенесено из корня репозитория lab4 при переходе на lab5 без изменений по существу. Пути `evidence/...` в этом файле указывают на `docs/lab4/evidence/`. Отчёт lab5 — [REPORT.md](../../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`), glibc `mallopt` (MALLOC_ARENA_MAX, MALLOC_MMAP_THRESHOLD_). Помощь ИИ (Claude) — при проектировании схемы согласованности БД/S3, проверки изображений, тестов, экспериментов и при написании отчёта.
Решения lab3 (балансировщик, реплики, идемпотентность, drain, rolling update) перенесены без изменений семантики; их отчёт и доказательства сохранены в [docs/lab3/REPORT.md](../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 не используется).
```sh
# 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).
```sh
# Публичные проверки
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`):
1. Дешёвые проверки до чтения тела: аутентификация → `filename` (400) → `Content-Type` только `image/png|image/jpeg` (415) → `Content-Length > 10 MiB` → 413 без чтения → членство в чате (404) → слот загрузки (`MAX_CONCURRENT_UPLOADS=4` на реплику; ожидание ≤ 5 с, иначе 503 + `Retry-After`).
2. Тело читается потоком; как только счётчик превысил 10 MiB — 413 (и для chunked без `Content-Length`). Остаток тела (до 10 MiB) дочитывается в никуда, чтобы клиент получил 413, а не обрыв. Общий дедлайн приёма — `UPLOAD_READ_TIMEOUT_SECONDS=60` (медленный клиент → 400). Обрыв клиентом → ничего не записано.
3. Проверка содержимого (`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 должен увидеть тот же формат и размеры.
4. `[1]` `INSERT attachments … state='pending'` (с проверкой членства в том же операторе) — **COMMIT до S3**.
5. `[2]` S3 `PutObject` с `Content-MD5` (S3 сам отклоняет повреждённую передачу — BadDigest; проверено) и `x-amz-meta-sha256`.
6. `[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`. Identity `anonymous` не объявлена.
- **Проверка приватности вне 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:
1. Переход контракта 3 → 4: поля `attachment_ids` в запросе и ответе сообщения (отсутствие = `[]` и для отпечатка идемпотентности; порядок значим), три новых endpoint.
2. Сервисы `s3`, `s3-init`, volume `s3data`, сеть `storage`; секреты S3; профиль `faults`.
3. HAProxy: для `POST …/attachments` — `timeout server 90s` (`http-request set-timeout`), остальным запросам — прежние 10 с.
4. Лимит памяти API 256M → 320M (4 загрузки по 10 MiB, замер ниже); glibc malloc tuning в `Dockerfile`.
5. `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](../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 постороннему.