Author SHA1 Message Date
ng14 3d5c6a6689 ЛР7 2026-11-08 00:33:25 +03:00
148 changed files with 21441 additions and 79 deletions
+8 -20
View File
@@ -1,20 +1,8 @@
.git
.github
.env
.env.*
!.env.example
secrets
certs
volumes
data
backups
*.key
*.pem
*.p12
*.pfx
*.jks
.venv
__pycache__
node_modules
evidence
.DS_Store
# Белый список: в контекст сборки попадает только то, что явно разрешено ниже.
# Так в образ точно не утекут .env, secrets/, .git, тесты и отчёты.
*
!requirements.txt
!src/
!migrations/
**/__pycache__
**/*.pyc
+124 -4
View File
@@ -1,23 +1,34 @@
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
# These are logical interface suggestions; map actual framework names in REPORT.md.
#
# lab7: в .env НЕТ ни одного секрета. Пароли и ключи живут в secrets/ (оператор) и в OpenBao (приложение).
# Строки *_FILE ниже — имена интерфейса из skeleton: в compose.yaml у api и worker они переопределены
# пустыми (секретов-файлов у приложения нет), а migrate получает DB_PASSWORD_FILE. Соответствие — REPORT.md.
APP_HOST=0.0.0.0
# Порт реплики внутри сети edge: HTTPS + обязательный клиентский сертификат lb (tlsserver.py).
APP_PORT=8080
# Внутренний healthcheck-слушатель на 127.0.0.1 контейнера (только /health/live и /health/ready).
APP_HEALTH_PORT=8081
APP_ENV=lab
SESSION_TTL_SECONDS=3600
# Choose credentials locally. File paths contain no secret values.
# lab7: у api/worker не используется (адрес без пароля задан в compose.yaml, пароль роли — из OpenBao).
DATABASE_URL_FILE=/run/secrets/database_url
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
SESSION_STORE=postgres
# lab7: не используется (CACHE_URL=valkeys://messenger@valkey:6379/0 в compose.yaml, пароль — из OpenBao).
CACHE_URL_FILE=/run/secrets/cache_url
API_REPLICAS=2
IDEMPOTENCY_TTL_SECONDS=86400
S3_ENDPOINT=https://s3:9000
S3_REGION=us-east-1
S3_BUCKET=messenger-attachments
# lab7: не используются (ключи S3 у api и worker разные и приходят из OpenBao).
S3_ACCESS_KEY_ID_FILE=/run/secrets/s3_access_key_id
S3_SECRET_ACCESS_KEY_FILE=/run/secrets/s3_secret_access_key
MAX_UPLOAD_BYTES=10485760
MAX_IMAGE_PIXELS=40000000
# lab7: не используется (BROKER_URL=amqps://broker:5671/messenger, вход по сертификату, без пароля).
BROKER_URL_FILE=/run/secrets/broker_url
WORKER_CONCURRENCY=2
JOB_MAX_ATTEMPTS=5
@@ -25,17 +36,126 @@ JOB_TIMEOUT_SECONDS=60
STAGING_RETENTION_SECONDS=86400
OTEL_SERVICE_NAME=messenger-api
# Worker must set a distinct service.name.
# lab7: OTLP по mTLS в шлюз otlp-gw (DNS-имя otel-collector), сертификаты — OTEL_EXPORTER_OTLP_*CERTIFICATE в compose.yaml.
OTEL_EXPORTER_OTLP_ENDPOINT=https://otel-collector:4318
OTEL_EXPORTER_OTLP_PROTOCOL=http/protobuf
OTEL_RESOURCE_ATTRIBUTES=deployment.environment.name=lab
# TLS and OpenBao: actual paths/ports depend on your implemented trust matrix.
PUBLIC_BASE_URL=https://localhost:8443
TLS_CA_FILE=/run/secrets/ca.crt
TLS_CERT_FILE=/run/secrets/service.crt
TLS_KEY_FILE=/run/secrets/service.key
# Публичный CA и CRL стенда (secrets/tls/ca смонтирован в /run/ca), сертификат своей identity (/run/tls).
TLS_CA_FILE=/run/ca/ca.crt
TLS_CRL_FILE=/run/ca/crl.pem
TLS_CERT_FILE=/run/tls/tls.crt
TLS_KEY_FILE=/run/tls/tls.key
# Как часто API перечитывает CRL (отзыв старого сертификата lb действует без рестарта).
TLS_CRL_CHECK_SECONDS=5
BAO_ADDR=https://openbao:8200
BAO_CACERT=/run/secrets/bao-ca.crt
BAO_CACERT=/run/ca/ca.crt
# No root token here. Bootstrap operator -> short-lived service auth -> scoped token.
# lab7: вход — cert auth (сертификат identity api/worker), роль и путь секрета задаёт compose.yaml (BAO_ROLE,
# BAO_SECRET_PATH). Секрет перечитывается раз в BAO_REFRESH_SECONDS; без OpenBao процесс ждёт при старте
# BAO_STARTUP_WAIT_SECONDS и завершается.
BAO_REFRESH_SECONDS=10
BAO_STARTUP_WAIT_SECONDS=90
ARGON2_MEMORY_KIB=19456
ARGON2_ITERATIONS=2
ARGON2_PARALLELISM=1
# Бюджет login DoS (с lab7): одновременных проверок пароля на реплику и сколько ждать места (иначе 503).
ARGON2_MAX_CONCURRENCY=2
ARGON2_QUEUE_SECONDS=2
# Лимиты частоты (общие для реплик, Valkey): 429 + Retry-After.
LOGIN_RATE_PER_IP=120
LOGIN_RATE_WINDOW_SECONDS=60
LOGIN_FAILURES_PER_USER=10
LOGIN_FAILURE_WINDOW_SECONDS=300
REGISTER_RATE_PER_IP=300
REGISTER_RATE_WINDOW_SECONDS=60
# Тело JSON-запроса (кроме загрузки файла) — не больше, иначе 413.
MAX_JSON_BODY_BYTES=65536
# --- Дополнительные настройки этого решения (значения по умолчанию из src/messenger/config.py) ---
# API_REPLICAS — число реплик API за балансировщиком (deploy.replicas в compose.yaml).
# IDEMPOTENCY_TTL_SECONDS приложением не читается: ключ хранится вместе с сообщением
# бессрочно, то есть не меньше 24 ч из контракта (migrations/004_message_idempotency.sql).
# Сколько секунд сессия может лежать в кэше Valkey (не дольше самой сессии).
SESSION_CACHE_TTL_SECONDS=30
# Пул соединений с PostgreSQL и таймауты.
DB_POOL_MIN_SIZE=1
DB_POOL_MAX_SIZE=10
DB_POOL_TIMEOUT_SECONDS=3
DB_CONNECT_TIMEOUT_SECONDS=3
DB_STATEMENT_TIMEOUT_MS=5000
# Valkey: таймаут операции, размер пула соединений, период фоновой проверки (PING).
CACHE_TIMEOUT_MS=300
CACHE_POOL_MAX_SIZE=20
CACHE_CHECK_INTERVAL_SECONDS=1
# Остановка по SIGTERM: сначала столько секунд /health/ready = 503 (уход из балансировки),
# потом не дольше GRACEFUL_SHUTDOWN_SECONDS на начатые запросы.
SHUTDOWN_DRAIN_SECONDS=3
GRACEFUL_SHUTDOWN_SECONDS=8
# S3: таймауты и число попыток (недоступный S3 -> быстрый 503).
S3_CONNECT_TIMEOUT_SECONDS=2
S3_READ_TIMEOUT_SECONDS=5
S3_MAX_ATTEMPTS=2
# Общий предел на одну операцию S3, включая DNS: ответ клиенту не дольше этого.
S3_OPERATION_TIMEOUT_SECONDS=6
# Readiness (с lab5): S3 проверяется фоном раз в S3_HEALTH_INTERVAL_SECONDS; нет успешной
# проверки дольше S3_HEALTH_MAX_AGE_SECONDS -> /health/ready = 503.
S3_HEALTH_INTERVAL_SECONDS=1
S3_HEALTH_MAX_AGE_SECONDS=3
# Приём файла: в памяти не больше UPLOAD_SPOOL_BYTES на загрузку (остальное — временный файл,
# удаляется после запроса); вся передача не дольше UPLOAD_TIMEOUT_SECONDS. Проверка структуры
# файла (без декодирования) — не больше IMAGE_CHECK_CONCURRENCY одновременно на реплику,
# очередь ждёт не дольше IMAGE_CHECK_WAIT_SECONDS (иначе 503).
UPLOAD_SPOOL_BYTES=1048576
UPLOAD_TIMEOUT_SECONDS=60
IMAGE_CHECK_CONCURRENCY=2
IMAGE_CHECK_WAIT_SECONDS=10
# --- с lab5: outbox, worker, повторы ---
# WORKER_CONCURRENCY — заданий одновременно
# и prefetch брокера; JOB_MAX_ATTEMPTS — всего попыток (первая + повторы);
# JOB_TIMEOUT_SECONDS — лимит времени одной попытки (дочерний процесс убивается);
# STAGING_RETENTION_SECONDS — сколько хранится оригинал failed-вложения для replay.
# Число worker-контейнеров (deploy.replicas в compose.yaml).
WORKER_REPLICAS=1
# Лимит памяти одной попытки (адресное пространство дочернего процесса, RLIMIT_AS).
WORKER_MEMORY_LIMIT_MB=640
# Backoff с jitter: пауза перед попыткой n+1 — случайная в [d/2, d], d = min(MAX, BASE * 2^(n-1)).
RETRY_BASE_SECONDS=2
RETRY_MAX_SECONDS=60
# Lease: аренда задания на JOB_LEASE_SECONDS, продление каждые JOB_HEARTBEAT_SECONDS;
# поиск истёкших аренд раз в REAPER_INTERVAL_SECONDS.
JOB_LEASE_SECONDS=30
JOB_HEARTBEAT_SECONDS=10
REAPER_INTERVAL_SECONDS=5
# Страховка от потерянного сообщения: queued без движения дольше этого — отправить ещё раз.
QUEUED_REPUBLISH_SECONDS=600
# Relay outbox: опрос таблицы (кроме мгновенного сигнала после загрузки) и размер пачки.
RELAY_POLL_SECONDS=1
RELAY_BATCH_SIZE=50
# Качество вариантов: JPEG (thumbnail, crop) и WebP (optimized; method 0..6 — скорость/размер).
JPEG_QUALITY=85
WEBP_QUALITY=80
WEBP_METHOD=4
# Уборка объектов S3 (фоновый поток worker): grace period, период, хранение отправленного outbox.
ATTACHMENT_GRACE_SECONDS=900
CLEANUP_INTERVAL_SECONDS=300
OUTBOX_RETENTION_SECONDS=604800
# Внедрение отказов для проверок (faults.py). ТОЛЬКО учебный стенд: точки отказа включаются
# файлами в /tmp/faults внутри контейнера, тесты создают их через docker exec.
FAULTS_ENABLED=1
# --- с lab6: наблюдаемость (OpenTelemetry SDK в API и worker -> otel-collector) ---
# OTEL_SERVICE_NAME выше — для API; у worker в compose.yaml свой: messenger-worker.
# service.version = APP_VERSION, service.instance.id = alias процесса (как X-Instance-Id, с lab7 — случайный).
# Новые имена HTTP-метрик/атрибутов semantic conventions (http.server.request.duration в секундах).
OTEL_SEMCONV_STABILITY_OPT_IN=http
# Контекст трассы — только W3C traceparent/tracestate (без baggage: его нет в jobs.schema.json).
OTEL_PROPAGATORS=tracecontext
# Метрики отправляются раз в 10 с (миллисекунды).
OTEL_METRIC_EXPORT_INTERVAL=10000
# Одна отправка любого сигнала — не дольше 5 с. ВНИМАНИЕ: Python SDK 1.45 читает это значение
# в СЕКУНДАХ (в спецификации — миллисекунды): 10000 здесь означало бы ~3 часа ожидания.
OTEL_EXPORTER_OTLP_TIMEOUT=5
# OTEL_SDK_DISABLED=true — выключить телеметрию (останутся только JSON-логи в stdout).
+14
View File
@@ -0,0 +1,14 @@
# Git на Windows (core.autocrlf=true) меняет LF на CRLF при checkout. Для этих файлов это ломает запуск:
# sh-скрипт с \r не выполняется, а конфиги Valkey и HAProxy читаются внутри Linux-контейнеров.
*.sh text eol=lf
*.sql text eol=lf
*.conf text eol=lf
*.cfg text eol=lf
# cmd.exe ожидает CRLF.
*.cmd text eol=crlf
# С lab7: конфиги OpenBao, RabbitMQ, Prometheus/Loki/Tempo/Grafana читаются в Linux-контейнерах.
*.hcl text eol=lf
*.yml text eol=lf
*.yaml text eol=lf
*.json text eol=lf
infra/rabbitmq/enabled_plugins text eol=lf
+3
View File
@@ -30,3 +30,6 @@ coverage/
.vscode/
# Keep small, sanitized evidence summaries in evidence/ under version control.
# Inspect git diff --cached: ignore rules are not a secret scanner.
.scan/
# Локальные правки портов под конкретную машину (WinNAT и т.п.) — не коммитить.
compose.override.yaml
+66
View File
@@ -0,0 +1,66 @@
# Базовый образ закреплён точной версией (не latest), чтобы сборка была воспроизводимой.
# Один образ на все процессы приложения: API (python -m messenger), worker (python -m messenger.worker),
# миграции (python -m messenger.migrate) и настройку S3 (python -m messenger.s3bootstrap).
FROM python:3.12.8-slim-bookworm
# Не создавать .pyc, сразу выводить логи (без буфера), не кэшировать скачанные пакеты.
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
PIP_DISABLE_PIP_VERSION_CHECK=1 \
MALLOC_ARENA_MAX=2 \
OPENBLAS_NUM_THREADS=1 \
OMP_NUM_THREADS=1
# MALLOC_ARENA_MAX=2 (с lab4): glibc по умолчанию заводит отдельную «кучу» на каждый поток,
# и освобождённая после загрузки файла память не переиспользуется другими потоками.
# Эксперимент make upload-memory: 6 одновременных загрузок по 8,8 МиБ на реплику дали рост
# пика RSS ~105 МиБ без этой настройки и ~30 МиБ с ней (REPORT.md lab4).
# OPENBLAS_NUM_THREADS / OMP_NUM_THREADS=1 (с lab5): numpy (нужен simplejpeg в worker) иначе заводит
# пул потоков на каждое ядро и резервирует под них память, а это мешает лимиту памяти дочернего
# процесса обработки (RLIMIT_AS, sandbox.py).
WORKDIR /srv
# С lab7 (разбор make scan-images, REPORT.md): базовый python:3.12.8-slim-bookworm собран на Debian 12.9,
# в нём устаревшие libssl3 (через неё идёт весь TLS приложения: OpenBao, PostgreSQL, брокер, S3, mTLS реплики),
# gnutls, perl, pcre2, apt. Ставим исправления безопасности bookworm при сборке; список пакетов чистим,
# в образе он не нужен. Тег базового образа остаётся закреплённым.
RUN apt-get update \
&& apt-get -y --no-install-recommends upgrade \
&& rm -rf /var/lib/apt/lists/*
# Сначала только список зависимостей: пока он не меняется, Docker берёт этот слой
# из кэша и не переустанавливает пакеты при каждой правке кода.
# --only-binary: только готовые wheel (psycopg-binary, argon2), без компиляции в образе.
COPY requirements.txt .
RUN pip install --only-binary=:all: -r requirements.txt
COPY src/ ./
# SQL-миграции едут в образе вместе с кодом: версия схемы всегда соответствует версии приложения.
# Применяет их сервис migrate (`python -m messenger.migrate`), реплики API только проверяют схему.
COPY migrations/ ./migrations/
# Непривилегированный пользователь: если приложение взломают, у атакующего не будет root.
# С lab7 в compose ещё read_only корень, cap_drop ALL и no-new-privileges.
RUN useradd --system --uid 10001 --no-create-home --shell /usr/sbin/nologin app
USER app
# Версия сборки (с lab3): пишется в лог при старте, по ней student-tests/rolling_update.py
# проверяет, что все реплики заменены новой версией. ARG стоит в конце, чтобы смена версии
# не пересобирала слои с зависимостями и кодом.
ARG APP_VERSION=dev
ENV APP_VERSION=${APP_VERSION}
EXPOSE 8080
# Docker сам периодически опрашивает /health/ready и показывает статус healthy/unhealthy.
# Ready проверяет PostgreSQL и S3, а после SIGTERM отвечает 503 (реплика уходит из балансировки).
# С lab7 основной порт — только HTTPS с клиентским сертификатом lb, поэтому healthcheck ходит
# во внутренний слушатель 127.0.0.1:APP_HEALTH_PORT (healthcheck.py), невидимый из сети.
# У worker нет HTTP: его healthcheck задан в compose.yaml (файл /tmp/worker.alive).
# curl в slim-образе нет, поэтому проверяем средствами Python. Частоту задаёт compose.yaml.
HEALTHCHECK --interval=10s --timeout=3s --start-period=20s --retries=3 \
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:%s/health/ready' % os.environ.get('APP_HEALTH_PORT', '8081'), timeout=2)"]
# Exec-форма (JSON-массив): python запускается напрямую как PID 1 и сам получает SIGTERM.
CMD ["python", "-m", "messenger"]
+363 -5
View File
@@ -1,13 +1,42 @@
PYTHON ?= python3
BASE_URL ?= https://localhost:8443
CA_FILE ?=
# 127.0.0.1, а не localhost: на части Windows-машин localhost резолвится очень медленно.
# С lab7 — HTTPS. Сертификат lb выдан на lb, localhost и 127.0.0.1, поэтому проверка имени проходит.
BASE_URL ?= https://127.0.0.1:8443
# API с SESSION_TTL_SECONDS=2 (сервис api-short-ttl, профиль ttl), тоже через балансировщик.
BASE_URL_TTL ?= https://127.0.0.1:8444
# Публичный CA стенда (make pki). Относительный путь: команды выполняются из корня репозитория.
CA_FILE ?= secrets/tls/ca/ca.crt
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
# Передаём адреса и CA собственным тестам через окружение (работает и в cmd, и в sh).
export BASE_URL
export BASE_URL_TTL
export CA_FILE
TOOLS = docker compose --profile tools run --rm
.PHONY: help check validate test load test-persistence test-failover test-security
.PHONY: help check validate test load test-persistence test-failover \
secrets up down ps logs restore student-test race expiry failure-valkey failure-postgres \
failure-valkey-pause db-test explain demo cache-stats \
balancing idempotency failover persistence failover-metrics rolling-update load-profile check-stack report-tables \
attachments attachment-failover failure-s3 s3-checks upload-memory cleanup s3-bootstrap \
worker-stop worker-start worker-outage redelivery outbox-crash worker-crash retry-replay lease concurrency \
staging-cleanup cleanup-race imaging-test jobs failed job replay queues \
telemetry-check dashboard-check incident-worker incident-db incident-db-down telemetry-outage \
telemetry-persistence alerts telemetry-logs \
pki pki-show pki-crl rotate-lb-cert bootstrap bao-status bao-init bao-unseal bao-seal bao-bootstrap \
bao-revoke-tokens bao-token-ttl rotate-db-secret test-security tls-matrix acl-matrix limits-test \
scan-deps scan-images argon2-bench
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@echo "secrets/up/down/ps/logs/restore: stand; student-test, race, expiry, failure-valkey, failure-postgres, failure-valkey-pause, db-test, explain, demo, cache-stats: own checks (lab2)"
@echo "balancing, idempotency, failover, persistence, failover-metrics, rolling-update, load-profile, check-stack, report-tables: own checks (lab3)"
@echo "attachments, attachment-failover, failure-s3, s3-checks, upload-memory, cleanup, s3-bootstrap: own checks (lab4)"
@echo "worker-stop, worker-start, worker-outage, redelivery, outbox-crash, worker-crash, retry-replay, lease, concurrency, staging-cleanup, cleanup-race, imaging-test: own checks (lab5)"
@echo "jobs, failed, job ID=..., replay ID=..., queues: operator commands (lab5)"
@echo "telemetry-check, dashboard-check, incident-worker, incident-db, incident-db-down, telemetry-outage, telemetry-persistence, alerts, telemetry-logs: observability (lab6)"
@echo "bootstrap, pki, pki-show, pki-crl, rotate-lb-cert, bao-status/init/unseal/seal/bootstrap/revoke-tokens/token-ttl, rotate-db-secret: security operations (lab7)"
@echo "test-security, check-stack, tls-matrix, acl-matrix, limits-test, scan-deps, scan-images: security checks (lab7)"
check:
$(PYTHON) scripts/check_contract.py
@@ -25,9 +54,338 @@ test-persistence:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2)
$(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-security:
$(PYTHON) tests/security.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-failover:
@test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2)
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-security:
$(PYTHON) tests/security.py --base-url "$(BASE_URL)" $(TLS_ARGS)
# ---------- стенд ----------
secrets:
sh scripts/init-secrets.sh
# Полный первый запуск из чистого clone (оператор): секреты, CA и сертификаты, OpenBao init/unseal/bootstrap, стенд.
# Повторять безопасно: каждый шаг идемпотентен (init второй раз ничего не делает).
bootstrap: secrets
docker compose build api
$(MAKE) pki
docker compose up -d --wait openbao
$(MAKE) bao-init bao-unseal bao-bootstrap
$(MAKE) up
up:
docker compose up -d --build --wait
# Без -v: volumes с данными (в том числе baodata OpenBao) сохраняются. После up OpenBao снова sealed:
# make bao-unseal. Удаление данных — только осознанно: docker compose down -v (тогда и make bao-init заново).
down:
docker compose --profile ttl --profile tools down
# ID контейнера + состояние. ID реплики api = её X-Instance-Id.
ps:
docker compose ps -a --format "table {{.Service}}\t{{.ID}}\t{{.Status}}"
logs:
docker compose logs --tail 50 api worker broker lb s3 s3-init otlp-gw otel-collector openbao
# ---------- lab7: PKI и OpenBao (оператор) ----------
# Локальный CA и сертификаты всех identity в secrets/tls (идемпотентно: недостающие и истекающие).
pki:
$(TOOLS) pki init
pki-show:
$(TOOLS) pki show
pki-crl:
$(TOOLS) pki crl
# Ротация leaf-сертификата lb без пересборки образов и без остановки: новый сертификат на месте
# старого -> HAProxy перечитывает его (USR2, мягкий reload) -> старый серийный номер в CRL.
# Реплики API перечитывают CRL раз в TLS_CRL_CHECK_SECONDS: старый сертификат lb больше не пустят.
rotate-lb-cert:
$(TOOLS) pki issue lb
docker compose kill -s USR2 lb
sleep 5
$(TOOLS) pki revoke-previous lb
bao-status:
-$(TOOLS) ops status
bao-init:
$(TOOLS) ops init
bao-unseal:
$(TOOLS) ops unseal
bao-seal:
$(TOOLS) ops seal
bao-bootstrap:
$(TOOLS) ops bootstrap
bao-revoke-tokens:
$(TOOLS) ops revoke-tokens
# make bao-token-ttl ROLE=api TTL=30s (проверка истечения токена; вернуть: TTL=15m)
bao-token-ttl:
@test -n "$(ROLE)" -a -n "$(TTL)" || (echo "make bao-token-ttl ROLE=api|worker TTL=30s"; exit 2)
$(TOOLS) ops token-ttl $(ROLE) $(TTL)
# Ротация рабочего секрета: пароль роли БД messenger_api (ALTER ROLE + новая версия KV в OpenBao).
rotate-db-secret:
$(TOOLS) ops rotate-db
# ---------- lab7: проверки безопасности ----------
# tls-matrix, acl-matrix, limits-test запускают скрипты, которые пишет студент (см. инструкцию в REPORT.md).
tls-matrix:
@test -f student-tests/tls_matrix.py || (echo "student-tests/tls_matrix.py not found: write it first (REPORT.md, TODO)"; exit 2)
$(TOOLS) sectest student-tests/tls_matrix.py
acl-matrix:
@test -f student-tests/acl_matrix.py || (echo "student-tests/acl_matrix.py not found: write it first (REPORT.md, TODO)"; exit 2)
$(TOOLS) sectest student-tests/acl_matrix.py
limits-test:
@test -f student-tests/test_limits.py || (echo "student-tests/test_limits.py not found: write it first (REPORT.md, TODO)"; exit 2)
$(PYTHON) -m unittest discover -s student-tests -p "test_limits.py" -v
# Стоимость Argon2id для разных параметров внутри контейнера api (обоснование выбора, REPORT.md).
argon2-bench:
docker compose exec -T api python - < student-tests/argon2_bench.py
# Уязвимости зависимостей Python (OSV/PyPI): один раз python -m pip install pip-audit.
scan-deps:
$(PYTHON) -m pip_audit -r requirements.txt --no-deps --disable-pip --progress-spinner off
# Уязвимости образов: Trivy в одноразовом контейнере. В Git Bash путь к папке берётся в виде C:/... (pwd -W),
# а MSYS_NO_PATHCONV=1 не даёт Git Bash переписать аргумент -v; на Linux/macOS это ни на что не влияет. Docker socket ему НЕ даём: образ сначала
# сохраняется в tar (docker save), Trivy читает только этот файл. База уязвимостей — в volume trivycache.
SCAN_IMAGES = mtusi-messenger:lab7 haproxy:3.2.25-alpine postgres:17.10-bookworm valkey/valkey:8.1.9 \
chrislusf/seaweedfs:4.44 rabbitmq:4.2.9-alpine openbao/openbao:2.4.4
scan-images:
mkdir -p .scan
for image in $(SCAN_IMAGES); do \
name=$$(echo $$image | tr '/:' '__'); \
docker save $$image -o .scan/$$name.tar && \
echo "== $$image"; \
MSYS_NO_PATHCONV=1 docker run --rm -v "$$(pwd -W 2>/dev/null || pwd)/.scan:/scan:ro" -v trivycache:/root/.cache aquasec/trivy:0.69.3 \
image --quiet --scanners vuln --severity HIGH,CRITICAL --ignore-unfixed --input /scan/$$name.tar; \
rm -f .scan/$$name.tar; \
done
# Вернуть остановленные реплики (после make test-failover): запустить всё, что должно работать,
# и дождаться, пока HAProxy снова возьмёт в работу все реплики.
restore:
docker compose up -d --wait
$(PYTHON) student-tests/stand.py
# ---------- собственные проверки lab1–lab2 (теперь через балансировщик) ----------
student-test:
$(PYTHON) -m unittest discover -s student-tests -p "test_*.py" -v
race:
$(PYTHON) student-tests/race.py
# Поднимает API с TTL сессии 2 с (за балансировщиком, 127.0.0.1:8081), проверяет и убирает его.
expiry:
docker compose --profile ttl up -d --wait api-short-ttl
$(PYTHON) student-tests/expiry.py; status=$$?; docker compose --profile ttl rm -sf api-short-ttl >/dev/null 2>&1; exit $$status
failure-valkey:
$(PYTHON) student-tests/dependency_failure.py valkey
failure-postgres:
$(PYTHON) student-tests/dependency_failure.py postgres
# Valkey на паузе (данные в нём сохраняются), logout, снова в строю: токен должен остаться отозванным.
failure-valkey-pause:
$(PYTHON) student-tests/cache_revocation.py
db-test:
docker compose --profile tools run --rm db-test
explain:
docker compose exec -T postgres psql -X -q -U messenger -d messenger -v ON_ERROR_STOP=1 < infra/sql/explain_history.sql
demo:
$(PYTHON) student-tests/demo.py
# Роль Valkey: сколько ключей в кэше и сколько попаданий/промахов; права пользователя health.
VALKEY_HEALTH = docker compose exec -T valkey valkey-cli --tls --cacert /run/ca/ca.crt -h 127.0.0.1 --user health --pass none --no-auth-warning
cache-stats:
$(VALKEY_HEALTH) dbsize
$(VALKEY_HEALTH) info stats | grep -E "keyspace_(hits|misses)"
-$(VALKEY_HEALTH) get sess:anything
# ---------- собственные проверки lab3 ----------
# Реплики, общие сессии и кэш, X-Instance-Id (входит и в student-test).
balancing:
$(PYTHON) -m unittest discover -s student-tests -p "test_balancing.py" -v
# Idempotency-Key: повторы, конкурентные запросы через разные реплики (входит и в student-test).
idempotency:
$(PYTHON) -m unittest discover -s student-tests -p "test_idempotency.py" -v
# Публичный failover-тест для КАЖДОЙ реплики по очереди + какой контейнер реально остановлен.
failover:
$(PYTHON) student-tests/run_failover.py
# Публичный persistence-тест + время старта каждого контейнера до и после hook.
persistence:
$(PYTHON) student-tests/run_persistence.py
# Уровень 4: остановка (SIGTERM) и авария (SIGKILL) каждой реплики под нагрузкой: RPS, ошибки, восстановление.
failover-metrics:
$(PYTHON) student-tests/failover_metrics.py
# Уровень 4: поочерёдная замена реплик новой версией под нагрузкой.
rolling-update:
$(PYTHON) student-tests/rolling_update.py
# Профиль нагрузки: публичный tests/load.py (30 с, 4 потока) + CPU/RAM контейнеров во время нагрузки.
load-profile:
$(PYTHON) student-tests/load_profile.py
# Уровень 4: лимиты CPU/RAM, нет портов API в обход LB, нет container_name, сети, версии.
check-stack:
$(PYTHON) student-tests/check_stack.py
# Таблицы замеров из evidence/*.json -> REPORT.md (между метками measurements).
report-tables:
$(PYTHON) student-tests/report_tables.py
# ---------- собственные проверки lab4 ----------
# Вложения через API: лимиты, «бомба», битые файлы, подмена MIME, filename, чужое и из другого чата
# (входит и в student-test).
attachments:
$(PYTHON) -m unittest discover -s student-tests -p "test_attachments.py" -v
# Уровень 3: upload -> сразу остановка обслужившей реплики -> ready и download через другую (тот же SHA-256).
attachment-failover:
$(PYTHON) student-tests/attachment_failover.py
# Уровень 3: S3 недоступен -> реплики не готовы, балансировщик отвечает 503; после запуска файл цел.
failure-s3:
$(PYTHON) student-tests/failure_s3.py
# Уровень 4: приватный bucket вне API, минимальные права ключа API, консоль закрыта, bootstrap идемпотентен,
# (lab5) в сообщении брокера только ID.
s3-checks:
$(PYTHON) student-tests/s3_checks.py
# Уровень 4: >= 10 одновременных загрузок, пик памяти реплик -> evidence/upload-memory.json и REPORT.md.
upload-memory:
$(PYTHON) student-tests/upload_memory.py
# Уборщик объектов S3 вручную (обычно работает в worker): make cleanup ARGS=--dry-run (только показать).
cleanup:
docker compose exec -T worker python -m messenger.cleanup $(ARGS)
# Повторить настройку bucket (идемпотентно).
s3-bootstrap:
docker compose run --rm s3-init
# ---------- lab5: брокер, worker, outbox ----------
# Остановить / запустить worker (демонстрация из README: загрузки ждут в очереди, API работает).
worker-stop:
docker compose stop worker
worker-start:
docker compose start worker
# Уровень 3: worker остановлен -> 202 -> сообщение с вложением -> перезапуск API и брокера -> worker -> ready.
worker-outage:
$(PYTHON) student-tests/worker_outage.py
# Уровень 3: повторная доставка того же задания и сообщение не по схеме (в DLQ).
redelivery:
$(PYTHON) student-tests/redelivery.py
# Уровень 4: падение API/relay между COMMIT и publish и после publish — transactional outbox.
outbox-crash:
$(PYTHON) student-tests/outbox_crash.py
# Уровень 4: падение worker после записи объектов до ack и после COMMIT до ack.
worker-crash:
$(PYTHON) student-tests/worker_crash.py
# Уровень 4: повторы с backoff и jitter, исчерпание попыток, постоянная ошибка, DLQ, replay.
retry-replay:
$(PYTHON) student-tests/retry_replay.py
# Уровень 4: lease — долгая задача продлевает аренду, замороженный worker её теряет, fencing.
lease:
$(PYTHON) student-tests/lease_takeover.py
# Уровень 4: не больше WORKER_CONCURRENCY заданий и prefetch сообщений одновременно.
concurrency:
$(PYTHON) student-tests/concurrency.py
# Уровень 4: staging удаляется после COMMIT; уборка объектов без ссылок, retention для replay.
staging-cleanup:
$(PYTHON) student-tests/staging_cleanup.py
# Замечание к MR: уборщик не удаляет текущую работу — replay, загрузка и обработка во время уборки.
cleanup-race:
$(PYTHON) student-tests/cleanup_race.py
# Варианты картинок и лимиты worker — проверки внутри образа (там Pillow).
imaging-test:
docker compose --profile tools run --rm imaging-test
# Оператор: сколько заданий в каждом состоянии / реестр failed / одно задание / явный replay.
jobs:
docker compose exec -T api python -m messenger.jobs stats
failed:
docker compose exec -T api python -m messenger.jobs failed
job:
@test -n "$(ID)" || (echo "make job ID=<attachment_id>"; exit 2)
docker compose exec -T api python -m messenger.jobs show $(ID)
replay:
@test -n "$(ID)" || (echo "make replay ID=<attachment_id>"; exit 2)
docker compose exec -T worker python -m messenger.jobs replay $(ID) --actor $(or $(ACTOR),operator)
# Очереди брокера: готовые к выдаче и выданные без ack (основная очередь и DLQ).
queues:
docker compose exec -T broker rabbitmqctl -q list_queues -p messenger name messages_ready messages_unacknowledged
# ---------- lab6: наблюдаемость (с lab7 Grafana https://127.0.0.1:3000; Prometheus — только через Grafana) ----------
# Уровни 3–4: X-Request-Id -> лог в Loki -> trace в Tempo; upload -> publish -> consume -> retry -> S3/DB
# в одной трассе; метрики без ID в labels; нет паролей, токенов и текстов сообщений в телеметрии.
telemetry-check:
$(PYTHON) student-tests/check_telemetry.py
# Источники данных и dashboard импортированы из Git, каждый запрос панели работает, alert rules загружены.
dashboard-check:
$(PYTHON) student-tests/check_dashboard.py
# Уровень 4, инцидент 1: worker остановлен -> QueueLagHigh firing -> worker запущен -> resolved (~5 мин).
incident-worker:
$(PYTHON) student-tests/incident_worker.py
# Уровень 4, инцидент 2: медленный handler против медленной БД (LOCK TABLE) -> HighErrorRate firing/resolved (~6 мин).
incident-db:
$(PYTHON) student-tests/incident_db.py
# То же для недоступной БД (docker compose pause postgres): 5xx только на входе HAProxy (~5 мин).
incident-db-down:
$(PYTHON) student-tests/incident_db.py --down
# Уровень 4, сценарий 3: остановка Tempo и Loki (3 мин) и Collector (1 мин) под нагрузкой (~7 мин).
telemetry-outage:
$(PYTHON) student-tests/telemetry_outage.py
# История телеметрии в volumes: перезапуск Prometheus, Loki, Tempo, Grafana — старые данные на месте.
telemetry-persistence:
$(PYTHON) student-tests/telemetry_persistence.py
# Состояние alert rules (inactive / pending / firing) из Prometheus.
alerts:
$(PYTHON) student-tests/obs.py alerts
# Последние предупреждения и ошибки API и worker из Loki.
telemetry-logs:
$(PYTHON) student-tests/obs.py logs
+201 -13
View File
@@ -1,37 +1,225 @@
# Отчёт — лабораторная 7
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Автор, группа: Гаджиев Нухбала, БВТ2303
- Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не выбран
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
- Использованные источники, библиотеки и помощь ИИ: всё из lab6 и новое: OpenBao 2.4.4 (не dev-mode,
file storage, cert auth); `cryptography` 50.0.2 (локальный CA `scripts/pki.py`, проверка CRL в API);
Argon2id (`argon2-cffi`, с lab2); TLS/mTLS на HAProxy (external TLS + mTLS к репликам, mTLS-шлюз перед
Collector), PostgreSQL (`hostssl`, verify-full, SCRAM, раздельные роли), SeaweedFS (S3 по HTTPS),
RabbitMQ (AMQPS + SASL EXTERNAL), Valkey (TLS + ACL), Prometheus/Loki/Tempo/Grafana (mTLS).
Документация: OWASP Password Storage и File Upload, OpenBao (AppRole/cert auth, policies, production
hardening), RabbitMQ TLS и `rabbitmq_auth_mechanism_ssl`, PostgreSQL TLS и `pg_hba`, Docker security.
ИИ использовался как вспомогательный ресурс: для оценки решения, написания комментариев к коду
и составления текстовых документов.
## Запуск из чистого clone
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Проверял на Windows 11 в Git Bash с Docker Desktop (WSL 2). Нужны Docker с Compose, Python 3.9+ (только для
тестов, стандартная библиотека; для `make validate` и `make scan-deps` — venv с `requirements-dev.txt`
и `pip-audit`) и GNU Make. Образы закреплены: всё из lab6 (python:3.12.8-slim-bookworm, haproxy:3.2.25-alpine,
postgres:17.10-bookworm, valkey/valkey:8.1.9, chrislusf/seaweedfs:4.44, rabbitmq:4.2.9-alpine,
otel/opentelemetry-collector-contrib:0.140.1, prom/prometheus:v3.7.3, grafana/loki:3.5.8, grafana/tempo:2.9.0,
grafana/grafana:12.2.1) и openbao/openbao:2.4.4; для сканов aquasec/trivy:0.69.3. Перед запуском остановить
стенд lab6 (`docker compose -p mtusi-lab6 down`): заняты порты 127.0.0.1.
```sh
git clone https://gitea.privcloud.tech/ng14/mtusi2026lab7.git && cd mtusi2026lab7
git checkout solution/bvt2303-gadzhiev
cp .env.example .env
sed -i 's/\r$//' .env # только Windows: убрать \r из .env
# Первый запуск одной командой (secrets, CA/сертификаты, OpenBao init/unseal/bootstrap, стенд):
make bootstrap PYTHON=python
# bootstrap делает по шагам (их же выполнять вручную при разборе):
# make secrets # пароли и ACL в secrets/ (вне Git); у api/worker секретов-файлов нет
# docker compose build api # образ приложения (его используют и инструменты pki/ops)
# make pki # локальный CA и leaf-сертификаты всех identity -> secrets/tls
# docker compose up -d --wait openbao # OpenBao поднялся sealed и не инициализирован
# make bao-init # 3 unseal shares (порог 2) и root token -> secrets/operator/ (600)
# make bao-unseal # ввод 2 shares
# make bao-bootstrap # kv-v2, cert auth, политики, роли, секреты приложения в OpenBao
# make up # весь стенд: docker compose up -d --build --wait
make ps
make check PYTHON=python
make test PYTHON=python # публичный smoke по HTTPS (BASE_URL/CA_FILE уже заданы в Makefile)
make test-security PYTHON=python # внешний endpoint отклоняет недоверенный CA
```
Grafana: https://127.0.0.1:3000, пользователь `admin`, пароль — `secrets/grafana_admin_password` (сертификат
Grafana выдан на `localhost`, браузер предупредит о неизвестном CA — это ожидаемо, CA локальный).
Проверки lab7: `make check-stack` (hardening, порты, сети, секреты), `make tls-matrix`, `make acl-matrix`,
`make limits-test`. Операции: `make pki-show`,
`make rotate-lb-cert`, `make bao-status`, `make rotate-db-secret`, `make bao-revoke-tokens`,
`make bao-token-ttl ROLE=api TTL=30s`. Сканы: `make scan-deps`, `make scan-images`. Замер Argon2: `make argon2-bench`.
Безопасная остановка: `make down` (volumes остаются, в том числе `baodata`; после `make up` OpenBao снова
sealed — `make bao-unseal`). Намеренное удаление учебных данных: `docker compose down -v`, затем
`rm -rf secrets` и заново `make bootstrap` (новый CA, новый init OpenBao).
## Архитектура и решения
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab6, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
```text
клиент --TLS 8443--> lb (HAProxy) --mTLS (identity lb, allowlist в API)--> api x2
api/worker --TLS verify-full--> postgres (роли messenger_api / messenger_worker)
api/worker --HTTPS, ключи по префиксам--> s3 (SeaweedFS)
api/worker --mTLS + SASL EXTERNAL--> broker (пользователь = CN: api публикует, worker читает)
api --TLS + ACL--> valkey (кэш сессий, общий лимит входа)
api/worker --mTLS, allowlist api,worker--> otlp-gw --127.0.0.1--> otel-collector
otel-collector --mTLS--> prometheus / tsdb-gw (loki, tempo) <--mTLS-- grafana (HTTPS 3000 для оператора)
api/worker --mTLS cert auth--> openbao (пароль роли БД, ключи S3, пароль Valkey)
сети (все internal, кроме public у lb и ops у grafana): public, edge, backend, otlp, telemetry, vault
```
Источник истины — PostgreSQL (с lab2), байты — S3 (с lab4), очередь — RabbitMQ (с lab5), телеметрия в
Prometheus/Loki/Tempo (с lab6). Бизнес-API и его контракт не менялись: поменялся транспорт (HTTPS снаружи)
и добавились защиты на границах. Транзакционные границы те же, что в lab5–6.
**Что перенесено из lab6:** весь код `src/messenger`, миграции 001–006, свои тесты, Dockerfile, бизнес-логика,
конфиги Collector/Prometheus/Loki/Tempo/Grafana (к ним добавлен TLS).
**Что изменено в lab7(по файлам):**
- `scripts/pki.py` — локальный CA и leaf-сертификаты (CN=SAN=identity, serverAuth+clientAuth), CRL, ротация,
сертификаты для отрицательных тестов (`secrets/tls-test`).
- `scripts/bao.py` — оператор OpenBao: init/unseal/seal, bootstrap (kv-v2, cert auth, политики, роли, секреты),
ротация пароля БД, отзыв токенов, смена TTL.
- `src/messenger/secretsource.py` — получение секретов из OpenBao по сертификату identity, renew/re-auth,
перечитывание и пересоздание пула БД при ротации, fail-closed при недоступном OpenBao.
- `src/messenger/tlsserver.py` — реплика API слушает HTTPS с обязательным клиентским сертификатом; проверка
разрешённой identity (SAN) и CRL после рукопожатия; `__main__.py` и `healthcheck.py` — запуск HTTPS и
отдельный health-listener на `127.0.0.1` контейнера.
- `src/messenger/ratelimit.py` + правки `sessions.py` — общий для реплик лимит входа (429 + Retry-After),
счётчики в Valkey; `security.py` — параметры Argon2id из окружения, rehash при входе, бюджет одновременных
проверок; `api.py` — лимиты, лимит тела (413), случайный alias вместо hostname.
- `db.py`, `objects.py`, `broker.py`, `sessions.py`, `s3bootstrap.py` — TLS/mTLS и секреты из OpenBao у каждой
зависимости; `migrations/007_roles.sql` + `infra/postgres/initdb/10-roles.sh` + `pg_hba.conf` — раздельные
роли БД и только TLS.
- `infra/tsdb/gateway.cfg` — mTLS-шлюз `tsdb-gw` перед Loki и Tempo: у их HTTP-серверов нет списка разрешённых
identity (только «сертификат нашего CA»), поэтому allowlist CN (`otel-collector`, `grafana`) проверяет шлюз, а
Loki/Tempo слушают только loopback шлюза. Найдено собственным TLS-аудитом (`tls_matrix.py`): до шлюза любой
сертификат нашего CA (`api`, `lb`, `intruder`) читал логи и трассы — 9 FAIL; после шлюза — 403.
- `compose.yaml` — OpenBao, mTLS-шлюзы `otlp-gw` и `tsdb-gw`, hardening (no-new-privileges, cap_drop, read_only, tmpfs),
сети по матрице, у api/worker нет файлов-секретов.
- `infra/` — TLS/mTLS в конфигах haproxy, rabbitmq (+`definitions.json`), valkey, prometheus (`web.yml`),
loki, tempo, grafana datasources, otel (`collector.yaml`, `gateway.cfg`), openbao (`bao.hcl`, `policies/`).
Соответствие `.env.example` реальной конфигурации: в `.env` нет ни одного секрета. Строки `*_FILE` оставлены
из skeleton как имена интерфейса; в `compose.yaml` у api/worker они пустые (секретов-файлов нет, всё из
OpenBao), у `migrate` задан `DB_PASSWORD_FILE`. Новые переменные (`TLS_*`, `BAO_*`, `ARGON2_*`, `LOGIN_*`,
`MAX_JSON_BODY_BYTES`, `APP_HEALTH_PORT`) описаны в `.env.example` построчно.
## Доказательства критериев
Прогон на стенде: Windows 11, Docker Desktop (WSL 2), образы выше. Даты и commit — в `evidence/` при сдаче.
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
| Публичный smoke по HTTPS | `make test` | PASS: сквозной сценарий (вход, чат, сообщения, файл, thumbnail, logout) по `https://127.0.0.1:8443` | `evidence/test.txt` |
| Внешний TLS отклоняет недоверенный CA | `make test-security` | PASS: доверенный HTTPS работает, пустой trust store → ошибка проверки сертификата | `evidence/security.txt` |
| Argon2id, обоснование параметров замером | `make argon2-bench` | внутри контейнера api (лимит 1 CPU), ноутбук автора: m=19 МиБ, t=2, p=1 → медиана 25.9 мс/hash, p95 28.6 мс, ~39 входов/с на ядро; t=3 — 37.6 мс, m=46 МиБ — 69 мс, m=64 МиБ — 127 мс. Выбран минимум OWASP: дороже для перебора по украденной базе, но вход остаётся быстрым, а бюджет реплики — около 75 проверок/с на 2 слота | `evidence/argon2-bench.txt` |
| Внешний HTTPS, внутр. mTLS LB→API, TLS к зависимостям | `make tls-matrix` | PASS, 119 проверок: каждая связь: правильная identity → успех, чужая/без сертификата/чужой CA/истёкший → отказ | `evidence/tls-matrix.txt` |
| OpenBao не dev-mode, cert auth, scoped policy | `make acl-matrix` | PASS, 114 проверок: api/worker читают только свой путь KV; чужой путь, запись, admin — запрет; вход чужим CN отклонён | `evidence/acl-matrix.txt` |
| Hardening, порты, сети, раздельные секреты | `make check-stack` | PASS: no-new-privileges, cap_drop, read_only+tmpfs (исключения объяснены), api/worker не root, лимиты; наружу только lb и grafana на 127.0.0.1 | `evidence/check-stack.txt` |
| Лимит входа (429/Retry-After), лимит размера | `make limits-test` | OK, 9 тестов: 429 (`Retry-After` ~299 с) после порога через разные реплики (общий счётчик), верный пароль тоже 429; тело > лимита → 413 | `evidence/limits.txt` |
| Персистентность и отказ реплики по HTTPS | `make test-persistence ACTION_SCRIPT=scripts/restart.cmd`, `make test-failover ACTION_SCRIPT=scripts/stop-one.cmd` (на Linux/macOS — `.sh`) | PASS: данные и сессия переживают рестарт; при отказе реплики 113 записей без потерь, 0 ошибок, восстановление 5.7 с (хук находит реплику по alias) | `evidence/persistence.txt`, `evidence/failover.txt` |
| Сохранены возможности lab3–6 | `make student-test`, `make db-test`, `make check-stack`, наблюдаемость | PASS (63 теста `student-test`): балансировка, идемпотентность, вложения, worker, трассы/метрики/alerts работают поверх TLS | `evidence/student-test.txt` |
| Ротация secret и cert без пересборки, отзыв | `make rotate-db-secret`, `make rotate-lb-cert`, `make bao-revoke-tokens` | см. «Эксперименты» | `evidence/rotation.txt` |
| Поведение при sealed OpenBao и expiry токена | `make bao-seal` / `make bao-unseal`, `make bao-token-ttl` | см. «Эксперименты» | `evidence/openbao-incident.txt` |
| Scan зависимостей и образов с разбором | `make scan-deps`, `make scan-images` | см. «Эксперименты» | `evidence/dependency-scan.txt`, `evidence/image-scan.txt`, `evidence/image-scan-app-after.txt` |
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
PASS без команды и вывода не является доказательством: перед сдачей сохрани stdout каждой команды в указанный
файл `evidence/` (например, `make tls-matrix > evidence/tls-matrix.txt 2>&1`). Для инфраструктурных хуков
приложи состояние контейнеров до и после (`make ps`).
## Эксперименты и отказы
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Hardware/лимиты: один ноутбук, Docker Desktop (WSL 2), ~20 контейнеров, лимиты CPU/RAM из `compose.yaml`
(api 384 МиБ, worker 1 ГиБ и т.д.). Данные синтетические. Raw-вывод — в `evidence/` без токенов.
**Argon2id (login DoS budget).** Замер `make argon2-bench` (таблица выше). При m=19 МиБ, t=2, p=1 одна
проверка ~26 мс (p95 29 мс) и 19 МиБ памяти. Бюджет: `ARGON2_MAX_CONCURRENCY=2` на реплику (одновременно не больше двух
дорогих проверок, остальные ждут `ARGON2_QUEUE_SECONDS`, затем 503), плюс общий для реплик лимит частоты
входа (429). Так поток входов не исчерпывает память и CPU, а чтение/отправка сообщений продолжают работать.
**Ротация рабочего secret (`make rotate-db-secret`).** Новый пароль роли `messenger_api`: сначала `ALTER ROLE`
в PostgreSQL, затем новая версия KV в OpenBao. API за `BAO_REFRESH_SECONDS` видит новое значение и пересоздаёт
пул (`db.drain_pools`): новые соединения входят с новым паролем, старый перестаёт работать для новых входов.
Наблюдение на стенде: KV `secret/messenger/api` стал версии 2; обе реплики за ~10 с записали `secrets.rotated` и
`db.pool_drained`; `make test` сразу после ротации — PASS; простоя нет, образы не пересобирались. Что старый
пароль больше не принимается для новых входов, показывает `acl-matrix` (роли входят только текущим паролем из OpenBao).
**Ротация leaf-сертификата (`make rotate-lb-cert`).** Новый сертификат `lb` пишется на место старого, HAProxy
перечитывает его (`kill -s USR2`, мягкий reload, без простоя), старый серийный номер добавляется в CRL. Реплики
API перечитывают CRL за `TLS_CRL_CHECK_SECONDS`: соединение со старым сертификатом `lb` после этого отклоняется,
с новым — принимается. Пересборки образов нет.
**Отзыв identity / токенов (`make bao-revoke-tokens`, `make bao-token-ttl`).** После отзыва всех токенов
cert-auth сервисы при следующем обращении входят заново по сертификату (в логах `secrets.relogin` →
`secrets.login`). При `TTL=30s` виден цикл: вход, renew, через срок — новый вход. Отзыв identity (удаление роли
или нового сертификата + старый серийник в CRL) закрывает доступ; работающий процесс живёт на кэше до рестарта.
**Sealed OpenBao / рестарт.** `make bao-seal` (или рестарт контейнера): работающие API и worker продолжают
работать на секретах в памяти (ротации не подхватываются), `make test` проходит; в логах
`secrets.refresh_failed` (HTTP 503). Новый процесс без доступного OpenBao не стартует: ждёт
`BAO_STARTUP_WAIT_SECONDS` и завершается (fail closed). После `make bao-unseal` — `secrets.recovered`, данные
KV/политики/роли на месте.
**Scan зависимостей (`make scan-deps`, pip-audit, OSV/PyPI).** Найдено 14 advisory, все в одном пакете —
`starlette 0.46.2` (транзитивная зависимость FastAPI). Разбор применимости:
- `CVE-2026-54282`/`CVE-2026-48710` (реконструкция `request.url` из Host и пути) — путь был достижим в
`needs_bearer`; **исправлено в коде**: решение о проверке токена и маршрутизация идут по `request.scope["path"]`,
одной и той же строке (`src/messenger/api.py`); Host для авторизации не используется.
- `CVE-2025-62727` (quadratic Range в `FileResponse`) — `FileResponse` не используется: скачивание идёт через
`StreamingResponse` с нашим `Content-Length` (`api.py`), Range-заголовок не обрабатывается. Не применимо.
- `CVE-2026-48818`/`CVE-2026-48817` (`StaticFiles`, UNC на Windows; `HTTPEndpoint` getattr) — `StaticFiles` и
`HTTPEndpoint` не используются (маршруты — функции FastAPI). Не применимо.
- `CVE-2026-54283`/`CVE-2026-54282` (лимиты формы, urlencoded) — форм-парсер не используется: тело только JSON и
поток байтов вложения с собственным лимитом (`BodyLimit`, 413). Не применимо.
- `CVE-2025-54121` (блокировка потока при спуле большого multipart) — multipart не используется. Не применимо.
Остаточный риск: закреплённая версия starlette остаётся уязвимой к неиспользуемым путям; обновление отложено,
чтобы не ломать совместимость с FastAPI 0.115 (контракт и публичные тесты важнее). Единственный достижимый путь
закрыт в коде. Вывод скана — `evidence/dependency-scan.txt`.
**Scan образов (`make scan-images`, Trivy 0.69.3, HIGH/CRITICAL, `--ignore-unfixed`).** Сырой вывод —
`evidence/image-scan.txt`. Trivy проверяет системные пакеты образа (Debian/Alpine) и библиотеки внутри
программ (Python, Go). Важен не счётчик, а достижимость: используется ли уязвимый код в нашем стенде и может
ли до него дойти недоверенный ввод. Итог по образам:
| Образ | Найдено | Что применимо к нам | Что сделано / почему остаётся |
| --- | --- | --- | --- |
| `mtusi-messenger:lab7` (наш) | 56 Debian + 3 Python | **Да:** базовый образ на Debian 12.9, `libssl3` 3.0.15 — через неё идёт весь TLS приложения (OpenBao, PostgreSQL, брокер, S3, mTLS реплики). Сами CVE (CVE-2025-15467 — разбор CMS/PKCS#7, CVE-2026-31789 — 32-битные сборки) наш путь не затрагивают, но это библиотека на каждой границе доверия | **Исправлено:** в `Dockerfile` при сборке ставятся обновления безопасности bookworm (`apt-get upgrade`), тег базы закреплён. После пересборки (43 пакета обновлено, `make test` — PASS): Debian 0 (было 56), Python 3 — `evidence/image-scan-app-after.txt`. Python: starlette — разбор выше (достижимый путь закрыт в коде) |
| `postgres:17.10-bookworm` | 36 Debian + 26 Go (`gosu`) | Нет. `perl`, `pcre2`, `apt` сервер PostgreSQL не вызывает; `libssl3` CVE-2026-84782 — только DTLS, а у PostgreSQL TLS поверх TCP. `gosu` (Go stdlib: crypto/tls, net/url) работает доли секунды при старте — меняет пользователя и делает exec, сети и TLS не касается | Остаточный риск: обновиться на следующий патч-тег образа, когда выйдет |
| `valkey/valkey:8.1.9` | 20 Debian | Нет. `perl`, `pcre2`, `sqlite`, `gzip`, `zlib`, `apt` сервер Valkey не использует; `libssl3t64` — только DTLS | Остаточный риск |
| `haproxy:3.2.25-alpine` (lb, otlp-gw, tsdb-gw) | 4 Alpine | Нет. `musl regcomp` и `pcre2` — компиляция регулярных выражений, а в наших конфигах нет ни одного regex (только `-m str`), шаблоны задаём мы, не клиент; `zlib gz_vacate` — файловый API gz, HAProxy его не вызывает, сжатие выключено | Остаточный риск |
| `chrislusf/seaweedfs:4.44` | 8 Alpine + 10 Go (`weed`) | **Частично:** Go stdlib CVE-2026-78667 (Range) и HTTP/2 SETTINGS DoS достижимы на S3 `:9000` — но только из внутренней сети `backend` и только для сервисов с ключами (api, worker). Остальное нет: `brotli`/`curl` — только curl healthcheck к своему 127.0.0.1; thrift, go-jose, x/image, внутренний gRPC (master/volume на 127.0.0.1) в нашей конфигурации не открыты | Остаточный риск DoS от уже авторизованного внутреннего сервиса; обновиться, когда выйдет сборка на Go ≥ 1.26.9 |
| `rabbitmq:4.2.9-alpine` | 0 | — | — |
| `openbao/openbao:2.4.4` | 29 Alpine + 68 Go (`bao`) | **Частично:** Go stdlib CVE-2025-68121 (crypto/tls, проверка сертификата при TLS session resumption) касается границы, где работает cert auth. Условие уязвимости — изменение `ClientCAs` между рукопожатиями; у нас CA задаётся один раз в `bao.hcl` и не меняется, поэтому путь не срабатывает. CVE-2026-111943 (недоверенный intermediate) — у нашего CA `path_length=0`, промежуточных CA нет. Остальное не включено: OIDC (CVE-2026-33757 CRITICAL, XSS), UI, raft, recovery mode, движки PostgreSQL (pgx), SSH (x/crypto/ssh), JWT (go-jose), gRPC authz; наружу OpenBao не опубликован | Остаточный риск с обоснованием; следующий шаг — переход на актуальный патч-релиз OpenBao 2.x (данные `file` storage совместимы вперёд) с повторным прогоном `tls-matrix`/`acl-matrix` |
Вывод: из найденного к нам по-настоящему относится устаревшая системная база нашего образа — исправлено
в `Dockerfile`. Для чужих образов достижимы только DoS-пути изнутри сети от уже аутентифицированных сервисов
(SeaweedFS) и неактивный при нашей конфигурации путь в TLS OpenBao; они оставлены как остаточный риск с планом
обновления. `make scan-deps` завершается с кодом 1 — так pip-audit сообщает, что находки есть; разбор выше.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
| `make rotate-db-secret` | старый пароль отклонён, новый работает, без простоя | подтверждено (см. выше) | ~`BAO_REFRESH_SECONDS` до смены пула; данные целы |
| `make rotate-lb-cert` | старый сертификат lb отклонён репликами, новый принят, без простоя | подтверждено | ≤ `TLS_CRL_CHECK_SECONDS`; данные целы |
| `make bao-seal` | API живёт на кэше, новые процессы не стартуют | подтверждено | восстановление `make bao-unseal`; данные целы |
| `make bao-revoke-tokens` + `TTL=30s` | повторный вход по сертификату | подтверждено (`secrets.relogin`) | секунды; данные целы |
## Ограничения и следующие шаги
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
- OpenBao на уровне TLS принимает любой клиентский сертификат и проверяет его при входе (cert auth): оператор
работает без клиентского сертификата. Поэтому отказ чужому/истёкшему сертификату проверяется на входе
(`tls_matrix.py`); истёкший OpenBao отклоняет с HTTP 500 и текстом «certificate has expired».
- Windows резервирует диапазон портов (WinNAT/Hyper-V), в который может попасть 8443/8444/8404. Решение:
`net stop winnat && net start winnat` от администратора; временный обход — локальный `compose.override.yaml`
с другими портами (в `.gitignore`, не коммитится).
- Учебные упрощения: всё на одном хосте; unseal shares лежат рядом в `secrets/operator/` (в production — три
держателя); ручной `make bao-unseal` после рестарта OpenBao; CA локальный (браузер предупреждает о Grafana).
- Один узел у PostgreSQL, Valkey, брокера, OpenBao: HA БД/брокера не входит в задачу (как и в lab5–6). Порт
Erlang distribution брокера виден в сети `backend` и закрыт cookie из volume — ограничение учебного стенда.
- Трек 5 не заявлен (цель — 4). Следующий шаг для 5: изолированный сценарий компрометации worker или
автоматизированный жизненный цикл PKI/secrets под нагрузкой с измерениями.
+784
View File
@@ -0,0 +1,784 @@
# Стенд lab7: тот же мессенджер lab6, защищённый на всех границах доверия (contracts/trust-matrix.md).
#
# клиент --TLS--> lb (HAProxy, 127.0.0.1:8443) --mTLS (identity lb)--> api x2
# api/worker --TLS verify-full--> postgres (роли messenger_api / messenger_worker)
# api/worker --HTTPS--> s3 (SeaweedFS) (разные ключи и префиксы)
# api/worker --mTLS + SASL EXTERNAL--> broker (пользователи = CN: api публикует, worker читает)
# api --TLS + ACL-пароль--> valkey (кэш сессий, лимиты входа)
# api/worker --mTLS (allowlist api,worker)--> otlp-gw --127.0.0.1--> otel-collector
# otel-collector --mTLS--> prometheus / tsdb-gw (loki, tempo) <--mTLS-- grafana (HTTPS 127.0.0.1:3000 для оператора)
# api/worker --mTLS cert auth--> openbao (секреты: пароль роли БД, ключи S3, пароль Valkey)
#
# Запуск из чистого clone (подробно — REPORT.md):
# make secrets pki && docker compose up -d --wait openbao && make bao-init bao-unseal bao-bootstrap && make up
#
# Сети (все internal, кроме public и ops — они только для опубликованных на 127.0.0.1 портов):
# public lb -> 127.0.0.1:8443 (API), :8444 (API с коротким TTL), :8404 (stats)
# edge lb <-> api
# backend api, worker, migrate, s3-init <-> postgres, valkey, s3, broker
# otlp api, worker -> otlp-gw (otel-collector)
# telemetry otlp-gw/otel-collector, lb (scrape) <-> prometheus, tsdb-gw (loki, tempo) <- grafana
# vault api, worker, ops -> openbao
# ops grafana -> 127.0.0.1:3000
#
# Hardening (x-hardened): no-new-privileges, cap_drop ALL, read-only корень + tmpfs там, где совместимо.
# Исключения (stateful/entrypoint как root) объяснены у сервисов и в REPORT.md.
# Секреты: TLS-ключ каждого сервиса смонтирован только в его контейнер (secrets/tls/<identity>);
# пароли и ключи приложения — только в OpenBao. Docker socket, privileged и host network не используются.
name: mtusi-lab7
x-build: &build
context: .
args:
APP_VERSION: ${APP_VERSION:-dev}
x-hardened: &hardened
security_opt: ["no-new-privileges:true"]
cap_drop: [ALL]
# Только публичный CA-сертификат и CRL — во все сервисы.
x-ca: &ca ./secrets/tls/ca:/run/ca:ro
# Общие (несекретные) настройки процессов приложения. Секретов здесь нет: см. secretsource.py.
x-app-env: &app-env
TLS_CA_FILE: /run/ca/ca.crt
TLS_CRL_FILE: /run/ca/crl.pem
TLS_CERT_FILE: /run/tls/tls.crt
TLS_KEY_FILE: /run/tls/tls.key
# Только наш CA для всех исходящих HTTPS (requests внутри OTel-экспортёра читает эти переменные).
SSL_CERT_FILE: /run/ca/ca.crt
REQUESTS_CA_BUNDLE: /run/ca/ca.crt
CACHE_URL: valkeys://messenger@valkey:6379/0
BROKER_URL: amqps://broker:5671/messenger
BAO_ADDR: https://openbao:8200
OTEL_EXPORTER_OTLP_CERTIFICATE: /run/ca/ca.crt
OTEL_EXPORTER_OTLP_CLIENT_CERTIFICATE: /run/tls/tls.crt
OTEL_EXPORTER_OTLP_CLIENT_KEY: /run/tls/tls.key
# Пустые *_FILE: у приложения нет файлов-секретов (иначе config.py стал бы их искать).
DATABASE_URL_FILE: ""
CACHE_URL_FILE: ""
S3_ACCESS_KEY_ID_FILE: ""
S3_SECRET_ACCESS_KEY_FILE: ""
BROKER_URL_FILE: ""
x-api-env: &api-env
<<: *app-env
DATABASE_URL: postgresql://messenger_api@postgres:5432/messenger?sslmode=verify-full&sslrootcert=/run/ca/ca.crt
BAO_ROLE: messenger-api
BAO_SECRET_PATH: secret/data/messenger/api
TLS_ALLOWED_CLIENTS: lb
x-api-healthcheck: &api-healthcheck
# Внутренний слушатель 127.0.0.1:8081 контейнера (healthcheck.py): основной порт требует mTLS lb.
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8081/health/ready', timeout=2)"]
interval: 5s
timeout: 3s
retries: 3
start_period: 40s
start_interval: 1s
x-api: &api
<<: *hardened
image: mtusi-messenger:lab7
env_file: .env
read_only: true
# /tmp: alias реплики, временные файлы загрузок (UPLOAD_SPOOL_BYTES), точки отказа faults.py.
tmpfs: ["/tmp:size=128m,mode=1777"]
volumes:
- ./secrets/tls/api:/run/tls:ro
- *ca
networks: [edge, backend, otlp, vault]
services:
# ---------- инструменты оператора (profile tools, не часть работающего стенда) ----------
# Локальный CA и сертификаты: make pki (scripts/pki.py). Сеть не нужна.
pki:
<<: *hardened
image: mtusi-messenger:lab7
build: *build
profiles: [tools]
user: "0:0" # пишет в ./secrets на хосте (bind mount)
entrypoint: ["python", "scripts/pki.py"]
command: ["init"]
environment:
PKI_ROOT: /srv/secrets
volumes:
- ./scripts:/srv/scripts:ro
- ./secrets:/srv/secrets
network_mode: none
read_only: true
# Операции OpenBao и ротация: make bao-* / rotate-db-secret (scripts/bao.py). Только сети vault и backend.
ops:
<<: *hardened
image: mtusi-messenger:lab7
profiles: [tools]
pull_policy: never
user: "0:0" # пишет secrets/operator/ (shares, root token) с mode 600
entrypoint: ["python", "scripts/bao.py"]
command: ["status"]
environment:
BAO_ADDR: https://openbao:8200
BAO_CACERT: /srv/secrets/tls/ca/ca.crt
SECRETS_DIR: /srv/secrets
BAO_POLICY_DIR: /srv/infra/openbao/policies
DB_HOST: postgres
volumes:
- ./scripts:/srv/scripts:ro
- ./secrets:/srv/secrets
- ./infra/openbao/policies:/srv/infra/openbao/policies:ro
networks: [vault, backend]
read_only: true
# Контейнер для собственных проверок матрицы доверия изнутри сетей стенда (make tls-matrix, acl-matrix):
# сертификаты сервисов (secrets/tls) и тестовые сертификаты (secrets/tls-test) — только чтение.
sectest:
<<: *hardened
image: mtusi-messenger:lab7
profiles: [tools]
pull_policy: never
entrypoint: ["python"]
command: ["--version"] # скрипт передаёт make (tls-matrix, acl-matrix)
environment:
PKI_DIR: /pki
volumes:
- ./student-tests:/srv/student-tests:ro
- ./secrets/tls:/pki/tls:ro
- ./secrets/tls-test:/pki/test:ro
networks: [edge, backend, otlp, telemetry, vault]
read_only: true
tmpfs: ["/tmp:size=16m"]
# ---------- приложение ----------
# Миграции (роль-владелец messenger, пароль из файла — это одноразовый инструмент, не приложение).
migrate:
<<: *hardened
image: mtusi-messenger:lab7
build: *build
env_file: .env
command: ["python", "-m", "messenger.migrate"]
environment:
DATABASE_URL: postgresql://messenger@postgres:5432/messenger?sslmode=verify-full&sslrootcert=/run/ca/ca.crt
DATABASE_URL_FILE: ""
DB_PASSWORD_FILE: /run/secrets/postgres_password
CACHE_URL_FILE: ""
S3_ACCESS_KEY_ID_FILE: ""
S3_SECRET_ACCESS_KEY_FILE: ""
BROKER_URL_FILE: ""
OTEL_SDK_DISABLED: "true"
secrets: [postgres_password]
volumes: [*ca]
networks: [backend]
read_only: true
depends_on:
postgres: {condition: service_healthy}
healthcheck:
disable: true
restart: "no"
deploy:
resources:
limits: {cpus: "0.50", memory: 128M}
api:
<<: *api
build: *build
environment:
<<: *api-env
depends_on:
migrate: {condition: service_completed_successfully}
s3-init: {condition: service_completed_successfully}
postgres: {condition: service_healthy}
valkey: {condition: service_healthy}
broker: {condition: service_healthy}
openbao: {condition: service_healthy}
otlp-gw: {condition: service_healthy}
healthcheck: *api-healthcheck
restart: unless-stopped
stop_grace_period: 15s
deploy:
replicas: ${API_REPLICAS:-2}
resources:
# ARGON2_MAX_CONCURRENCY=2 x 19 МиБ на хеш + процесс ~150 МиБ: 384 МиБ с запасом.
limits: {cpus: "1.00", memory: 384M}
worker:
<<: *hardened
image: mtusi-messenger:lab7
pull_policy: never
env_file: .env
command: ["python", "-m", "messenger.worker"]
environment:
<<: *app-env
DATABASE_URL: postgresql://messenger_worker@postgres:5432/messenger?sslmode=verify-full&sslrootcert=/run/ca/ca.crt
BAO_ROLE: messenger-worker
BAO_SECRET_PATH: secret/data/messenger/worker
CACHE_URL: "" # кэш сессий worker не нужен
OTEL_SERVICE_NAME: messenger-worker
read_only: true
# /tmp: файлы попытки обработки (оригинал до 10 МиБ + варианты) и alive-файл healthcheck.
tmpfs: ["/tmp:size=192m,mode=1777"]
volumes:
- ./secrets/tls/worker:/run/tls:ro
- *ca
networks: [backend, otlp, vault]
depends_on:
migrate: {condition: service_completed_successfully}
s3-init: {condition: service_completed_successfully}
postgres: {condition: service_healthy}
broker: {condition: service_healthy}
openbao: {condition: service_healthy}
otlp-gw: {condition: service_healthy}
healthcheck:
test: ["CMD", "python", "-c", "import os, sys, time; sys.exit(0 if time.time() - os.path.getmtime('/tmp/worker.alive') < 30 else 1)"]
interval: 5s
timeout: 3s
retries: 3
start_period: 40s
start_interval: 1s
restart: unless-stopped
stop_grace_period: 30s
deploy:
replicas: ${WORKER_REPLICAS:-1}
resources:
# Лимит на upload-worker (README, уровень 4): CPU 1 ядро, RAM 1 ГиБ на контейнер; внутри —
# WORKER_CONCURRENCY=2 попытки, каждая — дочерний процесс с RLIMIT_AS 640 МиБ и JOB_TIMEOUT_SECONDS.
limits: {cpus: "1.00", memory: 1G}
api-short-ttl:
<<: *api
profiles: [ttl]
pull_policy: never
environment:
<<: *api-env
SESSION_TTL_SECONDS: "2"
depends_on:
postgres: {condition: service_healthy}
valkey: {condition: service_healthy}
openbao: {condition: service_healthy}
healthcheck: *api-healthcheck
restart: unless-stopped
deploy:
resources:
limits: {cpus: "0.50", memory: 256M}
# ---------- вход ----------
lb:
<<: *hardened
image: haproxy:3.2.25-alpine
read_only: true
tmpfs: ["/tmp:size=8m"]
ports:
- "127.0.0.1:8443:8443" # единственная точка входа API, только HTTPS
- "127.0.0.1:8444:8444" # API с коротким TTL (make expiry), тоже HTTPS через балансировщик
- "127.0.0.1:8404:8404" # статистика HAProxy по HTTPS: https://127.0.0.1:8404/stats
volumes:
- ./infra/haproxy/haproxy.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
- ./secrets/tls/lb:/run/tls:ro
- *ca
networks: [public, edge, telemetry]
depends_on:
api: {condition: service_started}
healthcheck:
test: ["CMD", "wget", "-q", "-T", "2", "-O", "/dev/null", "http://127.0.0.1:8405/lb-health"]
interval: 5s
timeout: 3s
retries: 3
start_period: 20s
start_interval: 1s
restart: unless-stopped
stop_grace_period: 15s
deploy:
resources:
limits: {cpus: "0.50", memory: 128M}
# ---------- секреты ----------
# OpenBao не в dev-mode (infra/openbao/bao.hcl): persistent storage, sealed после каждого запуска.
# Healthy = процесс отвечает (в том числе sealed): unseal — действие оператора (make bao-unseal).
# Наружу не опубликован; оператор работает через контейнер ops в сети vault.
openbao:
<<: *hardened
image: openbao/openbao:2.4.4
user: "10001:10001"
entrypoint: ["bao", "server", "-config=/openbao/config/bao.hcl"]
read_only: true
tmpfs: ["/tmp:size=8m"]
volumes:
- ./infra/openbao/bao.hcl:/openbao/config/bao.hcl:ro
- ./secrets/tls/openbao:/run/tls:ro
- *ca
- baodata:/openbao/data
- baologs:/openbao/logs
networks: [vault]
depends_on:
openbao-init: {condition: service_completed_successfully}
healthcheck:
# bao status: 0 — unsealed, 2 — sealed, 1 — ошибка. Healthy при 0 и 2.
test: ["CMD-SHELL", "BAO_ADDR=https://127.0.0.1:8200 BAO_CACERT=/run/ca/ca.crt bao status >/dev/null 2>&1; test $$? -ne 1"]
interval: 5s
timeout: 3s
retries: 12
start_period: 10s
restart: unless-stopped
stop_grace_period: 15s
deploy:
resources:
limits: {cpus: "0.50", memory: 256M}
# Новый volume принадлежит root, а OpenBao работает от uid 10001: одноразово отдаём каталоги.
openbao-init:
image: mtusi-messenger:lab7
pull_policy: never
user: "0:0"
entrypoint: ["chown", "-R", "10001:10001", "/openbao/data", "/openbao/logs"]
security_opt: ["no-new-privileges:true"]
cap_drop: [ALL]
cap_add: [CHOWN, DAC_OVERRIDE, FOWNER]
volumes: ["baodata:/openbao/data", "baologs:/openbao/logs"]
network_mode: none
restart: "no"
deploy:
resources:
limits: {cpus: "0.25", memory: 64M}
# ---------- хранилища ----------
# PostgreSQL: только TLS (pg_hba.conf), раздельные роли. Ключ сервера копируется в каталог postgres
# с mode 600 (PostgreSQL не принимает ключ, доступный группе/всем — а bind mount с Windows такой).
# Исключение hardening: entrypoint образа стартует от root и переключается на postgres (gosu), поэтому
# нужны CHOWN/DAC_OVERRIDE/FOWNER/SETUID/SETGID; корень не read-only (stateful, /var/run/postgresql).
postgres:
image: postgres:17.10-bookworm
security_opt: ["no-new-privileges:true"]
cap_drop: [ALL]
cap_add: [CHOWN, DAC_OVERRIDE, FOWNER, SETUID, SETGID]
environment:
POSTGRES_USER: messenger
POSTGRES_DB: messenger
POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password
entrypoint:
- sh
- -c
- >-
install -m 0600 -o postgres -g postgres /run/tls/tls.key /var/lib/postgresql/server.key &&
install -m 0644 -o postgres -g postgres /run/tls/tls.crt /var/lib/postgresql/server.crt &&
exec docker-entrypoint.sh postgres
-c ssl=on -c ssl_cert_file=/var/lib/postgresql/server.crt -c ssl_key_file=/var/lib/postgresql/server.key
-c ssl_min_protocol_version=TLSv1.2 -c hba_file=/etc/postgresql/pg_hba.conf
-c password_encryption=scram-sha-256
-c fsync=on -c synchronous_commit=on -c full_page_writes=on
secrets: [postgres_password, db_api_password, db_worker_password]
volumes:
- pgdata:/var/lib/postgresql/data
- ./infra/postgres/pg_hba.conf:/etc/postgresql/pg_hba.conf:ro
- ./infra/postgres/initdb:/docker-entrypoint-initdb.d:ro
- ./secrets/tls/postgres:/run/tls:ro
- *ca
healthcheck:
test: ["CMD-SHELL", "pg_isready -h 127.0.0.1 -U messenger -d messenger"]
interval: 5s
timeout: 3s
retries: 12
start_period: 10s
restart: unless-stopped
stop_grace_period: 30s
networks: [backend]
deploy:
resources:
limits: {cpus: "1.00", memory: 512M}
valkey:
<<: *hardened
image: valkey/valkey:8.1.9
user: valkey # не root: entrypoint образа ничего не меняет и не переключает
command: ["valkey-server", "/usr/local/etc/valkey/valkey.conf"]
read_only: true
tmpfs: ["/tmp:size=16m"]
volumes:
- ./infra/valkey/valkey.conf:/usr/local/etc/valkey/valkey.conf:ro
- ./secrets/tls/valkey:/run/tls:ro
- *ca
secrets: [valkey_acl]
healthcheck:
test: ["CMD-SHELL", "valkey-cli --tls --cacert /run/ca/ca.crt -h 127.0.0.1 -p 6379 --user health --pass none --no-auth-warning ping | grep -q PONG"]
interval: 5s
timeout: 3s
retries: 12
restart: unless-stopped
networks: [backend]
deploy:
resources:
limits: {cpus: "0.50", memory: 128M}
# SeaweedFS: S3 только по HTTPS (:9000, сертификат s3). master/volume/filer — на 127.0.0.1 контейнера.
# Root внутри контейнера (так устроен образ), но без capabilities и с read-only корнем.
s3:
<<: *hardened
image: chrislusf/seaweedfs:4.44
# Не root: /data в образе принадлежит seaweed (1000). Root с cap_drop ALL (без DAC_OVERRIDE)
# писать туда не может, а возвращать capability ради этого незачем.
user: "1000:1000"
entrypoint: ["/usr/bin/weed"]
command: ["server", "-dir=/data", "-ip=127.0.0.1", "-ip.bind=127.0.0.1",
"-master.volumeSizeLimitMB=1024", "-volume.max=0", "-master.telemetry=false",
"-s3", "-s3.ip.bind=0.0.0.0", "-s3.port=9000", "-s3.iam=false",
"-s3.config=/run/secrets/s3_config",
"-s3.cert.file=/run/tls/tls.crt", "-s3.key.file=/run/tls/tls.key"]
read_only: true
tmpfs: ["/tmp:size=32m"]
secrets: [s3_config]
volumes:
- s3data:/data
- ./secrets/tls/s3:/run/tls:ro
- *ca
healthcheck:
test: ["CMD", "curl", "-fsS", "--cacert", "/run/ca/ca.crt", "-o", "/dev/null", "https://127.0.0.1:9000/healthz"]
interval: 5s
timeout: 3s
retries: 12
start_period: 15s
restart: unless-stopped
stop_grace_period: 15s
networks: [backend]
deploy:
resources:
limits: {cpus: "0.50", memory: 512M}
s3-init:
<<: *hardened
image: mtusi-messenger:lab7
build: *build
command: ["python", "-m", "messenger.s3bootstrap"]
environment:
S3_ENDPOINT: ${S3_ENDPOINT:-https://s3:9000}
S3_REGION: ${S3_REGION:-us-east-1}
S3_BUCKET: ${S3_BUCKET:-messenger-attachments}
S3_ADMIN_ACCESS_KEY_ID_FILE: /run/secrets/s3_root_user
S3_ADMIN_SECRET_ACCESS_KEY_FILE: /run/secrets/s3_root_password
TLS_CA_FILE: /run/ca/ca.crt
secrets: [s3_root_user, s3_root_password]
volumes: [*ca]
read_only: true
networks: [backend]
depends_on:
s3: {condition: service_healthy}
healthcheck:
disable: true
restart: "no"
deploy:
resources:
limits: {cpus: "0.50", memory: 128M}
# RabbitMQ: только AMQPS 5671 + SASL EXTERNAL, пользователи и топология — infra/rabbitmq/definitions.json.
# Узел один: кластерного канала нет. Порт Erlang distribution (25672, нужен CLI rabbitmq-diagnostics)
# виден только во внутренней сети backend и закрыт cookie из volume (REPORT.md, «Ограничения»).
# Исключение hardening: entrypoint образа меняет владельца volume и переключается на rabbitmq (su-exec).
broker:
image: rabbitmq:4.2.9-alpine
hostname: broker
security_opt: ["no-new-privileges:true"]
cap_drop: [ALL]
cap_add: [CHOWN, DAC_OVERRIDE, FOWNER, SETUID, SETGID]
environment:
RABBITMQ_CONFIG_FILES: /etc/rabbitmq/conf.d
volumes:
- rabbitmqdata:/var/lib/rabbitmq
- ./infra/rabbitmq/20-messenger.conf:/etc/rabbitmq/conf.d/20-messenger.conf:ro
- ./infra/rabbitmq/definitions.json:/etc/rabbitmq/definitions.json:ro
- ./infra/rabbitmq/enabled_plugins:/etc/rabbitmq/enabled_plugins:ro
- ./secrets/tls/broker:/run/tls:ro
- *ca
healthcheck:
test: ["CMD", "rabbitmq-diagnostics", "-q", "ping"]
interval: 10s
timeout: 10s
retries: 6
start_period: 60s
start_interval: 2s
restart: unless-stopped
stop_grace_period: 30s
networks: [backend]
deploy:
resources:
limits: {cpus: "1.00", memory: 512M}
# ---------- наблюдаемость ----------
# mTLS-шлюз перед Collector (infra/otel/gateway.cfg): identity api/worker, остальным — 403.
# Владелец network namespace: otel-collector подключается к нему (network_mode: service:otlp-gw),
# поэтому имя otel-collector в сетях otlp и telemetry — это адрес шлюза.
otlp-gw:
<<: *hardened
image: haproxy:3.2.25-alpine
read_only: true
tmpfs: ["/tmp:size=8m"]
volumes:
- ./infra/otel/gateway.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
- ./secrets/tls/otel-collector:/run/tls:ro
- *ca
networks:
otlp: {aliases: [otel-collector]}
telemetry: {aliases: [otel-collector]}
healthcheck:
test: ["CMD", "wget", "-q", "-T", "2", "-O", "/dev/null", "http://127.0.0.1:8406/healthz"]
interval: 5s
timeout: 3s
retries: 6
start_period: 10s
restart: unless-stopped
deploy:
resources:
limits: {cpus: "0.25", memory: 64M}
otel-collector:
<<: *hardened
image: otel/opentelemetry-collector-contrib:0.140.1
command: ["--config=/etc/otelcol-contrib/config.yaml"]
network_mode: "service:otlp-gw" # слушает 127.0.0.1:14318 общего со шлюзом namespace
read_only: true
tmpfs: ["/tmp:size=16m"]
volumes:
- ./infra/otel/collector.yaml:/etc/otelcol-contrib/config.yaml:ro
- ./secrets/tls/otel-collector:/run/tls:ro
- *ca
depends_on:
otlp-gw: {condition: service_healthy}
restart: unless-stopped
deploy:
resources:
limits: {cpus: "0.50", memory: 512M}
prometheus:
<<: *hardened
image: prom/prometheus:v3.7.3
command:
- --config.file=/etc/prometheus/prometheus.yml
- --web.config.file=/etc/prometheus/web.yml
- --storage.tsdb.path=/prometheus
- --storage.tsdb.retention.time=15d
- --web.enable-otlp-receiver
read_only: true
volumes:
- ./infra/prometheus/prometheus.yml:/etc/prometheus/prometheus.yml:ro
- ./infra/prometheus/web.yml:/etc/prometheus/web.yml:ro
- ./infra/prometheus/client.yml:/etc/prometheus/client.yml:ro
- ./infra/prometheus/rules:/etc/prometheus/rules:ro
- ./secrets/tls/prometheus:/run/tls:ro
- *ca
- promdata:/prometheus
networks: [telemetry]
healthcheck:
test: ["CMD", "promtool", "check", "ready", "--url=https://127.0.0.1:9090", "--http.config.file=/etc/prometheus/client.yml"]
interval: 5s
timeout: 3s
retries: 12
start_period: 20s
restart: unless-stopped
deploy:
resources:
limits: {cpus: "1.00", memory: 512M}
# mTLS-шлюз перед Loki и Tempo (infra/tsdb/gateway.cfg): у их HTTP-серверов нет allowlist identity,
# поэтому её проверяет шлюз — loki:3100 пускает otel-collector и grafana, tempo:3200 — grafana,
# tempo:4318 — otel-collector; остальным identity нашего CA — 403. Владелец network namespace:
# loki и tempo подключаются к нему (network_mode: service:tsdb-gw) и слушают только 127.0.0.1.
tsdb-gw:
<<: *hardened
image: haproxy:3.2.25-alpine
read_only: true
tmpfs: ["/tmp:size=8m"]
volumes:
- ./infra/tsdb/gateway.cfg:/usr/local/etc/haproxy/haproxy.cfg:ro
- ./secrets/tls/loki:/run/tls-loki:ro
- ./secrets/tls/tempo:/run/tls-tempo:ro
- *ca
networks:
telemetry: {aliases: [loki, tempo]}
healthcheck:
test: ["CMD", "wget", "-q", "-T", "2", "-O", "/dev/null", "http://127.0.0.1:8407/healthz"]
interval: 5s
timeout: 3s
retries: 6
start_period: 10s
restart: unless-stopped
deploy:
resources:
limits: {cpus: "0.25", memory: 64M}
loki:
<<: *hardened
image: grafana/loki:3.5.8
command: ["-config.file=/etc/loki/loki.yaml"]
network_mode: "service:tsdb-gw" # слушает 127.0.0.1:13100 общего со шлюзом namespace
read_only: true
tmpfs: ["/tmp:size=32m"]
volumes:
- ./infra/loki/loki.yaml:/etc/loki/loki.yaml:ro
- lokidata:/loki
depends_on:
tsdb-gw: {condition: service_healthy}
restart: unless-stopped
stop_grace_period: 30s
deploy:
resources:
limits: {cpus: "1.00", memory: 512M}
tempo-init:
image: grafana/tempo:2.9.0
user: root
entrypoint: ["chown", "10001:10001", "/var/tempo"]
security_opt: ["no-new-privileges:true"]
cap_drop: [ALL]
cap_add: [CHOWN]
volumes: ["tempodata:/var/tempo"]
network_mode: none
restart: "no"
deploy:
resources:
limits: {cpus: "0.25", memory: 64M}
tempo:
<<: *hardened
image: grafana/tempo:2.9.0
command: ["-config.file=/etc/tempo/tempo.yaml"]
network_mode: "service:tsdb-gw" # слушает 127.0.0.1:13200 и :14318 общего со шлюзом namespace
read_only: true
tmpfs: ["/tmp:size=32m"]
volumes:
- ./infra/tempo/tempo.yaml:/etc/tempo/tempo.yaml:ro
- tempodata:/var/tempo
depends_on:
tsdb-gw: {condition: service_healthy}
tempo-init: {condition: service_completed_successfully}
restart: unless-stopped
stop_grace_period: 30s
deploy:
resources:
limits: {cpus: "1.00", memory: 512M}
# Grafana: HTTPS для оператора (https://127.0.0.1:3000, admin + пароль из secrets/grafana_admin_password),
# к хранилищам — mTLS со своим сертификатом grafana (provisioning/datasources).
grafana:
<<: *hardened
image: grafana/grafana:12.2.1
environment:
GF_SERVER_PROTOCOL: https
GF_SERVER_CERT_FILE: /run/tls/tls.crt
GF_SERVER_CERT_KEY: /run/tls/tls.key
GF_SERVER_DOMAIN: localhost
GF_SECURITY_ADMIN_USER: admin
GF_SECURITY_ADMIN_PASSWORD__FILE: /run/secrets/grafana_admin_password
GF_SECURITY_COOKIE_SECURE: "true"
GF_USERS_ALLOW_SIGN_UP: "false"
GF_AUTH_ANONYMOUS_ENABLED: "false"
GF_ANALYTICS_REPORTING_ENABLED: "false"
GF_ANALYTICS_CHECK_FOR_UPDATES: "false"
GF_ANALYTICS_CHECK_FOR_PLUGIN_UPDATES: "false"
GF_NEWS_NEWS_FEED_ENABLED: "false"
GF_PLUGINS_PREINSTALL_DISABLED: "true"
GF_LOG_MODE: console
secrets: [grafana_admin_password]
read_only: true
tmpfs: ["/tmp:size=32m", "/var/log/grafana:size=8m"]
volumes:
- ./infra/grafana/provisioning:/etc/grafana/provisioning:ro
- ./infra/grafana/dashboards:/var/lib/grafana/dashboards:ro
- ./secrets/tls/grafana:/run/tls:ro
- *ca
- grafanadata:/var/lib/grafana
ports:
- "127.0.0.1:3000:3000"
networks: [telemetry, ops]
depends_on:
prometheus: {condition: service_healthy}
loki: {condition: service_started}
tempo: {condition: service_started}
healthcheck:
# HTTPS-порт слушается (0BB8 = 3000, состояние 0A = LISTEN). Проверка сертификата здесь не нужна:
# healthcheck не клиент, он только смотрит, что процесс принимает соединения.
test: ["CMD-SHELL", "cat /proc/net/tcp /proc/net/tcp6 2>/dev/null | grep -q ':0BB8 [0-9A-F:]* 0A '"]
interval: 5s
timeout: 3s
retries: 20
start_period: 30s
restart: unless-stopped
deploy:
resources:
limits: {cpus: "1.00", memory: 512M}
# ---------- проверки ----------
# Интеграционные тесты хранилища и заданий — ролью-владельцем (тестам нужна схема целиком).
db-test:
<<: *hardened
image: mtusi-messenger:lab7
profiles: [tools]
pull_policy: never
env_file: .env
environment:
DATABASE_URL: postgresql://messenger@postgres:5432/messenger?sslmode=verify-full&sslrootcert=/run/ca/ca.crt
DATABASE_URL_FILE: ""
DB_PASSWORD_FILE: /run/secrets/postgres_password
CACHE_URL_FILE: ""
S3_ACCESS_KEY_ID_FILE: ""
S3_SECRET_ACCESS_KEY_FILE: ""
BROKER_URL_FILE: ""
OTEL_SDK_DISABLED: "true"
secrets: [postgres_password]
networks: [backend]
read_only: true
tmpfs: ["/tmp:size=32m"]
volumes: ["./student-tests:/srv/student-tests:ro", *ca]
command: ["python", "-m", "unittest", "discover", "-s", "student-tests/db", "-v"]
depends_on:
postgres: {condition: service_healthy}
deploy:
resources:
limits: {cpus: "1.00", memory: 512M}
imaging-test:
<<: *hardened
image: mtusi-messenger:lab7
profiles: [tools]
pull_policy: never
network_mode: none
read_only: true
tmpfs: ["/tmp:size=256m"]
volumes: ["./student-tests:/srv/student-tests:ro", "./tests/fixtures:/srv/tests/fixtures:ro"]
command: ["python", "-m", "unittest", "discover", "-s", "student-tests/worker", "-v"]
deploy:
resources:
limits: {cpus: "1.00", memory: 1G}
volumes:
pgdata: {}
s3data: {}
rabbitmqdata: {}
promdata: {}
lokidata: {}
tempodata: {}
grafanadata: {}
baodata: {} # с lab7: зашифрованное хранилище OpenBao
baologs: {} # с lab7: audit log OpenBao
secrets:
postgres_password: {file: ./secrets/postgres_password}
db_api_password: {file: ./secrets/db_api_password}
db_worker_password: {file: ./secrets/db_worker_password}
valkey_acl: {file: ./secrets/valkey_users.acl}
s3_config: {file: ./secrets/s3_config.json}
s3_root_user: {file: ./secrets/s3_root_user}
s3_root_password: {file: ./secrets/s3_root_password}
grafana_admin_password: {file: ./secrets/grafana_admin_password}
networks:
public: {}
edge: {internal: true}
backend: {internal: true}
otlp: {internal: true}
telemetry: {internal: true}
vault: {internal: true}
ops: {}
+48 -27
View File
@@ -1,37 +1,58 @@
# Матрица доверия — заполнить в решении lab7
# Матрица доверия — lab7 (решение bvt2303-gadzhiev)
Это обязательная матрица покрытия. Для каждой строки укажите реальный порт, endpoint, CA, service identity, проверку SAN/ACL, срок жизни credentials и команду положительного/отрицательного теста. TLS шифрует и подтверждает сервер; mTLS также проверяет клиента. При доверенном CA всё равно нужно ограничивать разрешённую identity. Plaintext hop допустим только внутри закрытого локального transport/proxy boundary, без опубликованного обхода; границу и rationale нужно доказать.
Реализация шаблона `trust-matrix.md`. Один локальный CA стенда (`scripts/pki.py`, `secrets/ca/ca.key` —
только у оператора). У каждого сервиса свой leaf-сертификат: `CN = SAN DNS = имя сервиса`, срок 30 дней,
`serverAuth + clientAuth`. CA-сертификат и CRL публичны (`secrets/tls/ca/`, смонтированы в каждый контейнер
как `/run/ca`). TLS шифрует и подтверждает сервер; mTLS дополнительно проверяет клиента; где нужен ещё и
список разрешённых identity — он указан в колонке «identity/ACL». Доверенного CA самого по себе всегда мало.
| Связь | Минимум на 3 | Дополнительно на 4 | Доказательство / конфиг |
| --- | --- | --- | --- |
| Клиент → ingress/LB | TLS, CA + hostname, Bearer | Проверка expiry/revocation сессии и общего login rate limit | TODO |
| LB → API (все реплики) | mTLS + allowlist LB identity | Ротация leaf без обхода проверки | TODO |
| API/worker → PostgreSQL | TLS verify-full + раздельные ограниченные DB roles | Ротация credentials; mTLS — допустимое усиление | TODO |
| API/worker → S3 | TLS + разные scoped credentials/prefix rights | Проверка denied prefix и ротация | TODO |
| API/worker → broker | TLS + разные producer/consumer identities и ACL | mTLS + ограничение допустимых SAN/ролей | TODO |
| API/worker → Collector | TLS; сеть/аутентификация запрещает произвольный ingest | mTLS с раздельными identities | TODO |
| Collector → telemetry backends | TLS + scoped backend credentials или mTLS | Ротация и проверка least privilege | TODO |
| Grafana → data sources | TLS с проверкой сервера, ограниченная identity | Отрицательные проверки доступа | TODO |
| API/worker/agent → OpenBao | TLS + сервисный auth + scoped policy | Renewal/expiry/revocation | TODO |
| Оператор → OpenBao/Grafana/S3 admin | TLS + authentication, доступ локальный/через защищённый канал | Разделение operator/application roles | TODO |
| API → Redis/Valkey, если используется | TLS + ACL/пароль с минимальными правами | Ротация; mTLS по возможности | TODO |
| Replication/кластерные каналы, если добавлены | TLS/mTLS либо подтверждённый шифрованный transport | Проверка заявленной модели отказа | TODO |
Проверки: `make test-security` (внешний TLS), `make tls-matrix` (транспорт всей матрицы изнутри сетей),
`make acl-matrix` (права identity), `make check-stack` (hardening, порты, сети). Отрицательные тесты
`tls_matrix.py` / `acl_matrix.py` (общий код — `matrix.py`, контейнер `sectest`) и `test_limits.py`.
Нет выбранного компонента — отметьте N/A с причиной, а не оставляйте пустую строку. Внутренний публичный health listener, если нужен, минимален и изолирован; через него нельзя обращаться к бизнес-API без mTLS. Отдельно задокументируйте scrape/health/bootstrap каналы: они тоже не должны создавать обход.
| Связь | Порт / endpoint | Протокол | Серверная identity | Клиентская identity / ACL | Срок / ротация | Доказательство / конфиг |
| --- | --- | --- | --- | --- | --- | --- |
| Клиент → ingress/LB | `127.0.0.1:8443` (`/health/ready`, `/api/...`) | TLS 1.2+ | `lb` (SAN `lb`,`localhost`,`127.0.0.1`), проверяет клиент по CA | Bearer-сессия + лимит входа (429) + HSTS | leaf 30д; `make rotate-lb-cert` | `infra/haproxy/haproxy.cfg` (`bind ssl`); `make test-security`, `tls_matrix.py` (client_to_lb) |
| LB → API (каждая реплика) | `api:8080` | **mTLS** 1.2+ | реплика предъявляет `api`, LB проверяет `verifyhost api` | сервер пускает только SAN из `TLS_ALLOWED_CLIENTS=lb` + серийник не в CRL (`tlsserver.py`) | leaf 30д; ротация leaf lb без простоя, старый → CRL | `haproxy.cfg` (`default-server ssl verify required crt verifyhost api`), `src/messenger/tlsserver.py`; `tls_matrix.py` (lb_to_api) |
| API/worker → PostgreSQL | `postgres:5432` | TLS `verify-full` | `postgres` (SAN), проверяет клиент | роли `messenger_api` / `messenger_worker`, SCRAM, `hostssl`-только; без TLS — reject | пароль роли в OpenBao; `make rotate-db-secret` | `infra/postgres/pg_hba.conf`, `migrations/007_roles.sql`, `src/messenger/db.py`; `acl_matrix.py` |
| API/worker → S3 | `s3:9000` | HTTPS (TLS 1.2+) | `s3` (SAN), проверяет клиент (`verify=CA`) | разные ключи api/worker, права по префиксам (`staging/` W, `originals/`+`variants/` R у api; worker R `staging/`+`originals/`, W/List bucket) | ключи в OpenBao | `scripts/init-secrets.sh` (`s3_config.json`), `src/messenger/objects.py`; `s3_checks.py`, `acl_matrix.py` |
| API/worker → broker | `broker:5671` | **mTLS** 1.2+ + SASL EXTERNAL | `broker` (SAN), проверяет клиент | пользователь = CN сертификата: `api` только write exchange `attachments`, `worker` только read `attachments.process`; чужой CN того же CA → вход отклонён | leaf 30д | `infra/rabbitmq/20-messenger.conf`,`definitions.json`, `src/messenger/broker.py`; `tls_matrix.py`, `acl_matrix.py` |
| API/worker → Collector | `otel-collector:4318` (шлюз `otlp-gw`) | **mTLS** 1.2+ | `otel-collector` (SAN), проверяет клиент | шлюз пускает только CN `api`,`worker`; иначе 403. Сам Collector слушает `127.0.0.1:14318` общего namespace — обхода нет | leaf 30д | `infra/otel/gateway.cfg`,`collector.yaml`; `tls_matrix.py` (api_to_collector) |
| Collector → Prometheus | `prometheus:9090` | **mTLS** 1.2+ | `prometheus` (SAN) | `client_allowed_sans: otel-collector, grafana, prometheus` — остальные identity нашего CA отклоняются | leaf 30д | `infra/prometheus/web.yml`, `collector.yaml`; `tls_matrix.py` |
| Collector → Loki, Tempo | `loki:3100`, `tempo:4318` (шлюз `tsdb-gw`) | **mTLS** 1.2+ | `loki` / `tempo` (SAN, сертификаты у шлюза) | шлюз пускает только CN `otel-collector` (на `:3100` ещё `grafana`); иначе 403. Loki и Tempo слушают только `127.0.0.1` общего со шлюзом namespace — обхода нет | leaf 30д | `infra/tsdb/gateway.cfg`, `loki.yaml`, `tempo.yaml`; `tls_matrix.py` |
| Grafana → хранилища | `prometheus:9090`, `loki:3100`, `tempo:3200` | **mTLS** 1.2+ | те же (SAN) | клиент `grafana` (`provisioning/datasources`); `tempo:3200` пускает только `grafana` | leaf 30д | `infra/grafana/provisioning/datasources/datasources.yaml`, `infra/tsdb/gateway.cfg`; `tls_matrix.py` |
| API/worker/оператор → OpenBao | `openbao:8200` | TLS 1.2+, клиентский сертификат проверяется при входе (cert auth) | `openbao` (SAN), проверяет клиент | роль `messenger-api`/`-worker` принимает только CN `api`/`worker` нашего CA; политика = read своего пути KV | токен 15 мин, renew ≤ 1 ч, потом вход заново; `make bao-revoke-tokens` | `infra/openbao/bao.hcl`,`policies/*.hcl`, `scripts/bao.py`, `src/messenger/secretsource.py`; `acl_matrix.py` |
| Оператор → OpenBao/Grafana/S3-admin | локально / сеть `vault`,`ops` | TLS (+ mTLS к OpenBao) | как выше | root token и unseal shares — только у оператора (`secrets/operator/`, 600); ключи S3-admin только у `s3-init` | — | `scripts/bao.py`, `compose.yaml` (сервис `ops`) |
| API → Valkey | `valkey:6379` | TLS 1.2+ (`valkeys://`) | `valkey` (SAN), проверяет клиент | пользователь `messenger` (ACL: только `sess:*`,`rl:*` и нужные команды); `default` off | пароль ACL в OpenBao | `infra/valkey/valkey.conf`, `scripts/init-secrets.sh`; `acl_matrix.py` |
| Репликация/кластер | — | N/A | — | один узел у PostgreSQL, Valkey, брокера и OpenBao: кластерных каналов нет. Erlang distribution брокера — только `127.0.0.1` контейнера | — | `check_stack.py` (нет лишних портов) |
Grafana как HTTPS-сервер для оператора: `grafana` (SAN `localhost`), `127.0.0.1:3000`. Health-listener реплики
(`127.0.0.1:8081` внутри контейнера) — отдельный процесс только для `/health/*`, бизнес-API через него нет
(`src/messenger/healthcheck.py`): обхода mTLS он не создаёт. Prometheus `:8888` Collector и `lb:8404` — каналы
scrape/метрик, только чтение, внутренняя сеть `telemetry`.
## Обязательные отрицательные проверки
1. HTTPS с правильным CA/hostname проходит; с пустым/чужим CA и неправильным hostname — ошибка верификации, не «сервер недоступен».
2. LB→API: без client cert, с cert чужого CA, с запрещённой identity от доверенного CA — отказ; с разрешённой LB identity — успех.
3. На 4 повторите набор для broker и Collector; ограничение на network policy не заменяет проверку identity.
4. Пользователь вне чата не читает metadata/content и не прикрепляет чужой файл; поддельный X-User-Id не меняет Bearer identity.
5. OpenBao app policy читает только свой secret/path; запись policy и чтение чужого path запрещены. Worker не получает admin credentials API/БД/S3.
6. На 4 отзовите secret/cert и дождитесь контролируемого эффекта с учётом действующих соединений, TLS resumption и cache/TTL. Покажите новое подключение, иначе тест отзыва может ничего не проверить.
1. HTTPS с правильным CA/hostname → 200; пустой/чужой trust store и неверный hostname → ошибка проверки
сертификата, не «сервер недоступен». — `make test-security` (публичный, проходит); `tls_matrix.py` (client_to_lb).
2. LB→API: без client cert / cert чужого CA / запрещённая identity нашего CA (`intruder`, `worker`) / истёкший →
отказ; `lb` → успех. — `tls_matrix.py` (lb_to_api), `src/messenger/tlsserver.py`.
3. Для broker и Collector — тот же набор; network policy не заменяет проверку identity. — `tls_matrix.py`.
4. Пользователь вне чата не читает metadata/content и не прикрепляет чужой файл; поддельный `X-User-Id` не
меняет Bearer-identity. — `test_api.py`, `test_attachments.py` (сохранены с lab4), `acl_matrix.py`.
5. Политика приложения OpenBao читает только свой путь; запись политики и чтение чужого пути запрещены;
worker не получает admin-credentials. — `acl_matrix.py`.
6. Отзыв secret/cert с учётом действующих соединений, TLS resumption и TTL; показать НОВОЕ подключение. —
`make rotate-db-secret`, `make rotate-lb-cert`, `make bao-revoke-tokens`, `make bao-token-ttl`; REPORT.md «Эксперименты».
## Bootstrap и эксплуатация
В репозитории только открытые конфиги, policy templates и scripts. CA private key, leaf keys, root token, unseal shares и SecretID не коммитятся, не запекаются в образ и не печатаются в отчёте. Для локального стенда оператор создаёт их вне Git и передаёт через files/secrets с ограниченными правами. Опишите, кто имеет доступ к CA/unseal, что нужно после рестарта OpenBao и как восстановить работу.
В репозитории только открытые конфиги, шаблоны политик и скрипты. CA private key, leaf keys, root token,
unseal shares и пароли создаются локально (`make secrets pki`, `make bao-init`) в `secrets/` (в `.gitignore`),
не коммитятся, не запекаются в образ, не печатаются. Доступ к CA и unseal — только у оператора.
OpenBao не использует dev-mode. Выберите persistent storage и auth метод (например AppRole с короткоживущим SecretID/response wrapping, cert auth или иная обоснованная identity). Не подменяйте root token постоянной переменной BAO_TOKEN в приложении. Рабочие tokens имеют policy, TTL и renewal/re-auth сценарий. Статические KV secrets на 3 допустимы при реальном чтении через сервисную identity; динамические DB credentials — хорошее расширение, но не обязательное название технологии.
Разрешённый компромисс учебного стенда: ручной operator init/unseal, если он безопасно документирован и не нужен при каждом обычном рестарте API. Автоматическое хранение всех unseal shares рядом с OpenBao без защиты не считается решённым bootstrap.
OpenBao — `file` storage, не dev-mode, cert auth (`AppRole`-подобная сервисная identity по сертификату).
Root token в приложении не используется; рабочие токены имеют политику, TTL и сценарий re-auth.
Учебный компромисс: ручной `make bao-unseal` после рестарта OpenBao (документировано, при обычном
рестарте API не требуется). Unseal shares лежат рядом в `secrets/operator/` с правами 600 — это
упрощение учебного стенда; в production три shares расходятся трём держателям (см. `infra/openbao/README.md`).
+131
View File
@@ -0,0 +1,131 @@
docker compose --profile tools run --rm sectest student-tests/acl_matrix.py
Container mtusi-lab7-sectest-run-be9f379b896e Creating
Container mtusi-lab7-sectest-run-be9f379b896e Created
ACL matrix (lab7): what each identity may do
============================================
## OpenBao: cert auth roles and KV policies
OK api login role messenger-api expect allow got HTTP 200 policies=['default', 'messenger-api']
OK api token has no root/admin policy expect own got default,messenger-api
OK worker login role messenger-worker expect allow got HTTP 200 policies=['default', 'messenger-worker']
OK worker token has no root/admin policy expect own got default,messenger-worker
OK worker login role messenger-api expect deny got HTTP 400
OK api login role messenger-worker expect deny got HTTP 400
OK lb login role messenger-api expect deny got HTTP 400
OK intruder login role messenger-api expect deny got HTTP 400
OK intruder login role messenger-worker expect deny got HTTP 400
OK api read own KV path expect allow got HTTP 200
OK api read worker KV path expect deny got HTTP 403
OK api write own KV path expect deny got HTTP 403
OK api list KV paths expect deny got HTTP 403
OK api read KV metadata/versions expect deny got HTTP 403
OK api rewrite own policy expect deny got HTTP 403
OK api read policies expect deny got HTTP 403
OK api list secret engines expect deny got HTTP 403
OK api list cert auth roles expect deny got HTTP 403
OK api create token with more policies expect deny got HTTP 403
OK worker read own KV path expect allow got HTTP 200
OK worker read api KV path expect deny got HTTP 403
OK worker write own KV path expect deny got HTTP 403
OK worker list KV paths expect deny got HTTP 403
OK worker read KV metadata/versions expect deny got HTTP 403
OK worker rewrite own policy expect deny got HTTP 403
OK worker read policies expect deny got HTTP 403
OK worker list secret engines expect deny got HTTP 403
OK worker list cert auth roles expect deny got HTTP 403
OK worker create token with more policies expect deny got HTTP 403
OK worker secret has no Valkey/admin credentials expect none got db_password,s3_access_key_id,s3_secret_access_key
## PostgreSQL: roles messenger_api / messenger_worker
OK api connect as messenger_api (TLS verify-full) expect allow got connected
OK api SELECT users expect allow got executed (rolled back)
OK api SELECT messages expect allow got executed (rolled back)
OK api SELECT sessions expect allow got executed (rolled back)
OK api UPDATE chats expect allow got executed (rolled back)
OK api DELETE outbox expect allow got executed (rolled back)
OK api DELETE users expect deny got permission denied
OK api DELETE messages expect deny got permission denied
OK api DELETE schema_migrations expect deny got permission denied
OK api TRUNCATE outbox expect deny got permission denied
OK api CREATE TABLE expect deny got permission denied
OK api ALTER TABLE users expect deny got permission denied
OK api DROP TABLE expect deny got permission denied
OK api CREATE ROLE expect deny got permission denied
OK worker connect as messenger_worker (TLS verify-full) expect allow got connected
OK worker SELECT attachments expect allow got executed (rolled back)
OK worker SELECT attachment_jobs expect allow got executed (rolled back)
OK worker UPDATE attachments expect allow got executed (rolled back)
OK worker DELETE outbox expect allow got executed (rolled back)
OK worker SELECT users (password hashes) expect deny got permission denied
OK worker SELECT sessions expect deny got permission denied
OK worker SELECT chats expect deny got permission denied
OK worker SELECT chat_members expect deny got permission denied
OK worker SELECT messages expect deny got permission denied
OK worker SELECT message_attachments expect deny got permission denied
OK worker DELETE attachments expect deny got permission denied
OK worker TRUNCATE attachment_jobs expect deny got permission denied
OK worker CREATE TABLE expect deny got permission denied
OK worker ALTER TABLE attachments expect deny got permission denied
OK api api password as role messenger_worker expect deny got authentication failed
OK worker worker password as role messenger_api expect deny got authentication failed
OK api api password as role messenger expect deny got authentication failed
OK worker worker password as role messenger expect deny got authentication failed
OK worker worker password as role postgres expect deny got rejected by pg_hba.conf
## S3: prefixes in bucket messenger-attachments
OK api PUT staging/<id> expect allow got allowed
OK api GET staging/<id> (unchecked upload) expect deny got AccessDenied
OK api PUT originals/<id> (forge original) expect deny got AccessDenied
OK api PUT variants/<id>/... (forge variant) expect deny got AccessDenied
OK api LIST bucket expect deny got AccessDenied
OK worker GET staging/<id> expect allow got allowed
OK worker PUT originals/<id> expect allow got allowed
OK worker PUT variants/<id>/... expect allow got allowed
OK worker LIST bucket expect allow got allowed
OK worker GET variants/<id>/... (not its job) expect deny got AccessDenied
OK api GET originals/<id> expect allow got allowed
OK api GET variants/<id>/... expect allow got allowed
OK api DELETE originals/<id> expect deny got AccessDenied
OK api CREATE bucket expect deny got AccessDenied
OK api DELETE other bucket expect deny got AccessDenied
OK worker CREATE bucket expect deny got AccessDenied
OK worker DELETE other bucket expect deny got AccessDenied
OK api see other buckets (ListBuckets) expect deny got sees []
OK worker see other buckets (ListBuckets) expect deny got sees ['messenger-attachments']
## RabbitMQ: users = certificate CN (SASL EXTERNAL), vhost messenger
OK api publish to exchange attachments expect allow got published (unroutable, dropped)
OK api publish to exchange attachments.dlx expect deny got 403 ACCESS_REFUSED
OK api publish to default exchange expect deny got 403 ACCESS_REFUSED
OK api read queue attachments.process expect deny got 403 ACCESS_REFUSED
OK api read queue attachments.dead expect deny got 403 ACCESS_REFUSED
OK api declare own queue expect deny got 403 ACCESS_REFUSED
OK api declare exchange expect deny got 403 ACCESS_REFUSED
OK api delete queue attachments.process expect deny got 403 ACCESS_REFUSED
OK worker read queue attachments.process expect allow got read allowed (queue empty)
OK worker read queue attachments.dead expect deny got 403 ACCESS_REFUSED
OK worker publish to exchange attachments expect deny got 403 ACCESS_REFUSED
OK worker publish to exchange attachments.dlx expect deny got 403 ACCESS_REFUSED
OK worker declare own queue expect deny got 403 ACCESS_REFUSED
OK worker declare exchange expect deny got 403 ACCESS_REFUSED
OK worker delete queue attachments.process expect deny got 403 ACCESS_REFUSED
## Valkey: ACL users messenger / health / default
OK api SET/GET sess:* (session cache) expect allow got allowed
OK api INCRBY rl:* (rate limit counter) expect allow got allowed
OK api SET key outside sess:*/rl:* expect deny got NOPERM
OK api KEYS * (enumerate sessions) expect deny got NOPERM
OK api SCAN expect deny got NOPERM
OK api FLUSHALL expect deny got NOPERM
OK api CONFIG GET * expect deny got NOPERM
OK api ACL LIST expect deny got NOPERM
OK api EVAL (Lua) expect deny got NOPERM
OK api PUBLISH expect deny got NOPERM
OK health PING expect allow got allowed
OK health GET sess:* expect deny got NOPERM
OK anonymous PING without AUTH (default user off) expect deny got AuthenticationError
OK anonymous GET sess:* without AUTH expect deny got AuthenticationError
OK anonymous AUTH default <api password> expect deny got AuthenticationError
OK worker worker has no Valkey credentials expect deny got absent
PASS: 114 checks
+6
View File
@@ -0,0 +1,6 @@
docker compose exec -T api python - < student-tests/argon2_bench.py
m, MiB t p median ms p95 ms logins/s per core
19 2 1 25.9 28.6 38.6
19 3 1 37.6 46.7 26.6
46 1 1 69.4 96.5 14.4
64 2 1 127.2 159.1 7.9
+30
View File
@@ -0,0 +1,30 @@
python student-tests/check_stack.py
docker: 29.6.2
compose: 5.3.1
api replicas running: 2; container_name not set anywhere
service cpus mem user ro caps added published
api 1.00 384Mi 10001 yes - -
loki 1.00 512Mi 10001 yes - -
prometheus 1.00 512Mi 65534 yes - -
openbao 0.50 256Mi 10001 yes - -
otlp-gw 0.25 64Mi 99 yes - -
grafana 1.00 512Mi 472 yes - 127.0.0.1:3000
tsdb-gw 0.25 64Mi 99 yes - -
broker 1.00 512Mi 0 no CHOWN,DAC_OVERRIDE,FOWNER,SETGID,SETUID -
s3 0.50 512Mi 1000 yes - -
tempo 1.00 512Mi 10001 yes - -
postgres 1.00 512Mi 0 no CHOWN,DAC_OVERRIDE,FOWNER,SETGID,SETUID -
valkey 0.50 128Mi 999 yes - -
otel-collector 0.50 512Mi OCI runtime exec failed: exec failed: unable to start container process: exec: "id": executable file not found in $PATH yes - -
worker 1.00 1024Mi 10001 yes - -
api 1.00 384Mi 10001 yes - -
lb 0.50 128Mi 99 yes - 127.0.0.1:8404, 127.0.0.1:8443, 127.0.0.1:8444
published: lb 127.0.0.1:8443 (HTTPS API), :8444 (short TTL), :8404 (stats, HTTPS); grafana 127.0.0.1:3000 (HTTPS). api, OpenBao, Prometheus, Loki, Tempo, Collector, stores: none
hardening: no privileged/host namespaces/Docker socket; no-new-privileges and cap_drop ALL everywhere; cap_add only for broker, openbao-init, postgres, tempo-init; read-only root except broker, openbao-init, postgres, tempo-init; api/worker are not root; CPU/RAM limits everywhere
networks: only public (lb) and ops (grafana) are not internal; lb: edge+public+telemetry; api: backend+edge+otlp+vault; worker: backend+otlp+vault; postgres: backend; valkey: backend; s3: backend; broker: backend; openbao: vault; otlp-gw: otlp+telemetry; prometheus: telemetry; tsdb-gw: telemetry; grafana: ops+telemetry
balancer: every api server under the /health/ready check over mTLS, no backup servers
secrets: api and worker get NO Docker secrets and no token variables (only their TLS identity -> OpenBao cert auth); migrate -> postgres_password; postgres -> db_api_password, db_worker_password, postgres_password; valkey -> valkey_acl; s3 -> s3_config; s3-init -> s3_root_password, s3_root_user; grafana -> grafana_admin_password
images: broker rabbitmq:4.2.9-alpine; grafana grafana/grafana:12.2.1; lb haproxy:3.2.25-alpine; loki grafana/loki:3.5.8; openbao openbao/openbao:2.4.4; otel-collector otel/opentelemetry-collector-contrib:0.140.1; otlp-gw haproxy:3.2.25-alpine; postgres postgres:17.10-bookworm; prometheus prom/prometheus:v3.7.3; s3 chrislusf/seaweedfs:4.44; tempo grafana/tempo:2.9.0; tempo-init grafana/tempo:2.9.0; tsdb-gw haproxy:3.2.25-alpine; valkey valkey/valkey:8.1.9
PASS: hardening, ports, networks, per-service secrets and TLS identities match the trust matrix
+21
View File
@@ -0,0 +1,21 @@
python -m pip_audit -r requirements.txt --no-deps --disable-pip --progress-spinner off
WARNING:pip_audit._cli:--no-deps is supported, but users are encouraged to fully hash their pinned dependencies
WARNING:pip_audit._cli:Consider using a tool like `pip-compile`: https://pip-tools.readthedocs.io/en/latest/#using-hashes
Found 14 known vulnerabilities in 1 package
Name Version ID Fix Versions
--------- ------- --------------- ------------
starlette 0.46.2 PYSEC-2026-1941 0.47.2
starlette 0.46.2 PYSEC-2026-1942 0.49.1
starlette 0.46.2 PYSEC-2026-161 1.0.1
starlette 0.46.2 PYSEC-2026-161 1.0.1
starlette 0.46.2 PYSEC-2026-2281 1.1.0
starlette 0.46.2 PYSEC-2026-2280 1.1.0
starlette 0.46.2 PYSEC-2026-249 1.3.1
starlette 0.46.2 PYSEC-2026-248 1.3.0
starlette 0.46.2 PYSEC-2026-249 1.3.1
starlette 0.46.2 PYSEC-2026-248 1.3.0
starlette 0.46.2 PYSEC-2026-1942 0.49.1
starlette 0.46.2 PYSEC-2026-1941 0.47.2
starlette 0.46.2 PYSEC-2026-2281 1.1.0
starlette 0.46.2 PYSEC-2026-2280 1.1.0
make: *** [Makefile:162: scan-deps] Error 1
+4
View File
@@ -0,0 +1,4 @@
python tests/resilience.py --mode failover --action-script "scripts/stop-one.cmd" --base-url "https://127.0.0.1:8443" --ca-file "secrets/tls/ca/ca.crt"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 113, "failed_attempts": 0, "first_recovery_seconds": 5.703}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
+175
View File
@@ -0,0 +1,175 @@
Report Summary
┌──────────────────────────────────────────────────────────────────────────────────┬────────────┬─────────────────┐
│ Target │ Type │ Vulnerabilities │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ /scan/app.tar (debian 12.15) │ debian │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/annotated_types-0.8.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/anyio-4.15.1.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/argon2_cffi-25.1.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/argon2_cffi_bindings-26.1.0.dist-info/ME- │ python-pkg │ 0 │
│ TADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/asgiref-3.13.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/boto3-1.43.116.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/botocore-1.43.116.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/certifi-2026.10.23.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/cffi-2.1.1.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/charset_normalizer-3.5.2.dist-info/METAD- │ python-pkg │ 0 │
│ ATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/click-8.5.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/cryptography-50.0.2.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/fastapi-0.115.12.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/googleapis_common_protos-1.76.0.dist-inf- │ python-pkg │ 0 │
│ o/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/h11-0.16.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/idna-3.20.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/jmespath-1.1.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/numpy-2.3.5.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_api-1.45.2.dist-info/METAD- │ python-pkg │ 0 │
│ ATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_exporter_http_transport-0.- │ python-pkg │ 0 │
│ 66b2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_exporter_otlp_common-0.66b- │ python-pkg │ 0 │
│ 2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_exporter_otlp_proto_common- │ python-pkg │ 0 │
│ -1.45.2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_exporter_otlp_proto_http-1- │ python-pkg │ 0 │
│ .45.2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_instrumentation-0.66b2.dis- │ python-pkg │ 0 │
│ t-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_instrumentation_asgi-0.66b- │ python-pkg │ 0 │
│ 2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_instrumentation_botocore-0- │ python-pkg │ 0 │
│ .66b2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_instrumentation_dbapi-0.66- │ python-pkg │ 0 │
│ b2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_instrumentation_fastapi-0.- │ python-pkg │ 0 │
│ 66b2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_instrumentation_logging-0.- │ python-pkg │ 0 │
│ 66b2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_instrumentation_psycopg-0.- │ python-pkg │ 0 │
│ 66b2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_instrumentation_system_met- │ python-pkg │ 0 │
│ rics-0.66b2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_propagator_aws_xray-1.0.2.- │ python-pkg │ 0 │
│ dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_proto-1.45.2.dist-info/MET- │ python-pkg │ 0 │
│ ADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_sdk-1.45.2.dist-info/METAD- │ python-pkg │ 0 │
│ ATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_semantic_conventions-0.66b- │ python-pkg │ 0 │
│ 2.dist-info/METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/opentelemetry_util_http-0.66b2.dist-info- │ python-pkg │ 0 │
│ /METADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/packaging-26.3.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/pika-1.4.4.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/pillow-13.0.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/pip-24.3.1.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/protobuf-7.36.2.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/psutil-7.2.2.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/psycopg-3.3.6.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/psycopg_binary-3.3.6.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/psycopg_pool-3.3.3.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/pycparser-3.1.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/pydantic-2.13.5.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/pydantic_core-2.46.5.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/python_dateutil-2.9.0.post0.dist-info/ME- │ python-pkg │ 0 │
│ TADATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/requests-2.34.2.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/s3transfer-0.19.3.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/simplejpeg-1.9.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/six-1.17.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/starlette-0.46.2.dist-info/METADATA │ python-pkg │ 3 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/typing_extensions-4.16.0.dist-info/METAD- │ python-pkg │ 0 │
│ ATA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/typing_inspection-0.4.4.dist-info/METADA- │ python-pkg │ 0 │
│ TA │ │ │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/urllib3-2.8.0.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/uvicorn-0.34.3.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/valkey-6.1.1.dist-info/METADATA │ python-pkg │ 0 │
├──────────────────────────────────────────────────────────────────────────────────┼────────────┼─────────────────┤
│ usr/local/lib/python3.12/site-packages/wrapt-2.5.2.dist-info/METADATA │ python-pkg │ 0 │
└──────────────────────────────────────────────────────────────────────────────────┴────────────┴─────────────────┘
Legend:
- '-': Not scanned
- '0': Clean (no security findings detected)
Python (python-pkg)
===================
Total: 3 (HIGH: 3, CRITICAL: 0)
┌──────────────────────┬────────────────┬──────────┬────────┬───────────────────┬───────────────┬──────────────────────────────────────────────────────────────┐
│ Library │ Vulnerability │ Severity │ Status │ Installed Version │ Fixed Version │ Title │
├──────────────────────┼────────────────┼──────────┼────────┼───────────────────┼───────────────┼──────────────────────────────────────────────────────────────┤
│ starlette (METADATA) │ CVE-2025-62727 │ HIGH │ fixed │ 0.46.2 │ 0.49.1 │ starlette: Starlette DoS via Range header merging │
│ │ │ │ │ │ │ https://avd.aquasec.com/nvd/cve-2025-62727 │
│ ├────────────────┤ │ │ ├───────────────┼──────────────────────────────────────────────────────────────┤
│ │ CVE-2026-48818 │ │ │ │ 1.1.0 │ starlette: Starlette: SSRF and NTLM credential theft via UNC │
│ │ │ │ │ │ │ paths in StaticFiles... │
│ │ │ │ │ │ │ https://avd.aquasec.com/nvd/cve-2026-48818 │
│ ├────────────────┤ │ │ ├───────────────┼──────────────────────────────────────────────────────────────┤
│ │ CVE-2026-54283 │ │ │ │ 1.3.1 │ starlette: Starlette: request.form() limits silently ignored │
│ │ │ │ │ │ │ for application/x-www-form-urlencoded enable DoS │
│ │ │ │ │ │ │ https://avd.aquasec.com/nvd/cve-2026-54283 │
└──────────────────────┴────────────────┴──────────┴────────┴───────────────────┴───────────────┴──────────────────────────────────────────────────────────────┘
File diff suppressed because it is too large Load Diff
+24
View File
@@ -0,0 +1,24 @@
python -m unittest discover -s student-tests -p "test_limits.py" -v
test_big_body_rejected_before_authentication (test_limits.LimitsTest.test_big_body_rejected_before_authentication) ... ok
test_body_over_limit_chunked_is_413 (test_limits.LimitsTest.test_body_over_limit_chunked_is_413) ... ok
test_body_over_limit_with_content_length_is_413 (test_limits.LimitsTest.test_body_over_limit_with_content_length_is_413) ... ok
test_body_under_limit_is_accepted (test_limits.LimitsTest.test_body_under_limit_is_accepted) ... ok
test_limit_is_per_username (test_limits.LimitsTest.test_limit_is_per_username) ... ok
test_login_failures_lead_to_429_with_retry_after_across_replicas (test_limits.LimitsTest.test_login_failures_lead_to_429_with_retry_after_across_replicas) ... ok
test_old_hash_is_rehashed_on_login (test_limits.LimitsTest.test_old_hash_is_rehashed_on_login) ... ok
test_success_resets_failure_counter (test_limits.LimitsTest.test_success_resets_failure_counter) ... ok
test_wrong_password_does_not_rehash (test_limits.LimitsTest.test_wrong_password_does_not_rehash) ... ok
----------------------------------------------------------------------
Ran 9 tests in 6.108s
OK
POST /users, chunked 66643 bytes without Content-Length -> 413 payload_too_large
POST /users, Content-Length 66643 -> 413 payload_too_large
10 wrong passwords -> 401, served by 2 of 2 replicas
next login (even with the right password) -> 429 rate_limited, Retry-After: 299 s
stored hash params: m=8192,t=1,p=1 -> after login m=19456,t=2,p=1
+24
View File
@@ -0,0 +1,24 @@
== seal: API works on cached secrets
docker compose --profile tools run --rm ops seal
Container mtusi-lab7-ops-run-c7e1163bc17d Creating
Container mtusi-lab7-ops-run-c7e1163bc17d Created
sealed: services keep their cached secrets, new logins and reads fail until make bao-unseal
api-1 | {"timestamp": "2026-11-07T21:05:20.486+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "secrets.refresh_failed", "logger": "messenger.secrets", "message": "OpenBao недоступен (HTTP 503): работаю на секретах в памяти, полученных 10 с назад", "secrets.state": "unavailable"}
api-2 | {"timestamp": "2026-11-07T21:05:11.928+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "secrets.refresh_failed", "logger": "messenger.secrets", "message": "OpenBao недоступен (HTTP 503): работаю на секретах в памяти, полученных 10 с назад", "secrets.state": "unavailable"}
PASS: lab7 public API scenario; infrastructure and grading evidence remain separate.
== unseal
docker compose --profile tools run --rm ops unseal
Container mtusi-lab7-ops-run-84133e93d57d Creating
Container mtusi-lab7-ops-run-84133e93d57d Created
sealed=False (used 2 of 3 shares)
api-1 | {"timestamp": "2026-11-07T21:05:40.522+00:00", "severity": "INFO", "service.name": "messenger-api", "event": "secrets.recovered", "logger": "messenger.secrets", "message": "OpenBao снова доступен"}
api-2 | {"timestamp": "2026-11-07T21:05:41.971+00:00", "severity": "INFO", "service.name": "messenger-api", "event": "secrets.recovered", "logger": "messenger.secrets", "message": "OpenBao снова доступен"}
== revoke tokens -> relogin by certificate
docker compose --profile tools run --rm ops revoke-tokens
Container mtusi-lab7-ops-run-4f188b7f2c5c Creating
Container mtusi-lab7-ops-run-4f188b7f2c5c Created
revoked all tokens issued by auth/cert: services must log in again with their certificates
api-1 | {"timestamp": "2026-11-07T21:06:00.562+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "secrets.relogin", "logger": "messenger.secrets", "message": "OpenBao: токен больше не действует, новый вход"}
api-1 | {"timestamp": "2026-11-07T21:06:00.582+00:00", "severity": "INFO", "service.name": "messenger-api", "event": "secrets.login", "logger": "messenger.secrets", "message": "OpenBao: вход по сертификату, роль messenger-api, политики default,messenger-api, токен на 900 с"}
api-2 | {"timestamp": "2026-11-07T21:05:52.005+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "secrets.relogin", "logger": "messenger.secrets", "message": "OpenBao: токен больше не действует, новый вход"}
api-2 | {"timestamp": "2026-11-07T21:05:52.080+00:00", "severity": "INFO", "service.name": "messenger-api", "event": "secrets.login", "logger": "messenger.secrets", "message": "OpenBao: вход по сертификату, роль messenger-api, политики default,messenger-api, токен на 900 с"}
+3
View File
@@ -0,0 +1,3 @@
python tests/resilience.py --mode persistence --action-script "scripts/restart.cmd" --base-url "https://127.0.0.1:8443" --ca-file "secrets/tls/ca/ca.crt"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
+26
View File
@@ -0,0 +1,26 @@
== rotate-db-secret
docker compose --profile tools run --rm ops rotate-db
Container mtusi-lab7-ops-run-d93b73787775 Creating
Container mtusi-lab7-ops-run-d93b73787775 Created
rotated DB password of messenger_api: PostgreSQL updated, KV secret/messenger/api now version 2 (value not printed)
api-1 | {"timestamp": "2026-11-07T21:04:30.365+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "secrets.rotated", "logger": "messenger.secrets", "message": "OpenBao: новая версия секрета, изменились поля db_password"}
api-1 | {"timestamp": "2026-11-07T21:04:30.376+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "db.pool_drained", "logger": "messenger.db", "message": "Пароль роли БД сменился: пулы соединений пересоздаются (1)"}
api-2 | {"timestamp": "2026-11-07T21:04:31.810+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "secrets.rotated", "logger": "messenger.secrets", "message": "OpenBao: новая версия секрета, изменились поля db_password"}
api-2 | {"timestamp": "2026-11-07T21:04:31.823+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "db.pool_drained", "logger": "messenger.db", "message": "Пароль роли БД сменился: пулы соединений пересоздаются (1)"}
PASS: lab7 public API scenario; infrastructure and grading evidence remain separate.
== rotate-lb-cert
docker compose --profile tools run --rm pki issue lb
Container mtusi-lab7-pki-run-eeae88882775 Creating
Container mtusi-lab7-pki-run-eeae88882775 Created
lb: issued serial 1D3D845E1AF594ABD70BC068EA871439966B52E4 (valid until 2026-12-07 21:04 UTC), previous serial 4880A64F68E8FD2A8B19E8482491A66EE8DC86BC
docker compose kill -s USR2 lb
Container mtusi-lab7-lb-1 Killing
Container mtusi-lab7-lb-1 Killed
sleep 5
docker compose --profile tools run --rm pki revoke-previous lb
Container mtusi-lab7-pki-run-2793ec0da54c Creating
Container mtusi-lab7-pki-run-2793ec0da54c Created
revoked lb serial 4880A64F68E8FD2A8B19E8482491A66EE8DC86BC; CRL now lists 1 serials
api-2 | {"timestamp": "2026-11-07T21:04:58.024+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "tls.crl_loaded", "logger": "messenger.tls", "message": "CRL обновлён: отозвано 1 сертификатов"}
api-1 | {"timestamp": "2026-11-07T21:05:00.832+00:00", "severity": "WARNING", "service.name": "messenger-api", "event": "tls.crl_loaded", "logger": "messenger.tls", "message": "CRL обновлён: отозвано 1 сертификатов"}
PASS: lab7 public API scenario; infrastructure and grading evidence remain separate.
+2
View File
@@ -0,0 +1,2 @@
python tests/security.py --base-url "https://127.0.0.1:8443" --ca-file "secrets/tls/ca/ca.crt"
PASS: trusted HTTPS works; untrusted CA rejected. This does NOT verify internal mTLS, OpenBao or hardening.
+110
View File
@@ -0,0 +1,110 @@
python -m unittest discover -s student-tests -p "test_*.py" -v
test_auth_checked_before_access_and_body (test_api.MessengerApiTest.test_auth_checked_before_access_and_body) ... ok
test_bad_cursor_returns_400 (test_api.MessengerApiTest.test_bad_cursor_returns_400) ... ok
test_chat_list_pagination (test_api.MessengerApiTest.test_chat_list_pagination) ... ok
test_chat_membership_rules (test_api.MessengerApiTest.test_chat_membership_rules) ... ok
test_duplicate_username_returns_409 (test_api.MessengerApiTest.test_duplicate_username_returns_409) ... ok
test_empty_blank_and_too_long_messages_return_400 (test_api.MessengerApiTest.test_empty_blank_and_too_long_messages_return_400) ... ok
test_malformed_json_returns_400 (test_api.MessengerApiTest.test_malformed_json_returns_400) ... ok
test_nul_character_is_stored (test_api.MessengerApiTest.test_nul_character_is_stored) ... ok
test_outsider_gets_404_for_foreign_chat (test_api.MessengerApiTest.test_outsider_gets_404_for_foreign_chat) ... ok
test_pagination_walks_several_pages (test_api.MessengerApiTest.test_pagination_walks_several_pages) ... ok
test_unicode_roundtrip (test_api.MessengerApiTest.test_unicode_roundtrip) ... ok
test_wrong_types_and_extra_fields_return_400 (test_api.MessengerApiTest.test_wrong_types_and_extra_fields_return_400) ... ok
test_attachment_rules_without_500 (test_attachments.AttachmentTest.test_attachment_rules_without_500) ... ok
test_broken_scan_becomes_failed_and_cannot_be_attached (test_attachments.AttachmentTest.test_broken_scan_becomes_failed_and_cannot_be_attached) ... ok
test_corrupted_images_are_415 (test_attachments.AttachmentTest.test_corrupted_images_are_415) ... ok
test_dangerous_filenames_are_400 (test_attachments.AttachmentTest.test_dangerous_filenames_are_400) ... ok
test_exact_limits (test_attachments.AttachmentTest.test_exact_limits) ... ok
test_idempotency_with_attachments (test_attachments.AttachmentTest.test_idempotency_with_attachments) ... ok
test_large_real_image_within_limits_is_accepted (test_attachments.AttachmentTest.test_large_real_image_within_limits_is_accepted) ... ok
test_message_with_attachments (test_attachments.AttachmentTest.test_message_with_attachments) ... ok
test_mime_spoofing_is_415 (test_attachments.AttachmentTest.test_mime_spoofing_is_415) ... ok
test_outsider_and_anonymous_cannot_upload (test_attachments.AttachmentTest.test_outsider_and_anonymous_cannot_upload) ... ok
test_pixel_bomb_is_413 (test_attachments.AttachmentTest.test_pixel_bomb_is_413) ... ok
test_png_and_jpeg_roundtrip_for_member (test_attachments.AttachmentTest.test_png_and_jpeg_roundtrip_for_member) ... ok
test_structurally_broken_jpeg_is_415 (test_attachments.AttachmentTest.test_structurally_broken_jpeg_is_415) ... ok
test_too_large_is_413_before_reading (test_attachments.AttachmentTest.test_too_large_is_413_before_reading) ... ok
test_too_large_stream_is_413 (test_attachments.AttachmentTest.test_too_large_stream_is_413) ... ok
test_valid_jpeg_variants_are_accepted (test_attachments.AttachmentTest.test_valid_jpeg_variants_are_accepted) ... ok
test_variants_and_bad_ids (test_attachments.AttachmentTest.test_variants_and_bad_ids) ... ok
test_variants_follow_the_contract (test_attachments.AttachmentTest.test_variants_follow_the_contract) ... ok
test_bearer_required_on_business_endpoints (test_auth.AuthTest.test_bearer_required_on_business_endpoints) ... ok
test_login_returns_opaque_token_with_expiry (test_auth.AuthTest.test_login_returns_opaque_token_with_expiry) ... ok
test_logout_revokes_only_current_session (test_auth.AuthTest.test_logout_revokes_only_current_session) ... ok
test_malformed_basic_returns_401 (test_auth.AuthTest.test_malformed_basic_returns_401) ... ok
test_password_length_rules (test_auth.AuthTest.test_password_length_rules) ... ok
test_password_with_colon_and_unicode (test_auth.AuthTest.test_password_with_colon_and_unicode) ... ok
test_relogin_after_logout (test_auth.AuthTest.test_relogin_after_logout) ... ok
test_user_never_contains_password (test_auth.AuthTest.test_user_never_contains_password) ... ok
test_wrong_password_and_unknown_user_look_the_same (test_auth.AuthTest.test_wrong_password_and_unknown_user_look_the_same) ... ok
test_x_user_id_does_not_change_identity (test_auth.AuthTest.test_x_user_id_does_not_change_identity) ... ok
test_instance_id_on_errors_and_health (test_balancing.BalancingTest.test_instance_id_on_errors_and_health) ... ok
test_logout_applies_on_every_replica (test_balancing.BalancingTest.test_logout_applies_on_every_replica) ... ok
test_one_session_is_served_by_every_replica (test_balancing.BalancingTest.test_one_session_is_served_by_every_replica) ... ok
test_session_cache_is_shared_between_replicas (test_balancing.BalancingTest.test_session_cache_is_shared_between_replicas) ... ok
test_write_on_one_replica_read_on_another (test_balancing.BalancingTest.test_write_on_one_replica_read_on_another) ... ok
test_failed_request_does_not_burn_key (test_idempotency.IdempotencyTest.test_failed_request_does_not_burn_key) ... ok
test_json_formatting_does_not_matter (test_idempotency.IdempotencyTest.test_json_formatting_does_not_matter) ... ok
test_key_is_required_and_validated (test_idempotency.IdempotencyTest.test_key_is_required_and_validated) ... ok
test_key_scope_is_user_and_chat (test_idempotency.IdempotencyTest.test_key_scope_is_user_and_chat) ... ok
test_parallel_different_bodies_same_key (test_idempotency.IdempotencyTest.test_parallel_different_bodies_same_key) ... ok
test_parallel_same_key_through_replicas_creates_one_message (test_idempotency.IdempotencyTest.test_parallel_same_key_through_replicas_creates_one_message) ... ok
test_replay_rechecks_session_and_access (test_idempotency.IdempotencyTest.test_replay_rechecks_session_and_access) ... ok
test_replay_through_another_replica_returns_same_message (test_idempotency.IdempotencyTest.test_replay_through_another_replica_returns_same_message) ... ok
test_same_key_other_body_is_409 (test_idempotency.IdempotencyTest.test_same_key_other_body_is_409) ... ok
test_big_body_rejected_before_authentication (test_limits.LimitsTest.test_big_body_rejected_before_authentication) ... ok
test_body_over_limit_chunked_is_413 (test_limits.LimitsTest.test_body_over_limit_chunked_is_413) ... ok
test_body_over_limit_with_content_length_is_413 (test_limits.LimitsTest.test_body_over_limit_with_content_length_is_413) ... ok
test_body_under_limit_is_accepted (test_limits.LimitsTest.test_body_under_limit_is_accepted) ... ok
test_limit_is_per_username (test_limits.LimitsTest.test_limit_is_per_username) ... ok
test_login_failures_lead_to_429_with_retry_after_across_replicas (test_limits.LimitsTest.test_login_failures_lead_to_429_with_retry_after_across_replicas) ... ok
test_old_hash_is_rehashed_on_login (test_limits.LimitsTest.test_old_hash_is_rehashed_on_login) ... ok
test_success_resets_failure_counter (test_limits.LimitsTest.test_success_resets_failure_counter) ... ok
test_wrong_password_does_not_rehash (test_limits.LimitsTest.test_wrong_password_does_not_rehash) ... ok
----------------------------------------------------------------------
Ran 63 tests in 55.072s
OK
10 485 760 байт и 6400×6250 = 40 000 000 px: 202 -> ready; на 1 байт/пиксель больше: 413
fixture 320×200 -> thumbnail 256×160 JPEG, crop 128×128 JPEG, optimized 320×200 WebP; 48×32 -> {'thumbnail': (48, 32), 'crop': (128, 128), 'optimized': (48, 32)}
X-Instance-Id есть в health, 404, 401 и 400
logout через одну реплику -> 401 на ['r-4265d3e11ef7', 'r-d2dbb84b8d7b']
20 x GET /users/me с одним токеном -> реплики {'r-d2dbb84b8d7b': 10, 'r-4265d3e11ef7': 10}; это alias запущенных реплик api (с lab7 — случайные, не hostname), повторный вход не нужен
10 x GET /users/me через реплики {'r-d2dbb84b8d7b': 5, 'r-4265d3e11ef7': 5}: попаданий в кэш +20, промахов +0 — кэш общий
сообщение записала реплика r-d2dbb84b8d7b, сразу прочитали ['r-4265d3e11ef7', 'r-d2dbb84b8d7b']
с тем же ключом: сначала 400 (пустой текст), потом 201 — ошибка ключ не заняла
тот же JSON с другими пробелами и переносами -> тот же 201 и то же сообщение
нет ключа, пустой, 129 символов, пробел, '/', кириллица -> 400; 128 символов и ._:- -> 201
тот же ключ у другого пользователя и в другом чате -> независимые сообщения
10 одновременных разных тел с одним ключом: 201 x1, 409 x9, в истории 1 сообщение
20 одновременных POST с одним ключом через реплики {'r-4265d3e11ef7': 10, 'r-d2dbb84b8d7b': 10}: все 201 с одним id, в истории 1 сообщение
повтор: посторонний -> 404, после logout -> 401, после нового входа -> то же сообщение
1 запрос + 4 повтора через реплики ['r-4265d3e11ef7', 'r-d2dbb84b8d7b']: 201 и то же сообщение, в истории 1
другой текст с тем же ключом -> 409 conflict, второе сообщение не создано
POST /users, chunked 66643 bytes without Content-Length -> 413 payload_too_large
POST /users, Content-Length 66643 -> 413 payload_too_large
10 wrong passwords -> 401, served by 2 of 2 replicas
next login (even with the right password) -> 429 rate_limited, Retry-After: 298 s
stored hash params: m=8192,t=1,p=1 -> after login m=19456,t=2,p=1
+2
View File
@@ -0,0 +1,2 @@
python tests/smoke.py --base-url "https://127.0.0.1:8443" --ca-file "secrets/tls/ca/ca.crt"
PASS: lab7 public API scenario; infrastructure and grading evidence remain separate.
+146
View File
@@ -0,0 +1,146 @@
docker compose --profile tools run --rm sectest student-tests/tls_matrix.py
Container mtusi-lab7-sectest-run-304d2fb36af0 Creating
Container mtusi-lab7-sectest-run-304d2fb36af0 Created
TLS matrix (lab7): who may connect where
========================================
## 1. client -> lb:8443 (external TLS; client verifies server identity lb)
OK client our CA, hostname lb, GET /health/ready expect 200 got TLSv1.3 HTTP 200
OK client empty trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK client foreign CA trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK client wrong hostname (not lb) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK client plaintext HTTP on :8443 expect refuse got plaintext: closed by server
## 2. lb -> api:8080 (mTLS; replica allows ONLY identity lb, CRL checked)
OK dns api replicas expect >=1 got 172.19.0.7, 172.19.0.8
OK lb -> api@172.19.0.7 GET /health/ready expect 200 got TLSv1.3 HTTP 200
OK lb -> api@172.19.0.7 expecting name lb expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'lb'.
OK no client cert -> api@172.19.0.7 expect refuse got TLSv1.3 ok, then closed by server
OK rogue-lb -> api@172.19.0.7 expect refuse got TLSv1.3 ok, then closed by server
OK lb-expired -> api@172.19.0.7 expect refuse got TLSv1.3 ok, then closed by server
OK intruder -> api@172.19.0.7 expect refuse got TLSv1.3 ok, then closed by server
OK worker -> api@172.19.0.7 expect refuse got TLSv1.3 ok, then closed by server
OK api -> api@172.19.0.7 expect refuse got TLSv1.3 ok, then closed by server
OK grafana -> api@172.19.0.7 expect refuse got TLSv1.3 ok, then closed by server
OK otel-collector -> api@172.19.0.7 expect refuse got TLSv1.3 ok, then closed by server
OK lb -> api@172.19.0.8 GET /health/ready expect 200 got TLSv1.3 HTTP 200
OK lb -> api@172.19.0.8 expecting name lb expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'lb'.
OK no client cert -> api@172.19.0.8 expect refuse got TLSv1.3 ok, then closed by server
OK rogue-lb -> api@172.19.0.8 expect refuse got TLSv1.3 ok, then closed by server
OK lb-expired -> api@172.19.0.8 expect refuse got TLSv1.3 ok, then closed by server
OK intruder -> api@172.19.0.8 expect refuse got TLSv1.3 ok, then closed by server
OK worker -> api@172.19.0.8 expect refuse got TLSv1.3 ok, then closed by server
OK api -> api@172.19.0.8 expect refuse got TLSv1.3 ok, then closed by server
OK grafana -> api@172.19.0.8 expect refuse got TLSv1.3 ok, then closed by server
OK otel-collector -> api@172.19.0.8 expect refuse got TLSv1.3 ok, then closed by server
## 3. api/worker -> otel-collector:4318 (mTLS gateway otlp-gw; allowlist CN api, worker)
OK api -> otel-collector POST /v1/metrics expect 200 got TLSv1.3 HTTP 200
OK worker -> otel-collector POST /v1/metrics expect 200 got TLSv1.3 HTTP 200
OK api empty trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK api foreign CA trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK api wrong hostname (not otel-collector) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK no client cert -> otel-collector expect refuse got server alert: TLSV13_ALERT_CERTIFICATE_REQUIRED
OK rogue-lb -> otel-collector expect refuse got server alert: TLSV1_ALERT_UNKNOWN_CA
OK lb-expired -> otel-collector expect refuse got server alert: SSLV3_ALERT_CERTIFICATE_EXPIRED
OK intruder -> otel-collector expect refuse got TLSv1.3 HTTP 403
OK lb -> otel-collector expect refuse got TLSv1.3 HTTP 403
OK grafana -> otel-collector expect refuse got TLSv1.3 HTTP 403
OK prometheus -> otel-collector expect refuse got TLSv1.3 HTTP 403
OK any bypass gateway: otel-collector:14318 expect closed got port 14318 closed
## 4. otel-collector / grafana -> prometheus, loki, tempo (mTLS)
OK otel-collector -> prometheus:9090 GET /-/ready expect 200 got TLSv1.3 HTTP 200
OK grafana -> prometheus:9090 GET /-/ready expect 200 got TLSv1.3 HTTP 200
OK otel-collector empty trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK otel-collector foreign CA trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK otel-collector wrong hostname (not prometheus) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK no client cert -> prometheus:9090 expect refuse got server alert: TLSV13_ALERT_CERTIFICATE_REQUIRED
OK rogue-lb -> prometheus:9090 expect refuse got server alert: TLSV1_ALERT_UNKNOWN_CA
OK lb-expired -> prometheus:9090 expect refuse got server alert: SSLV3_ALERT_CERTIFICATE_EXPIRED
OK intruder -> prometheus:9090 expect refuse got server alert: SSLV3_ALERT_BAD_CERTIFICATE
OK api -> prometheus:9090 expect refuse got server alert: SSLV3_ALERT_BAD_CERTIFICATE
OK lb -> prometheus:9090 expect refuse got server alert: SSLV3_ALERT_BAD_CERTIFICATE
OK otel-collector -> loki:3100 GET /loki/api/v1/status/buildinfo expect 200 got TLSv1.3 HTTP 200
OK grafana -> loki:3100 GET /loki/api/v1/status/buildinfo expect 200 got TLSv1.3 HTTP 200
OK otel-collector empty trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK otel-collector foreign CA trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK otel-collector wrong hostname (not loki) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK no client cert -> loki:3100 expect refuse got server alert: TLSV13_ALERT_CERTIFICATE_REQUIRED
OK rogue-lb -> loki:3100 expect refuse got server alert: TLSV1_ALERT_UNKNOWN_CA
OK lb-expired -> loki:3100 expect refuse got server alert: SSLV3_ALERT_CERTIFICATE_EXPIRED
OK intruder -> loki:3100 expect refuse got TLSv1.3 HTTP 403
OK api -> loki:3100 expect refuse got TLSv1.3 HTTP 403
OK lb -> loki:3100 expect refuse got TLSv1.3 HTTP 403
OK grafana -> tempo:3200 GET /api/status/buildinfo expect 200 got TLSv1.3 HTTP 200
OK grafana empty trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK grafana foreign CA trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK grafana wrong hostname (not tempo) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK no client cert -> tempo:3200 expect refuse got server alert: TLSV13_ALERT_CERTIFICATE_REQUIRED
OK rogue-lb -> tempo:3200 expect refuse got server alert: TLSV1_ALERT_UNKNOWN_CA
OK lb-expired -> tempo:3200 expect refuse got server alert: SSLV3_ALERT_CERTIFICATE_EXPIRED
OK intruder -> tempo:3200 expect refuse got TLSv1.3 HTTP 403
OK api -> tempo:3200 expect refuse got TLSv1.3 HTTP 403
OK lb -> tempo:3200 expect refuse got TLSv1.3 HTTP 403
OK otel-collector -> tempo:3200 expect refuse got TLSv1.3 HTTP 403
OK otel-collector -> tempo:4318 POST /v1/traces expect 200 got TLSv1.3 HTTP 200
OK no client cert -> tempo:4318 expect refuse got server alert: TLSV13_ALERT_CERTIFICATE_REQUIRED
OK rogue-lb -> tempo:4318 expect refuse got server alert: TLSV1_ALERT_UNKNOWN_CA
OK lb-expired -> tempo:4318 expect refuse got server alert: SSLV3_ALERT_CERTIFICATE_EXPIRED
OK intruder -> tempo:4318 expect refuse got TLSv1.3 HTTP 403
OK api -> tempo:4318 expect refuse got TLSv1.3 HTTP 403
OK lb -> tempo:4318 expect refuse got TLSv1.3 HTTP 403
OK grafana -> tempo:4318 expect refuse got TLSv1.3 HTTP 403
## 5. api/worker -> openbao:8200 (TLS + cert auth: role accepts only CN api / worker)
OK api -> openbao GET /v1/sys/health expect 200 got TLSv1.3 HTTP 200
OK api empty trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK api foreign CA trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK api wrong hostname (not openbao) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK no client cert -> openbao login role messenger-api expect refuse got login HTTP 400: client certificate must be supplied
OK rogue-lb -> openbao login role messenger-api expect refuse got login HTTP 400: invalid certificate or no client certificate supplied; addit
OK lb-expired -> openbao login role messenger-api expect refuse got login HTTP 500: failed to verify client's certificate: x509: certificate has
OK intruder -> openbao login role messenger-api expect refuse got login HTTP 400: no chain matching all constraints could be found for this lo
OK lb -> openbao login role messenger-worker expect refuse got login HTTP 400: no chain matching all constraints could be found for this lo
OK worker -> openbao login role messenger-api expect refuse got login HTTP 400: no chain matching all constraints could be found for this lo
OK api -> openbao login role messenger-api expect 200 got login HTTP 200
OK worker -> openbao login role messenger-worker expect 200 got login HTTP 200
## 6. api/worker -> broker:5671 (mTLS + SASL EXTERNAL: user = certificate CN)
OK api -> broker login expect allow got SASL EXTERNAL login ok
OK worker -> broker login expect allow got SASL EXTERNAL login ok
OK api empty trust store -> server cert expect verify-err got client rejected server cert: self-signed certificate in certificate chain
OK api foreign CA trust store -> server cert expect verify-err got client rejected server cert: self-signed certificate in certificate chain
OK api wrong hostname (not broker) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK no client cert -> broker (TLS) expect refuse got server alert: TLSV13_ALERT_CERTIFICATE_REQUIRED
OK rogue-lb -> broker (TLS) expect refuse got server alert: TLSV1_ALERT_UNKNOWN_CA
OK lb-expired -> broker (TLS) expect refuse got server alert: SSLV3_ALERT_CERTIFICATE_EXPIRED
OK intruder -> broker login expect refuse got login refused: ProbableAuthenticationError
OK lb -> broker login expect refuse got login refused: ProbableAuthenticationError
OK grafana -> broker login expect refuse got login refused: ProbableAuthenticationError
OK any plaintext AMQP broker:5672 expect closed got 5672 closed
## 7. api/worker -> postgres:5432 (TLS verify-full, hostssl only, SCRAM)
OK api -> postgres as messenger_api (verify-full) expect allow got connected, TLSv1.3
OK worker -> postgres as messenger_worker (verify-full) expect allow got connected, TLSv1.3
OK api -> postgres without TLS (right password) expect refuse got pg_hba: no encryption -> reject
OK api -> postgres, foreign CA trust store expect verify-err got server cert verify failed
OK api -> postgres by IP 172.19.0.4 (name != SAN) expect verify-err got hostname mismatch
## 8. api -> valkey:6379 (TLS; identity = ACL user, checked in acl_matrix.py)
OK api -> valkey TLS, PING without AUTH expect NOAUTH got TLSv1.3 ok, server answered
OK api empty trust store -> server cert expect verify-err got client rejected server cert: self-signed certificate in certificate chain
OK api foreign CA trust store -> server cert expect verify-err got client rejected server cert: self-signed certificate in certificate chain
OK api wrong hostname (not valkey) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK api -> valkey plaintext PING expect refuse got plaintext: ConnectionResetError: [Errno 104] Connection reset by peer
## 9. api/worker -> s3:9000 (HTTPS; identity = S3 keys, checked in acl_matrix.py)
OK api -> s3 GET /healthz expect 200 got TLSv1.3 HTTP 200
OK api empty trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK api foreign CA trust store -> server cert expect verify-err got client rejected server cert: unable to get local issuer certificate
OK api wrong hostname (not s3) expect verify-err got client rejected server cert: Hostname mismatch, certificate is not valid for 'wrong-name.invalid'.
OK api -> s3 plaintext HTTP expect refuse got plaintext: HTTP/1.0 400 Bad Request
## 10. replication / cluster channels: N/A (single node PostgreSQL, Valkey, broker, OpenBao)
PASS: 119 checks
File diff suppressed because it is too large Load Diff
@@ -0,0 +1,15 @@
# Dashboard'ы импортируются из файлов infra/grafana/dashboards/*.json (смонтированы в контейнер).
# allowUiUpdates: false — источник истины файл в Git; правки в интерфейсе не сохраняются в него.
apiVersion: 1
providers:
- name: messenger
orgId: 1
folder: Messenger
type: file
disableDeletion: true
allowUiUpdates: false
updateIntervalSeconds: 30
options:
path: /var/lib/grafana/dashboards
foldersFromFilesStructure: false
@@ -0,0 +1,87 @@
# Источники данных Grafana (импортируются при старте, в интерфейсе их нельзя изменить — readOnly).
# Grafana сама ничего не хранит: она отправляет запросы в три хранилища.
# Внутри: «$$» — это буквальный «$» (Grafana подставляет переменные окружения в $NAME).
#
# С lab7 все три источника — HTTPS с mTLS: Grafana проверяет сертификат хранилища нашим CA и имя
# сервера (serverName) и предъявляет свой сертификат identity grafana. Сертификаты и ключ читаются
# из файлов при старте ($__file{...}) — в Git и в базе Grafana их значений нет.
apiVersion: 1
datasources:
- name: Prometheus
uid: prometheus
type: prometheus
access: proxy
url: https://prometheus:9090
isDefault: true
editable: false
secureJsonData:
tlsCACert: $__file{/run/ca/ca.crt}
tlsClientCert: $__file{/run/tls/tls.crt}
tlsClientKey: $__file{/run/tls/tls.key}
jsonData:
tlsAuth: true
tlsAuthWithCACert: true
serverName: prometheus
httpMethod: POST
prometheusType: Prometheus
timeInterval: 15s
- name: Loki
uid: loki
type: loki
access: proxy
url: https://loki:3100
editable: false
secureJsonData:
tlsCACert: $__file{/run/ca/ca.crt}
tlsClientCert: $__file{/run/tls/tls.crt}
tlsClientKey: $__file{/run/tls/tls.key}
jsonData:
tlsAuth: true
tlsAuthWithCACert: true
serverName: loki
maxLines: 1000
# Из записи лога — переход к трассе: trace_id хранится в structured metadata записи.
derivedFields:
- name: trace_id
matcherType: label
matcherRegex: trace_id
datasourceUid: tempo
url: "$${__value.raw}"
urlDisplayLabel: "Открыть трассу"
- name: Tempo
uid: tempo
type: tempo
access: proxy
url: https://tempo:3200
editable: false
secureJsonData:
tlsCACert: $__file{/run/ca/ca.crt}
tlsClientCert: $__file{/run/tls/tls.crt}
tlsClientKey: $__file{/run/tls/tls.key}
jsonData:
tlsAuth: true
tlsAuthWithCACert: true
serverName: tempo
nodeGraph:
enabled: true
search:
hide: false
# Из span — переход к логам этой трассы в Loki (по trace_id, ±5 минут от span).
tracesToLogsV2:
datasourceUid: loki
spanStartTimeShift: "-5m"
spanEndTimeShift: "5m"
filterByTraceID: false
customQuery: true
query: '{service_name=~"messenger-api|messenger-worker"} | trace_id="$${__trace.traceId}"'
# Из span — к метрикам того же сервиса в Prometheus.
tracesToMetrics:
datasourceUid: prometheus
spanStartTimeShift: "-5m"
spanEndTimeShift: "5m"
queries:
- name: "RPS сервиса"
query: 'sum(rate(http_server_request_duration_seconds_count{job="messenger-api"}[1m]))'
+118
View File
@@ -0,0 +1,118 @@
# HAProxy — балансировщик и единственная точка входа стенда lab7.
# Клиент -> HTTPS 127.0.0.1:8443 (TLS, сертификат identity lb, SAN localhost/127.0.0.1)
# -> HAProxy -> mTLS -> одна из реплик api (порт 8080 внутри внутренней сети edge).
# Данные и сессии общие (PostgreSQL, Valkey), поэтому любой запрос может обслужить любая
# реплика: балансировка round robin, без привязки клиента к реплике (без sticky session).
#
# С lab7:
# - снаружи только TLS 1.2+ (bind ... ssl); открытого HTTP-порта нет;
# - к репликам — mTLS: HAProxy предъявляет клиентский сертификат lb (/run/tls/tls.pem) и проверяет
# сертификат реплики нашим CA И имя api (verifyhost api). Реплика сама проверяет, что клиент — lb
# (src/messenger/tlsserver.py). Проверки готовности (check) идут по тому же mTLS;
# - лимит размера запроса: больше 10 МиБ + запас на заголовки -> 413 до передачи в API;
# - X-Forwarded-For перезаписывается (а не дополняется): по нему API считает лимит частоты входа;
# - stats и метрики (8404) — тоже по TLS; healthcheck контейнера — 127.0.0.1:8405 внутри контейнера.
global
log stdout format raw local0 info
maxconn 2000
# При остановке контейнера (SIGUSR1, мягкая остановка) доделать начатые запросы, но не дольше 10 с.
hard-stop-after 10s
ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets
ssl-default-server-options ssl-min-ver TLSv1.2 no-tls-tickets
# Сертификаты и ключи читаются при старте и при reload (docker compose kill -s USR2 lb):
# ротация leaf-сертификата lb без пересборки образа и без остановки балансировщика.
# Список реплик берётся из DNS Docker: имя сервиса "api" -> IP всех ЗАПУЩЕННЫХ реплик.
# Остановили реплику или добавили новую — HAProxy увидит это сам, без перезапуска.
resolvers docker
nameserver dns 127.0.0.11:53
resolve_retries 3
timeout resolve 1s
timeout retry 1s
hold valid 2s # перечитывать список реплик раз в 2 с
hold obsolete 2s # IP, пропавший из DNS (контейнер остановлен), убрать через 2 с
hold nx 2s
hold other 2s
hold refused 2s
hold timeout 2s
accepted_payload_size 8192
defaults
mode http
log global
option httplog
option dontlog-normal # в лог только ошибки и смены состояния реплик, а не каждый запрос
timeout connect 1s # сеть внутри Docker быстрая: мёртвый адрес не держит запрос дольше 1 с
timeout client 30s
timeout server 30s # дольше самого долгого ответа API: загрузка файла (очередь проверки до 10 с + S3 до 6 с)
timeout http-request 10s # медленные заголовки (slowloris) — не дольше 10 с
timeout http-keep-alive 5s
timeout queue 5s
timeout check 1s
# Ошибка СОЕДИНЕНИЯ (запрос ещё не отправлен) — повторить, причём на другой реплике.
# Это безопасно для любого метода. Запрос, который уже ушёл в API, HAProxy сам НЕ повторяет:
# POST сообщения повторяет клиент с тем же Idempotency-Key.
retries 2
option redispatch 1
# Ошибки, которые создаёт сам балансировщик, отдаются в формате ошибки из контракта с X-Request-Id.
# X-Instance-Id у них нет: ни одна реплика API этот ответ не создавала.
unique-id-format %[uuid]
http-error status 503 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Нет готовой реплики API, повторите запрос позже","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
http-error status 502 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Реплика API оборвала соединение, повторите запрос","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
http-error status 504 content-type application/json lf-string '{"error":{"code":"unavailable","message":"Реплика API не ответила вовремя, повторите запрос","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
http-error status 413 content-type application/json lf-string '{"error":{"code":"payload_too_large","message":"Запрос слишком большой","request_id":"%[unique-id]"}}' hdr X-Request-Id "%[unique-id]"
frontend api_in
bind :8443 ssl crt /run/tls/tls.pem alpn http/1.1
# 10 МиБ файла (MAX_UPLOAD_BYTES) + 64 КиБ запаса. Без Content-Length (chunked) тело считает API.
http-request deny deny_status 413 if { req.hdr_val(content-length) gt 10551296 }
http-request set-header X-Forwarded-For %[src]
http-request set-header X-Forwarded-Proto https
http-response set-header Strict-Transport-Security "max-age=31536000"
default_backend api
backend api
balance roundrobin
# Проверка готовности: /health/ready = процесс отвечает, PostgreSQL и S3 доступны, нет SIGTERM.
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api
http-check expect status 200
# mTLS к каждой реплике (и для запросов, и для check):
# crt — клиентский сертификат identity lb (его проверяет реплика);
# ca-file — только наш CA; verify required — без проверки сертификата реплики не соединяемся;
# verifyhost — сертификат реплики обязан быть выдан на имя api (другая identity того же CA не подойдёт);
# sni — имя api в ClientHello.
default-server ssl verify required ca-file /run/ca/ca.crt crt /run/tls/tls.pem verifyhost api sni str(api) alpn http/1.1 check-ssl
# До 6 реплик (обычно 2, во время rolling update 3); пустые слоты стоят в MAINT.
# Проверка раз в 1 с, при смене состояния раз в 0,5 с; 2 неудачи подряд -> DOWN, 2 удачи -> UP.
server-template api 6 api:8080 check inter 1s fastinter 500ms downinter 2s fall 2 rise 2 observe layer4 error-limit 1 on-error mark-down resolvers docker resolve-prefer ipv4 init-addr none
# Второй вход только для проверки истечения сессии (make expiry): API с SESSION_TTL_SECONDS=2
# (сервис api-short-ttl, профиль ttl). Он тоже доступен только через балансировщик и только по TLS.
frontend ttl_in
bind :8444 ssl crt /run/tls/tls.pem alpn http/1.1
http-request deny deny_status 413 if { req.hdr_val(content-length) gt 10551296 }
http-request set-header X-Forwarded-For %[src]
default_backend api_short_ttl
backend api_short_ttl
option httpchk
http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api
http-check expect status 200
default-server ssl verify required ca-file /run/ca/ca.crt crt /run/tls/tls.pem verifyhost api sni str(api) alpn http/1.1 check-ssl
server-template ttl 2 api-short-ttl:8080 check inter 1s fall 2 rise 2 resolvers docker resolve-prefer ipv4 init-addr none
# Статистика HAProxy: https://127.0.0.1:8404/stats (только на 127.0.0.1 хоста, только чтение),
# метрики /metrics для Prometheus (по TLS, он проверяет сертификат lb).
# /lb-health — healthcheck контейнера на 127.0.0.1:8405 (только внутри контейнера):
# 503, пока в backend api нет ни одной готовой реплики.
frontend stats
bind :8404 ssl crt /run/tls/tls.pem
bind 127.0.0.1:8405
monitor-uri /lb-health
monitor fail if { nbsrv(api) lt 1 }
http-request use-service prometheus-exporter if { path /metrics }
stats enable
stats uri /stats
stats refresh 2s
+75
View File
@@ -0,0 +1,75 @@
# Loki 3.5.8 стенда lab7 — хранилище ЛОГОВ (один процесс, данные на диске в volume lokidata).
#
# Логи приходят от Collector по OTLP (/otlp/v1/logs). Labels потока (индекс) — только ресурсные
# атрибуты с маленьким числом значений: service_name, service_instance_id, deployment_environment_name.
# Остальное (event, severity, trace_id, span_id, request_id, attachment_id…) хранится как structured
# metadata записи: по нему можно фильтровать (| trace_id="..."), но в индекс оно не попадает,
# поэтому ID не раздувают число потоков.
auth_enabled: false
# С lab7: Loki слушает ТОЛЬКО 127.0.0.1 общего с шлюзом tsdb-gw network namespace
# (network_mode: service:tsdb-gw). Снаружи к нему ходят через шлюз: mTLS нашим CA + allowlist identity
# otel-collector, grafana (infra/tsdb/gateway.cfg). Почему шлюз: у HTTP-сервера Loki есть проверка
# «сертификат нашего CA», но нет списка разрешённых identity. Этот hop не выходит из контейнера.
server:
http_listen_address: 127.0.0.1
http_listen_port: 13100
grpc_listen_address: 127.0.0.1
grpc_listen_port: 9096
log_level: warn
common:
instance_addr: 127.0.0.1
path_prefix: /loki
replication_factor: 1
ring:
kvstore:
store: inmemory
storage:
filesystem:
chunks_directory: /loki/chunks
rules_directory: /loki/rules
schema_config:
configs:
- from: "2024-01-01"
store: tsdb
object_store: filesystem
schema: v13
index:
prefix: index_
period: 24h
limits_config:
allow_structured_metadata: true # нужно для OTLP-логов (trace_id, span_id, event…)
retention_period: 168h # 7 дней
ingestion_rate_mb: 8
ingestion_burst_size_mb: 16
max_query_lookback: 168h
otlp_config:
resource_attributes:
ignore_defaults: true # только явный короткий список labels ниже
attributes_config:
- action: index_label
attributes: [service.name, service.instance.id, deployment.environment.name]
ingester:
# Журнал (WAL) в volume: принятые, но ещё не записанные в chunks логи переживают перезапуск Loki.
wal:
enabled: true
dir: /loki/wal
flush_on_shutdown: true # при остановке записать chunks на диск
compactor:
working_directory: /loki/compactor
retention_enabled: true
delete_request_store: filesystem
ruler:
storage:
type: local
local:
directory: /loki/rules
analytics:
reporting_enabled: false
+46 -4
View File
@@ -1,7 +1,49 @@
# OpenBao — реализовать конфигурацию и политики
# OpenBao стенда lab7
Добавьте non-dev конфигурацию listener/storage/TLS, API/worker policies, bootstrap и rotation scripts. Credentials и unseal material создаются локально; здесь нет готового root token или private key.
Не dev-mode: `bao.hcl` (persistent `file` storage в volume `baodata`, TLS listener, declarative audit device),
политики `policies/*.hcl`, операторский скрипт `scripts/bao.py` (только стандартная библиотека Python,
запускается в одноразовом контейнере `ops`). Значений секретов, root token и unseal shares в Git нет.
Решение должно показать реальную сервисную аутентификацию и получение нужного secret по ограниченной policy; просто работающий контейнер OpenBao не засчитывается. На 3 статический KV secret допустим. На 4 покажите expiry/renewal/rotation и allow/deny. Путь KV v2 data/metadata и ACL должен соответствовать фактическому mount; не копируйте широкое `path "*"` для приложения.
## Кто что хранит
Документируйте шаги оператора init/unseal и восстановление после restart. Скрипт не должен печатать tokens/shares или хранить их в Git. См. contracts/trust-matrix.md и REPORT.md.
| Материал | Где | Кто имеет доступ |
| --- | --- | --- |
| Unseal shares (3, порог 2) | `secrets/operator/unseal-key-1..3` (mode 600) | только оператор; в production — три разных человека |
| Root token | `secrets/operator/root-token` (mode 600) | только оператор, только для `make bao-*` |
| CA private key | `secrets/ca/ca.key` | только оператор (`make pki`) |
| Сертификат и ключ api / worker | `secrets/tls/api`, `secrets/tls/worker` | смонтированы только в свой контейнер |
| Пароли БД, ключи S3, пароль Valkey для приложения | KV v2 `secret/messenger/api`, `secret/messenger/worker` | только роль своей identity |
## Bootstrap (один раз, из чистого clone)
```sh
make secrets pki # пароли и сертификаты (secrets/, вне Git)
docker compose up -d --wait openbao # запустился sealed и не инициализирован
make bao-init # 3 shares, порог 2, root token -> secrets/operator/
make bao-unseal # 2 shares
make bao-bootstrap # kv-v2 secret/, auth/cert, политики, роли, секреты приложения
```
`make bao-bootstrap` идемпотентен: повтор обновляет политики и роли и не создаёт новую версию секрета,
если значение не изменилось.
## Как входит приложение
`POST /v1/auth/cert/login {"name": "messenger-api"}` по mTLS. Роль принимает только сертификат нашего CA
с CN `api` (`allowed_common_names`), выдаёт токен с политикой `messenger-api` на 15 минут
(продление до 1 часа, потом новый вход). Политика — `read` одного пути `secret/data/messenger/api`.
Постоянного токена, SecretID или root token в образе, `.env` и compose нет: первый секрет приложения —
его TLS-ключ, а его выдаёт и отзывает оператор (`make pki`, `make rotate-lb-cert` как пример ротации leaf).
## После рестарта OpenBao
OpenBao снова sealed. Работающие API и worker продолжают работать на секретах в памяти, новые не стартуют.
Оператор: `make bao-unseal` — данные (KV, политики, роли) на месте, сервисы входят заново сами.
## Ротация и отзыв
- `make rotate-db-secret` — новый пароль роли `messenger_api`: ALTER ROLE + новая версия KV, API подхватывает
за `BAO_REFRESH_SECONDS` и пересоздаёт пулы. Старый пароль перестаёт работать для новых входов.
- `make bao-revoke-tokens` — отзыв всех токенов cert auth: сервисы входят заново сертификатом.
- отзыв identity: удалить роль (`bao delete auth/cert/certs/messenger-api` из `ops`) или выпустить новый
сертификат и отозвать старый серийный номер (`make pki-revoke`).
+34
View File
@@ -0,0 +1,34 @@
# OpenBao 2.4.4 стенда lab7 — НЕ dev-mode.
#
# - storage "file": постоянное хранилище в volume baodata (/openbao/data). Всё, что там лежит,
# зашифровано ключом, который OpenBao держит только в памяти после unseal;
# - после КАЖДОГО запуска OpenBao запечатан (sealed): оператор вводит 2 из 3 unseal shares
# (make bao-unseal). Обычный рестарт API и worker unseal не требует;
# - listener: только TLS 1.2+, сертификат identity openbao (наш CA). Клиентские сертификаты
# запрашиваются (cert auth): по ним входят api и worker (auth/cert, роли messenger-api/-worker);
# - UI выключен, наружу порт не опубликован: оператор работает через контейнер ops (make bao-*);
# - audit device объявлен здесь (OpenBao 2.4 не разрешает включать его через API): каждый запрос
# пишется в /openbao/logs/audit.log, токены и значения секретов — только как HMAC.
# mlock в OpenBao 2.4 не используется (параметра disable_mlock больше нет), IPC_LOCK не нужен.
ui = false
log_level = "info"
api_addr = "https://openbao:8200"
storage "file" {
path = "/openbao/data"
}
listener "tcp" {
address = "0.0.0.0:8200"
tls_cert_file = "/run/tls/tls.crt"
tls_key_file = "/run/tls/tls.key"
tls_client_ca_file = "/run/ca/ca.crt"
tls_min_version = "tls12"
}
audit "file" "audit-file" {
description = "Журнал всех запросов (значения секретов и токены — HMAC)"
options {
file_path = "/openbao/logs/audit.log"
}
}
+6
View File
@@ -0,0 +1,6 @@
# Policy of the API replicas (cert auth role messenger-api, certificate CN=api).
# Only READ of its own KV v2 secret. No list, no metadata, no other paths, no sys/*.
# Token lookup-self / renew-self come from the built-in "default" policy.
path "secret/data/messenger/api" {
capabilities = ["read"]
}
@@ -0,0 +1,6 @@
# Policy of the worker (cert auth role messenger-worker, certificate CN=worker).
# Only READ of its own KV v2 secret: the worker never sees API credentials
# (Valkey password, API S3 keys, messenger_api DB password).
path "secret/data/messenger/worker" {
capabilities = ["read"]
}
+128
View File
@@ -0,0 +1,128 @@
# OpenTelemetry Collector (otelcol-contrib 0.140.1) стенда lab7.
#
# С lab7 приём и отправка защищены:
# - API и worker подключаются не к Collector напрямую, а к шлюзу otlp-gw (HAProxy, infra/otel/gateway.cfg)
# по mTLS: сертификат шлюза otel-collector (наш CA), клиент обязан предъявить сертификат нашего CA
# с identity api или worker — сертификат lb, grafana или intruder от того же CA получает 403.
# Collector делит с шлюзом сетевое пространство (network_mode: service:otlp-gw) и слушает
# ТОЛЬКО 127.0.0.1:14318 — закрытый локальный hop, из сети Docker к Collector в обход шлюза не попасть.
# Почему шлюз: у OTLP-приёмника Collector есть mTLS, но нет списка разрешённых identity.
# - к Prometheus, Loki и Tempo Collector подключается по mTLS со своим сертификатом otel-collector
# и проверяет их сертификаты нашим CA (имя сервера = имя в адресе).
#
# API и worker отправляют сюда по OTLP/HTTP три сигнала. Collector их не хранит:
# он принимает (receivers), обрабатывает (processors) и отправляет в хранилища (exporters):
# traces -> Tempo (OTLP/HTTP, https://tempo:4318)
# logs -> Loki (родной OTLP-приём Loki 3, https://loki:3100/otlp)
# metrics -> Prometheus (родной OTLP-приём Prometheus 3, https://prometheus:9090/api/v1/otlp)
#
# Ограничение памяти и буферов (уровень 4, «остановка telemetry-хранилища не ломает сообщения
# и не вызывает бесконечный рост RAM»):
# - memory_limiter первым в каждом pipeline: когда куча Go доходит до 400 МиБ (лимит контейнера
# 512 МиБ), Collector перестаёт принимать данные (клиенту — ошибка, SDK отбрасывает у себя), а не
# растёт дальше. Ограничивается именно куча: в RSS процесса ещё ~150 МиБ — сам бинарник contrib;
# - batch собирает данные пачками (меньше запросов к хранилищам);
# - у каждого exporter своя очередь в памяти: не больше QUEUE пачек; повторы с паузой 1…30 с,
# не дольше 5 минут, потом пачка отбрасывается. Переполненная очередь тоже отбрасывает новые пачки.
# Потери считаются собственными метриками Collector (otelcol_exporter_send_failed_*,
# otelcol_exporter_enqueue_failed_*, otelcol_exporter_queue_size), их собирает Prometheus.
# Приложение от Collector не зависит: SDK отправляет в фоне и при ошибке отбрасывает (telemetry.py).
extensions:
health_check:
endpoint: 127.0.0.1:13133
receivers:
otlp:
protocols:
http:
endpoint: 127.0.0.1:14318 # только локально: снаружи — через mTLS-шлюз otlp-gw
max_request_body_size: 8388608 # 8 МиБ на запрос: больше не принимаем
processors:
memory_limiter:
check_interval: 1s
limit_mib: 400
spike_limit_mib: 80
batch:
send_batch_size: 1024
send_batch_max_size: 2048
timeout: 2s
# Страховка от утечки чувствительных данных: даже если какая-то инструментация запишет
# query-строку, полный URL или заголовки авторизации — они удаляются до хранилищ.
attributes/scrub:
actions:
- {key: url.query, action: delete}
- {key: url.full, action: delete}
- {key: http.url, action: delete}
- {key: http.target, action: delete}
- {key: http.request.header.authorization, action: delete}
- {key: http.request.header.cookie, action: delete}
- {key: http.request.header.x-vault-token, action: delete}
- {key: db.connection_string, action: delete}
- {pattern: ^db\.query\.parameter\..*, action: delete}
exporters:
otlphttp/tempo:
endpoint: https://tempo:4318
tls: &tls
ca_file: /run/ca/ca.crt
cert_file: /run/tls/tls.crt
key_file: /run/tls/tls.key
min_version: "1.2"
compression: gzip
timeout: 10s
sending_queue: &queue
enabled: true
num_consumers: 2
queue_size: 200 # пачек; при batch до 2048 записей — ограниченный объём
retry_on_failure: &retry
enabled: true
initial_interval: 1s
max_interval: 30s
max_elapsed_time: 300s
otlphttp/loki:
endpoint: https://loki:3100/otlp
tls: *tls
compression: gzip
timeout: 10s
sending_queue: *queue
retry_on_failure: *retry
otlphttp/prometheus:
# Prometheus принимает OTLP-метрики по пути /api/v1/otlp/v1/metrics (флаг --web.enable-otlp-receiver).
metrics_endpoint: https://prometheus:9090/api/v1/otlp/v1/metrics
tls: *tls
compression: gzip
timeout: 10s
sending_queue: *queue
retry_on_failure: *retry
service:
extensions: [health_check]
pipelines:
traces:
receivers: [otlp]
processors: [memory_limiter, attributes/scrub, batch]
exporters: [otlphttp/tempo]
logs:
receivers: [otlp]
processors: [memory_limiter, attributes/scrub, batch]
exporters: [otlphttp/loki]
metrics:
receivers: [otlp]
processors: [memory_limiter, batch]
exporters: [otlphttp/prometheus]
telemetry:
logs:
level: info
# Собственные метрики Collector (принято/отправлено/отброшено, размер очередей) на :8888,
# их забирает Prometheus (scrape job otel-collector). Это канал только чтения счётчиков:
# через него нельзя записать телеметрию; виден только в сети telemetry (scrape-канал, REPORT.md).
metrics:
level: detailed
readers:
- pull:
exporter:
prometheus:
host: 0.0.0.0
port: 8888
+39
View File
@@ -0,0 +1,39 @@
# otlp-gw — mTLS-шлюз перед OpenTelemetry Collector (lab7).
#
# Слушает :4318 в сетях otlp и telemetry (DNS-имя otel-collector) с сертификатом identity otel-collector.
# Клиент обязан предъявить сертификат нашего CA (verify required) — без сертификата или с чужим CA
# рукопожатие не проходит. Затем проверяется identity: CN должен быть api или worker, иначе 403.
# Разрешённый запрос передаётся Collector на 127.0.0.1:14318 — общий с шлюзом network namespace
# (network_mode: service:otlp-gw), этот hop не выходит из контейнера.
# Заголовок X-Client-Identity (CN) передаётся Collector: шлюз ставит его сам, клиентский затирается.
global
log stdout format raw local0 info
maxconn 500
ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets
defaults
mode http
log global
option httplog
option dontlog-normal
timeout connect 2s
timeout client 30s
timeout server 30s
timeout http-request 10s
frontend otlp_in
bind :4318 ssl crt /run/tls/tls.pem ca-file /run/ca/ca.crt verify required
acl allowed_identity ssl_c_s_dn(CN) -m str api worker
http-request deny deny_status 403 unless allowed_identity
# OTLP-запросы маленькие (пачки SDK); больше 8 МиБ не принимаем (как max_request_body_size Collector).
http-request deny deny_status 413 if { req.hdr_val(content-length) gt 8388608 }
http-request set-header X-Client-Identity %[ssl_c_s_dn(CN)]
default_backend collector
backend collector
server local 127.0.0.1:14318
# Healthcheck контейнера: только 127.0.0.1 внутри общего network namespace.
frontend health
bind 127.0.0.1:8406
monitor-uri /healthz
+14
View File
@@ -0,0 +1,14 @@
#!/bin/sh
# lab7: роли приложения. Выполняется образом postgres ОДИН раз — при инициализации пустого volume.
# Пароли читаются из файлов-секретов (scripts/init-secrets.sh) и передаются psql переменными:
# в командной строке процессов и в логах их нет. Права ролям выдаёт миграция 007_roles.sql.
set -e # без -u: скрипт может выполняться через source внутри docker-entrypoint.sh
psql -v ON_ERROR_STOP=1 --username "$POSTGRES_USER" --dbname "$POSTGRES_DB" \
-v api_pw="$(cat /run/secrets/db_api_password)" \
-v worker_pw="$(cat /run/secrets/db_worker_password)" <<'SQL'
CREATE ROLE messenger_api LOGIN PASSWORD :'api_pw' CONNECTION LIMIT 60;
CREATE ROLE messenger_worker LOGIN PASSWORD :'worker_pw' CONNECTION LIMIT 20;
REVOKE ALL ON DATABASE messenger FROM PUBLIC;
GRANT CONNECT ON DATABASE messenger TO messenger_api, messenger_worker;
SQL
echo "10-roles.sh: roles messenger_api, messenger_worker created"
+11
View File
@@ -0,0 +1,11 @@
# lab7: кто и как может подключаться к PostgreSQL.
# Сеть: ТОЛЬКО TLS (hostssl) и только SCRAM-SHA-256. Любое подключение без TLS — reject.
# Сертификат сервера проверяет клиент (sslmode=verify-full, наш CA, имя postgres в SAN).
# Unix-socket внутри контейнера — для initdb, pg_isready и docker exec оператора (он уже root на хосте).
# TYPE DATABASE USER ADDRESS METHOD
local all all trust
hostssl messenger messenger_api all scram-sha-256
hostssl messenger messenger_worker all scram-sha-256
hostssl messenger messenger all scram-sha-256
host all all all reject
hostnossl all all all reject
+6
View File
@@ -0,0 +1,6 @@
# Клиент для promtool (healthcheck контейнера): сертификат identity prometheus, проверка сервера нашим CA.
tls_config:
ca_file: /run/ca/ca.crt
cert_file: /run/tls/tls.crt
key_file: /run/tls/tls.key
server_name: prometheus
+54
View File
@@ -0,0 +1,54 @@
# Prometheus 3.7.3 стенда lab7 — хранилище МЕТРИК.
#
# С lab7 весь HTTP Prometheus — только mTLS с allowlist identity (web.yml): otel-collector, grafana, prometheus.
#
# Метрики приложения приходят push-ом по OTLP от Collector (флаг --web.enable-otlp-receiver
# в compose.yaml). Имена переводятся в стиль Prometheus: точки -> «_», единица -> суффикс
# (http.server.request.duration [s] -> http_server_request_duration_seconds_bucket/_sum/_count),
# service.name -> label job, service.instance.id -> label instance.
# Сам Prometheus опрашивает (scrape) только собственные метрики Collector (:8888) и балансировщик
# (lb:8404/metrics — ответы клиентам, включая 503 самого HAProxy, когда нет готовой реплики).
# Здесь же вычисляются alert rules (rules/alerts.yml): состояние pending/firing/resolved видно
# на http://127.0.0.1:9090/alerts и в Grafana. Отправки наружу (Alertmanager) нет — не требуется.
global:
scrape_interval: 15s
evaluation_interval: 15s
rule_files:
- /etc/prometheus/rules/*.yml
scrape_configs:
# Собственные счётчики Collector: только чтение, внутренняя сеть telemetry (scrape-канал, см. REPORT.md).
- job_name: otel-collector
static_configs:
- targets: ["otel-collector:8888"]
# Балансировщик: по TLS, сертификат lb проверяется нашим CA и именем lb.
- job_name: haproxy
scheme: https
tls_config:
ca_file: /run/ca/ca.crt
server_name: lb
static_configs:
- targets: ["lb:8404"]
# Сам Prometheus: mTLS своим сертификатом (identity prometheus разрешена в web.yml).
- job_name: prometheus
scheme: https
tls_config:
ca_file: /run/ca/ca.crt
cert_file: /run/tls/tls.crt
key_file: /run/tls/tls.key
server_name: prometheus
static_configs:
- targets: ["127.0.0.1:9090"]
otlp:
# Ресурсные атрибуты, которые станут labels всех метрик (остальные — в серии target_info).
promote_resource_attributes:
- service.version
- deployment.environment.name
storage:
tsdb:
# Пачки OTLP от разных процессов приходят не строго по времени: принимаем опоздания до 30 мин.
out_of_order_time_window: 30m
+96
View File
@@ -0,0 +1,96 @@
# Alert rules стенда lab6 (вычисляет Prometheus раз в 15 с). Доставки наружу нет: состояние
# inactive -> pending -> firing -> (resolved) видно на http://127.0.0.1:9090/alerts, в Grafana
# (Alerting -> Alert rules, источник Prometheus) и через API /api/v1/alerts.
# Что делать при срабатывании — infra/prometheus/runbooks.md.
#
# SLI/SLO (окно — скользящий 1 час, учебный стенд; в эксплуатации было бы 28–30 дней):
# SLO-1 доступность API: >= 99% ответов клиентам (вход HAProxy, без /health) — не 5xx;
# SLO-2 задержка API: p95 бизнес-запросов (гистограмма приложения) < 0.5 с;
# SLO-3 обработка: 95% вложений готовы (ready) быстрее 30 с от принятия загрузки.
# Recording rules ниже считают эти SLI, dashboard показывает их рядом с целями.
groups:
- name: messenger-sli
interval: 15s
rules:
# Доля 5xx на входе: числитель — ответы 5xx клиентам (из приложения и от самого HAProxy),
# знаменатель — все ответы фронтенда api_in. Неверный пароль клиента (401) — не ошибка сервиса.
- record: messenger:edge_error_ratio:rate2m
expr: |
sum(rate(haproxy_frontend_http_responses_total{proxy="api_in",code="5xx"}[2m]))
/
sum(rate(haproxy_frontend_http_responses_total{proxy="api_in"}[2m]))
- record: messenger:edge_availability:ratio1h
expr: |
1 - (
sum(increase(haproxy_frontend_http_responses_total{proxy="api_in",code="5xx"}[1h]))
/
sum(increase(haproxy_frontend_http_responses_total{proxy="api_in"}[1h]))
)
# p95 по buckets ВСЕХ реплик (сумма по le), а не среднее p95 реплик.
- record: messenger:http_latency_p95:5m
expr: |
histogram_quantile(0.95,
sum by (le) (rate(http_server_request_duration_seconds_bucket{job="messenger-api"}[5m])))
- record: messenger:time_to_ready_under_30s:ratio1h
expr: |
sum(increase(messenger_attachment_time_to_ready_seconds_bucket{le=~"30(\\.0)?"}[1h]))
/
sum(increase(messenger_attachment_time_to_ready_seconds_count[1h]))
- name: messenger-alerts
rules:
- alert: HighErrorRate
# Больше 5% ответов клиентам — 5xx за последние 2 минуты, и это держится 1 минуту.
# При трафике меньше 0.2 запроса/с alert не считается: 1 ошибка из 3 запросов — не инцидент.
expr: |
messenger:edge_error_ratio:rate2m > 0.05
and on() sum(rate(haproxy_frontend_http_responses_total{proxy="api_in"}[2m])) > 0.2
for: 1m
labels:
severity: page
slo: availability
annotations:
summary: "Доля 5xx на входе API {{ $value | humanizePercentage }} (порог 5%)"
description: >-
Клиенты получают 5xx. Сравните панель «Ошибки: вход HAProxy и приложение»: если 5xx отдаёт
сам HAProxy (у приложения ошибок нет) — нет готовых реплик (обычно недоступна БД или S3);
если 5xx отдаёт приложение — ищите trace с ошибкой и лог по X-Request-Id.
runbook: infra/prometheus/runbooks.md#higherrorrate
- alert: QueueLagHigh
# Самое старое задание, которое уже можно обрабатывать, ждёт worker дольше 60 с, 1 минуту подряд.
# Это отставание очереди (lag), а не длительность обработки: worker не берёт задания.
expr: max by (queue) (messenger_queue_oldest_age_seconds{job="messenger-api"}) > 60
for: 1m
labels:
severity: page
slo: processing
annotations:
summary: "Задание ждёт обработки {{ $value | humanizeDuration }} (очередь {{ $labels.queue }})"
description: >-
Возраст старейшего задания растёт: worker не забирает задания. Проверьте панели
«Worker: занято/всего» и «Задания по исходу»: 0 доставок — worker остановлен или не
подключён к брокеру; заняты все слоты — не хватает мощности.
runbook: infra/prometheus/runbooks.md#queuelaghigh
- alert: TelemetryExportFailing
# Collector не может отправить данные в хранилище (Tempo, Loki или Prometheus): ошибки отправки
# или больше 20 пачек в очереди exporter, 1 минуту подряд.
# Бизнес-функции не затронуты, но часть телеметрии теряется после исчерпания повторов.
expr: |
sum by (exporter) (
rate(otelcol_exporter_send_failed_spans_total[2m])
or rate(otelcol_exporter_send_failed_log_records_total[2m])
or rate(otelcol_exporter_send_failed_metric_points_total[2m])
) > 0
or sum by (exporter) (otelcol_exporter_queue_size) > 20
for: 1m
labels:
severity: ticket
annotations:
summary: "Collector не может отправить телеметрию: {{ $labels.exporter }}"
description: >-
Хранилище телеметрии недоступно или перегружено. Очередь exporter ограничена
(200 пачек), после 5 минут повторов пачки отбрасываются — потери видны на панели Collector.
runbook: infra/prometheus/runbooks.md#telemetryexportfailing
+56
View File
@@ -0,0 +1,56 @@
# Runbooks alerts (lab6)
Alerts вычисляет Prometheus (`infra/prometheus/rules/alerts.yml`). Состояние: http://127.0.0.1:9090/alerts,
`make alerts`, панель «Alerts: pending / firing» в Grafana (http://127.0.0.1:3000, dashboard
«Messenger lab6»). Доставки наружу нет. Все шаги ниже — только по сохранённым наблюдениям.
## HighErrorRate
**Условие.** Доля ответов 5xx на входе HAProxy за 2 минуты > 5% и держится 1 минуту
(`messenger:edge_error_ratio:rate2m > 0.05`, трафик > 0.2 запроса/с). Это SLI доступности (SLO-1: ≥ 99% за час).
**Шаги.**
1. Панель «Ошибки: вход HAProxy и приложение».
- 5xx есть у приложения → ошибки отдаёт код API. Переходите к шагу 2.
- 5xx только на входе, у приложения запросов почти нет, «готовых реплик API» = 0 → HAProxy сам
отвечает 503: ни одна реплика не проходит `/health/ready`. Причина — PostgreSQL или S3.
Логи: `{service_name="messenger-api"} | event="http.request" | http_route="/health/ready"`.
2. Какой маршрут: панель «p95 по маршрутам» и «RPS по маршрутам».
3. Трасса ошибки: в Loki `{service_name="messenger-api"} | severity_text="WARNING" | event="http.request"`
→ запись с кодом 5xx → кнопка «Открыть трассу» (или по `request_id` из ответа клиента `X-Request-Id`).
4. В трассе сравните длительность server span и SQL-спанов:
- SQL-спан длинный (≈ 5 с, statement_timeout) со статусом ERROR → **медленная БД** (блокировка,
долгая транзакция, перегрузка). Пул соединений: растёт `used`/`ждут соединение`.
Проверка в БД: `make explain`, блокировки — `SELECT * FROM pg_locks WHERE NOT granted`.
- SQL-спаны короткие, а server span длинный → медленный **код обработчика**, БД ни при чём.
5. После устранения: ошибки на входе падают, alert переходит в resolved за 1–2 минуты (окно 2 минуты).
## QueueLagHigh
**Условие.** Самое старое задание, готовое к обработке, ждёт worker дольше 60 с, 1 минуту подряд
(`max(messenger_queue_oldest_age_seconds) > 60`). Это отставание очереди, а не длительность обработки.
**Шаги.**
1. Панель «Задания по исходу»: 0 доставок в секунду → worker не забирает задания.
«Насыщение worker»: если серия пропала — процесс worker не отправляет метрики (остановлен, упал).
Логи: `{service_name="messenger-worker"} | event=~"worker.stopped|worker.started|worker.broker_unavailable"`.
`make ps`: состояние контейнера worker.
2. Если worker работает, а насыщение 100% — не хватает мощности: `WORKER_REPLICAS=2 docker compose up -d worker`.
3. Если растёт «строка outbox ждёт брокер» — недоступен RabbitMQ (relay в API не может отправить):
логи `event="relay.unavailable"`.
4. Трасса загрузки, сделанной во время отказа (Tempo: `{ span.messenger.attachment.id = "<id>" }`):
промежуток между `send attachments` и `process attachments.process` — время ожидания в очереди.
5. После запуска worker backlog уходит за секунды, alert — resolved на следующей проверке (15–30 с).
## TelemetryExportFailing
**Условие.** Collector не может отправить данные в Tempo, Loki или Prometheus (`otelcol_exporter_send_failed_*`
растёт или в очереди exporter больше 20 пачек) 1 минуту.
**Шаги.**
1. Панель «Очереди exporter»: у какого exporter растёт очередь (`otlphttp/tempo`, `otlphttp/loki`,
`otlphttp/prometheus`) — то хранилище и недоступно. `make ps`, `docker compose logs <хранилище>`.
2. Бизнес-функции не затронуты: API и worker не ждут Collector. Проверка: `make test`.
3. Очередь ограничена (200 пачек), повторы — до 5 минут. Пока хранилище вернулось за это время,
данные доезжают из очереди; иначе отбрасываются и считаются в «не отправлено».
4. После запуска хранилища очередь разгружается, alert — resolved.
+12
View File
@@ -0,0 +1,12 @@
# Prometheus 3.7.3 (с lab7): HTTP-сервер только по TLS и только с клиентским сертификатом нашего CA.
# Доверенного CA мало: client_allowed_sans пропускает лишь три identity —
# otel-collector (запись OTLP-метрик), grafana (запросы dashboard), prometheus (свой healthcheck).
# Сертификат api, worker или lb от того же CA получит отказ. Наружу Prometheus не опубликован:
# оператор смотрит метрики и alerts через Grafana (HTTPS + пароль).
tls_server_config:
cert_file: /run/tls/tls.crt
key_file: /run/tls/tls.key
client_auth_type: RequireAndVerifyClientCert
client_ca_file: /run/ca/ca.crt
client_allowed_sans: [otel-collector, grafana, prometheus]
min_version: TLS12
+41
View File
@@ -0,0 +1,41 @@
# RabbitMQ стенда lab7: общие настройки (секретов здесь нет).
#
# С lab7:
# - открытого AMQP (5672) нет: только AMQPS 5671, TLS 1.2+;
# - mTLS: брокер требует клиентский сертификат нашего CA (verify_peer + fail_if_no_peer_cert);
# - вход только SASL EXTERNAL: имя пользователя = CN клиентского сертификата, поэтому пользователи
# названы ровно как identity — "api" и "worker". Паролей у них нет (password_hash пустой),
# PLAIN/AMQPLAIN выключены;
# - сертификат того же CA с другим CN (например, intruder или lb) не даёт ничего: такого
# пользователя нет -> отказ при входе; api не может читать очередь, worker не может публиковать
# (права в definitions.json);
# - топология, vhost, пользователи и права создаются из definitions.json при старте брокера.
listeners.tcp = none
listeners.ssl.default = 5671
ssl_options.cacertfile = /run/ca/ca.crt
ssl_options.certfile = /run/tls/tls.crt
ssl_options.keyfile = /run/tls/tls.key
ssl_options.verify = verify_peer
ssl_options.fail_if_no_peer_cert = true
ssl_options.versions.1 = tlsv1.3
ssl_options.versions.2 = tlsv1.2
auth_mechanisms.1 = EXTERNAL
ssl_cert_login_from = common_name
definitions.import_backend = local_filesystem
definitions.local.path = /etc/rabbitmq/definitions.json
definitions.skip_if_unchanged = true
# Гость и пользователь по умолчанию не нужны: доступ только по сертификатам из definitions.json.
loopback_users = none
# Лимиты: при нехватке памяти или диска брокер не падает, а временно блокирует публикацию.
vm_memory_high_watermark.absolute = 256MiB
disk_free_limit.absolute = 256MiB
# Потребитель, который держит сообщение без ack дольше 5 минут, считается зависшим.
consumer_timeout = 300000
# Веб-консоль (management plugin) в этом образе не включена: управлять брокером по HTTP нельзя.
log.console = true
log.console.level = info
+29
View File
@@ -0,0 +1,29 @@
{
"rabbit_version": "4.2.9",
"vhosts": [{"name": "messenger"}],
"users": [
{"name": "api", "password_hash": "", "hashing_algorithm": "rabbit_password_hashing_sha256", "tags": []},
{"name": "worker", "password_hash": "", "hashing_algorithm": "rabbit_password_hashing_sha256", "tags": []}
],
"permissions": [
{"user": "api", "vhost": "messenger", "configure": "^$", "write": "^attachments$", "read": "^$"},
{"user": "worker", "vhost": "messenger", "configure": "^$", "write": "^$", "read": "^attachments\\.process$"}
],
"exchanges": [
{"name": "attachments", "vhost": "messenger", "type": "direct", "durable": true, "auto_delete": false, "internal": false, "arguments": {}},
{"name": "attachments.dlx", "vhost": "messenger", "type": "direct", "durable": true, "auto_delete": false, "internal": false, "arguments": {}}
],
"queues": [
{"name": "attachments.process", "vhost": "messenger", "durable": true, "auto_delete": false,
"arguments": {"x-queue-type": "quorum", "x-delivery-limit": 10, "x-dead-letter-exchange": "attachments.dlx",
"x-dead-letter-routing-key": "attachment.dead"}},
{"name": "attachments.dead", "vhost": "messenger", "durable": true, "auto_delete": false,
"arguments": {"x-queue-type": "quorum", "x-max-length": 100000}}
],
"bindings": [
{"source": "attachments", "vhost": "messenger", "destination": "attachments.process", "destination_type": "queue",
"routing_key": "attachment.process.v1", "arguments": {}},
{"source": "attachments.dlx", "vhost": "messenger", "destination": "attachments.dead", "destination_type": "queue",
"routing_key": "attachment.dead", "arguments": {}}
]
}
+1
View File
@@ -0,0 +1 @@
[rabbitmq_auth_mechanism_ssl].
+74
View File
@@ -0,0 +1,74 @@
-- Обоснование индекса истории сообщений: EXPLAIN (ANALYZE, BUFFERS) на синтетических данных.
-- Запуск: make explain > evidence/explain-history.txt
-- (= docker compose exec -T postgres psql -U messenger -d messenger < infra/sql/explain_history.sql)
--
-- Всё выполняется в одной транзакции и в конце откатывается (ROLLBACK):
-- синтетические данные не остаются в базе, скрипт можно запускать сколько угодно раз.
-- DROP INDEX внутри транзакции на время скрипта блокирует запись в messages — запускать на учебном стенде.
\pset footer off
BEGIN;
-- 1 «большой» чат на 12 000 сообщений и 19 чатов по 500 (всего 21 500 сообщений):
-- в таблице есть чужие сообщения, как в настоящей базе.
CREATE TEMP TABLE seed_chats AS
SELECT gen_random_uuid() AS chat_id, n, CASE WHEN n = 0 THEN 12000 ELSE 500 END AS size
FROM generate_series(0, 19) AS n;
CREATE TEMP TABLE seed_user AS SELECT gen_random_uuid() AS user_id;
INSERT INTO users (id, username, display_name, password_hash)
SELECT user_id, 'explain_' || substr(md5(random()::text), 1, 12), convert_to('EXPLAIN', 'UTF8'), 'not-a-real-hash' FROM seed_user;
INSERT INTO chats (id, title) SELECT chat_id, convert_to('explain ' || n, 'UTF8') FROM seed_chats;
INSERT INTO chat_members (chat_id, user_id) SELECT chat_id, user_id FROM seed_chats, seed_user;
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
SELECT gen_random_uuid(), c.chat_id, u.user_id, convert_to('synthetic message ' || g, 'UTF8'),
timestamptz '2026-01-01 00:00:00+00' + g * interval '1 second'
FROM seed_chats c, seed_user u, generate_series(1, c.size) AS g;
ANALYZE messages;
SELECT chat_id AS big_chat FROM seed_chats WHERE n = 0 \gset
-- Курсор «середины истории»: ключ (created_at, id) 6000-го сообщения большого чата.
SELECT created_at AS cur_ts, id AS cur_id FROM messages
WHERE chat_id = :'big_chat' ORDER BY created_at, id OFFSET 5999 LIMIT 1 \gset
\echo '=== Объём данных'
SELECT count(*) AS messages_total,
count(*) FILTER (WHERE chat_id = :'big_chat') AS messages_in_big_chat
FROM messages;
\echo ''
\echo '=== Индекс истории (migrations/001_core.sql)'
SELECT indexdef FROM pg_indexes WHERE indexname = 'messages_chat_history_idx';
\echo ''
\echo '=== 1. Первая страница (limit=50, приложение просит 51 строку, чтобы понять, есть ли следующая)'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'big_chat'
ORDER BY created_at, id LIMIT 51;
\echo ''
\echo '=== 2. Страница из середины истории по keyset-курсору (после 6000-го сообщения)'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
ORDER BY created_at, id LIMIT 51;
\echo ''
\echo '=== 3. Для сравнения: та же страница через OFFSET (так приложение НЕ делает)'
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'big_chat'
ORDER BY created_at, id OFFSET 6000 LIMIT 51;
\echo ''
\echo '=== 4. Для сравнения: запрос 2 без индекса (индекс удалён только внутри этой транзакции)'
DROP INDEX messages_chat_history_idx;
EXPLAIN (ANALYZE, BUFFERS, COSTS OFF)
SELECT id, chat_id, sender_id, text, created_at FROM messages
WHERE chat_id = :'big_chat' AND (created_at, id) > (:'cur_ts'::timestamptz, :'cur_id'::uuid)
ORDER BY created_at, id LIMIT 51;
ROLLBACK;
\echo ''
\echo '=== ROLLBACK: синтетические данные удалены, индекс на месте'
+43
View File
@@ -0,0 +1,43 @@
# Tempo 2.9.0 стенда lab7 — хранилище ТРАСС (один процесс, данные на диске в volume tempodata).
#
# Трассы приходят от Collector по OTLP/HTTP, Grafana ищет трассы по trace_id и TraceQL.
stream_over_http_enabled: true
# С lab7: Tempo слушает ТОЛЬКО 127.0.0.1 общего с шлюзом tsdb-gw network namespace
# (network_mode: service:tsdb-gw). Снаружи: tempo:3200 (запросы, только identity grafana) и
# tempo:4318 (приём OTLP, только identity otel-collector) — mTLS и allowlist в infra/tsdb/gateway.cfg.
# Почему шлюз: у HTTP-сервера Tempo нет списка разрешённых identity, только «сертификат нашего CA».
server:
http_listen_address: 127.0.0.1
http_listen_port: 13200
grpc_listen_address: 127.0.0.1
log_level: warn
# Кольцо компонентов одного процесса: gossip только на loopback, в сеть не выходит.
memberlist:
bind_addr: ["127.0.0.1"]
distributor:
receivers:
otlp:
protocols:
http:
endpoint: 127.0.0.1:14318
ingester:
max_block_duration: 5m # блок трасс сбрасывается на диск не реже раза в 5 минут
compactor:
compaction:
block_retention: 168h # 7 дней
storage:
trace:
backend: local
wal:
path: /var/tempo/wal
local:
path: /var/tempo/blocks
usage_report:
reporting_enabled: false
+61
View File
@@ -0,0 +1,61 @@
# tsdb-gw — mTLS-шлюз перед Loki и Tempo (lab7).
#
# Зачем: у HTTP-сервера Loki и Tempo (dskit) есть только «клиент обязан предъявить сертификат нашего CA»,
# а списка разрешённых identity нет. Без шлюза любой сервис стенда с сертификатом нашего CA (api, lb, …)
# читал бы логи и трассы. Матрица доверия: клиенты хранилищ — только otel-collector и grafana.
#
# Шлюз слушает в сети telemetry под DNS-именами loki и tempo, с сертификатом своей identity на каждом порту:
# :3100 (loki) — запись логов от otel-collector и запросы grafana;
# :3200 (tempo) — запросы grafana;
# :4318 (tempo) — приём трасс OTLP от otel-collector.
# Клиент обязан предъявить сертификат нашего CA (verify required): без сертификата или с чужим CA
# рукопожатие не проходит. Затем проверяется identity (CN): чужая identity нашего CA получает 403.
# Разрешённый запрос уходит в Loki/Tempo на 127.0.0.1 — они делят с шлюзом network namespace
# (network_mode: service:tsdb-gw) и из сети Docker недоступны: обхода шлюза нет.
global
log stdout format raw local0 info
maxconn 500
ssl-default-bind-options ssl-min-ver TLSv1.2 no-tls-tickets
defaults
mode http
log global
option httplog
option dontlog-normal
timeout connect 2s
timeout client 60s
timeout server 60s
timeout http-request 10s
frontend loki_in
bind :3100 ssl crt /run/tls-loki/tls.pem ca-file /run/ca/ca.crt verify required
acl allowed ssl_c_s_dn(CN) -m str otel-collector grafana
http-request deny deny_status 403 unless allowed
default_backend loki
frontend tempo_query_in
bind :3200 ssl crt /run/tls-tempo/tls.pem ca-file /run/ca/ca.crt verify required
acl allowed ssl_c_s_dn(CN) -m str grafana
http-request deny deny_status 403 unless allowed
default_backend tempo_query
frontend tempo_otlp_in
bind :4318 ssl crt /run/tls-tempo/tls.pem ca-file /run/ca/ca.crt verify required
acl allowed ssl_c_s_dn(CN) -m str otel-collector
http-request deny deny_status 403 unless allowed
http-request deny deny_status 413 if { req.hdr_val(content-length) gt 8388608 }
default_backend tempo_otlp
backend loki
server local 127.0.0.1:13100
backend tempo_query
server local 127.0.0.1:13200
backend tempo_otlp
server local 127.0.0.1:14318
# Healthcheck контейнера: только 127.0.0.1 внутри общего namespace.
frontend health
bind 127.0.0.1:8407
monitor-uri /healthz
+32
View File
@@ -0,0 +1,32 @@
# Valkey в этой работе — КЭШ сессий и (с lab7) общие счётчики лимита частоты входа.
# Источник истины для сессий — таблица sessions в PostgreSQL. Persistence выключена:
# после рестарта кэш пустой, данные заново берутся из БД, счётчики лимитов начинаются с нуля.
#
# С lab7 — только TLS: открытый порт выключен (port 0), TLS-порт 6379 с сертификатом identity valkey
# (наш CA). Клиент (API) проверяет сертификат и имя valkey. Клиентский сертификат не требуется
# (tls-auth-clients no): аутентификация — ACL-пароль пользователя messenger, полученный API из OpenBao.
port 0
tls-port 6379
tls-cert-file /run/tls/tls.crt
tls-key-file /run/tls/tls.key
tls-ca-cert-file /run/ca/ca.crt
tls-auth-clients no
tls-protocols "TLSv1.2 TLSv1.3"
bind 0.0.0.0
protected-mode yes
# Пользователи и пароли — в секрете (scripts/init-secrets.sh создаёт secrets/valkey_users.acl):
# default — выключен (анонимный доступ запрещён);
# health — без пароля, только ping/info/dbsize (для healthcheck и наблюдения);
# messenger — пароль из OpenBao, только ключи sess:* и rl:* и только нужные команды.
aclfile /run/secrets/valkey_acl
# Без сохранения на диск: ни RDB-снимков, ни AOF. Рабочий каталог — tmpfs (корень контейнера read-only).
dir /tmp
save ""
appendonly no
# Ограничение памяти. При нехватке выбрасываются давно не читанные записи С TTL (все записи о сессиях
# и счётчики лимитов). Ключ sess:gen (общее поколение кэша) без TTL и поэтому не выбрасывается.
maxmemory 64mb
maxmemory-policy volatile-lru
+45
View File
@@ -0,0 +1,45 @@
-- 001: пользователи, чаты, участники, сообщения.
-- Применяется один раз; номер версии записывается в schema_migrations (см. src/messenger/db.py).
-- Все проверки, которые важны для целостности, продублированы в базе: даже если в коде
-- появится ошибка, PostgreSQL не даст записать некорректные данные.
CREATE TABLE users (
id uuid PRIMARY KEY,
username text NOT NULL,
display_name text NOT NULL,
password_hash text NOT NULL, -- строка Argon2id ($argon2id$...), не сам пароль
created_at timestamptz NOT NULL DEFAULT now(),
CONSTRAINT users_username_key UNIQUE (username), -- защищает от гонки двух регистраций
CONSTRAINT users_username_format CHECK (username ~ '^[a-z0-9_]{3,32}$'),
CONSTRAINT users_display_name_len CHECK (char_length(display_name) BETWEEN 1 AND 100)
);
CREATE TABLE chats (
id uuid PRIMARY KEY,
title text NOT NULL CHECK (char_length(title) BETWEEN 1 AND 100),
created_at timestamptz NOT NULL DEFAULT now()
);
-- Членство: какой пользователь в каком чате. Первичный ключ исключает дубликаты.
CREATE TABLE chat_members (
chat_id uuid NOT NULL REFERENCES chats (id),
user_id uuid NOT NULL REFERENCES users (id),
PRIMARY KEY (chat_id, user_id)
);
-- «Список чатов пользователя»: поиск по user_id (PK начинается с chat_id и тут не помогает).
CREATE INDEX chat_members_user_idx ON chat_members (user_id, chat_id);
CREATE TABLE messages (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL,
sender_id uuid NOT NULL,
text text NOT NULL CHECK (char_length(text) BETWEEN 1 AND 4000),
created_at timestamptz NOT NULL DEFAULT now(),
-- Отправитель обязан быть участником этого чата: внешний ключ на пару (чат, участник).
CONSTRAINT messages_sender_is_member FOREIGN KEY (chat_id, sender_id)
REFERENCES chat_members (chat_id, user_id)
);
-- История чата: WHERE chat_id = ? AND (created_at, id) > (?, ?) ORDER BY created_at, id LIMIT ?
-- Индекс уже отсортирован в нужном порядке, поэтому страница читается без сортировки
-- и без просмотра всей истории. Обоснование и EXPLAIN: evidence/explain-history.txt.
CREATE INDEX messages_chat_history_idx ON messages (chat_id, created_at, id);
+13
View File
@@ -0,0 +1,13 @@
-- 002: серверные сессии (источник истины для Bearer-токенов).
-- Хранится не сам токен, а его SHA-256: утечка таблицы не даёт рабочих токенов.
CREATE TABLE sessions (
token_hash bytea PRIMARY KEY CHECK (octet_length(token_hash) = 32),
user_id uuid NOT NULL REFERENCES users (id),
created_at timestamptz NOT NULL DEFAULT now(),
expires_at timestamptz NOT NULL, -- абсолютное время: рестарт не продлевает сессию
revoked_at timestamptz, -- заполнено = logout
CONSTRAINT sessions_expiry_after_creation CHECK (expires_at > created_at)
);
-- Очистка старых сессий пользователя при входе (DELETE ... WHERE user_id = ?).
CREATE INDEX sessions_user_idx ON sessions (user_id);
+28
View File
@@ -0,0 +1,28 @@
-- 003: свободный текст хранится как байты UTF-8 (bytea), а не как text.
--
-- Причина: тип text в PostgreSQL не может содержать символ U+0000 (байт 0x00), а контракт
-- этот символ в display_name, title и text не запрещает. Строка "hello\u0000world" давала 500.
-- В bytea байт 0x00 допустим, поэтому такие строки теперь сохраняются и возвращаются без изменений.
-- Кодирование/декодирование UTF-8 — в src/messenger/store.py (to_db/from_db).
--
-- Это новая миграция, а не правка 001: 001 уже применена на существующих стендах.
-- Уже сохранённые данные переводятся через convert_to и не теряются.
--
-- Точное число символов (1–100, 1–4000) проверяет API. Функции PostgreSQL, которые считают
-- символы в bytea, отвергают байт 0x00, поэтому CHECK в базе ограничивает длину в байтах:
-- не пусто и не больше 4 байт на символ (максимальный размер символа в UTF-8).
ALTER TABLE users DROP CONSTRAINT users_display_name_len;
ALTER TABLE users ALTER COLUMN display_name TYPE bytea USING convert_to(display_name, 'UTF8');
ALTER TABLE users ADD CONSTRAINT users_display_name_len
CHECK (octet_length(display_name) BETWEEN 1 AND 400);
ALTER TABLE chats DROP CONSTRAINT chats_title_check;
ALTER TABLE chats ALTER COLUMN title TYPE bytea USING convert_to(title, 'UTF8');
ALTER TABLE chats ADD CONSTRAINT chats_title_len
CHECK (octet_length(title) BETWEEN 1 AND 400);
ALTER TABLE messages DROP CONSTRAINT messages_text_check;
ALTER TABLE messages ALTER COLUMN text TYPE bytea USING convert_to(text, 'UTF8');
ALTER TABLE messages ADD CONSTRAINT messages_text_len
CHECK (octet_length(text) BETWEEN 1 AND 16000);
+30
View File
@@ -0,0 +1,30 @@
-- 004 (lab3): идемпотентность отправки сообщения (заголовок Idempotency-Key).
--
-- Ключ и SHA-256 тела запроса хранятся прямо в строке сообщения. Уникальное ограничение
-- (chat_id, sender_id, idempotency_key) = область ключа из контракта: пользователь + чат
-- (метод и путь у этого ключа всегда POST /chats/{id}/messages). Повтор с тем же ключом
-- не может создать второе сообщение даже при одновременных запросах через разные реплики.
-- Ключ живёт столько же, сколько сообщение (бессрочно; контракт требует не меньше 24 ч).
--
-- Совместимость с уже работающей версией (lab2): добавляются только НОВЫЕ столбцы,
-- которые могут быть NULL. Старый код пишет сообщения без ключа (NULL) и читает только
-- свои столбцы — он продолжает работать с новой схемой. Строки без ключа уникальность
-- не нарушают: в PostgreSQL значения NULL не считаются одинаковыми.
-- Ограничение: на большой таблице построение уникального индекса блокирует запись в messages.
-- Для большой базы индекс строят заранее через CREATE UNIQUE INDEX CONCURRENTLY (вне транзакции),
-- а затем добавляют ограничение USING INDEX. На учебной базе это доли секунды.
ALTER TABLE messages
ADD COLUMN idempotency_key text,
ADD COLUMN request_hash bytea;
ALTER TABLE messages
ADD CONSTRAINT messages_idempotency_key_format
CHECK (idempotency_key ~ '^[A-Za-z0-9._:-]{1,128}$'),
ADD CONSTRAINT messages_request_hash_len
CHECK (octet_length(request_hash) = 32),
-- ключ и отпечаток тела всегда вместе: оба заданы или оба NULL
ADD CONSTRAINT messages_key_with_hash
CHECK ((idempotency_key IS NULL) = (request_hash IS NULL)),
ADD CONSTRAINT messages_idempotency_unique
UNIQUE (chat_id, sender_id, idempotency_key);
+50
View File
@@ -0,0 +1,50 @@
-- lab4: вложения (картинки PNG/JPEG).
-- В PostgreSQL лежат только МЕТАДАННЫЕ: чей файл, в каком чате, имя для показа, размер, SHA-256.
-- Сами байты лежат в приватном bucket S3 (MinIO); здесь хранится только ключ объекта storage_key.
-- Столбца с байтами файла в таблице нет.
--
-- status — внутреннее состояние загрузки, наружу API показывает только ready:
-- pending — строка записана ДО загрузки байтов в S3 («намерение»). Если после этого
-- что-то сломалось (S3 недоступен, база не подтвердила ready, процесс убит),
-- строка остаётся pending, и уборщик (src/messenger/cleanup.py) после grace period
-- удаляет объект (если он успел записаться) и саму строку;
-- ready — байты в S3 и метаданные в БД, файл можно скачивать и прикреплять.
CREATE TABLE attachments (
id uuid PRIMARY KEY,
chat_id uuid NOT NULL REFERENCES chats (id),
owner_id uuid NOT NULL REFERENCES users (id),
filename text NOT NULL CHECK (char_length(filename) BETWEEN 1 AND 255), -- только для показа
content_type text NOT NULL CHECK (content_type IN ('image/png', 'image/jpeg')), -- по содержимому
size_bytes bigint NOT NULL CHECK (size_bytes BETWEEN 1 AND 10485760),
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
width integer NOT NULL CHECK (width > 0),
height integer NOT NULL CHECK (height > 0),
storage_key text NOT NULL UNIQUE, -- ключ в bucket, назначает сервер
status text NOT NULL CHECK (status IN ('pending', 'ready')),
created_at timestamptz NOT NULL DEFAULT now(),
updated_at timestamptz NOT NULL DEFAULT now(),
-- Загрузил участник этого чата: внешний ключ на пару (чат, участник), как у messages.
CONSTRAINT attachments_owner_is_member FOREIGN KEY (chat_id, owner_id)
REFERENCES chat_members (chat_id, user_id)
);
CREATE INDEX attachments_chat_idx ON attachments (chat_id);
-- Уборщику нужны только старые pending-строки: частичный индекс маленький.
CREATE INDEX attachments_pending_idx ON attachments (created_at) WHERE status = 'pending';
-- Какие вложения у сообщения и в каком порядке (как в attachment_ids запроса).
-- Одно вложение могут использовать несколько сообщений этого же чата.
CREATE TABLE message_attachments (
message_id uuid NOT NULL REFERENCES messages (id),
attachment_id uuid NOT NULL REFERENCES attachments (id),
position smallint NOT NULL CHECK (position BETWEEN 0 AND 9), -- не больше 10 вложений
PRIMARY KEY (message_id, position),
CONSTRAINT message_attachments_unique UNIQUE (message_id, attachment_id)
);
CREATE INDEX message_attachments_attachment_idx ON message_attachments (attachment_id);
-- С lab4 текст сообщения может быть пустым, если есть хотя бы одно вложение
-- (это проверяет API). Ограничение длины остаётся, нижняя граница снимается.
-- Изменение только ослабляет проверку, поэтому совместимо с уже работающей версией lab3.
ALTER TABLE messages DROP CONSTRAINT messages_text_len;
ALTER TABLE messages ADD CONSTRAINT messages_text_len CHECK (octet_length(text) <= 16000);
+111
View File
@@ -0,0 +1,111 @@
-- 006 (lab5): асинхронная обработка вложений — задания, transactional outbox, варианты, журнал.
--
-- Что меняется по сравнению с lab4:
-- * загрузка больше не делает вложение готовым сразу. API кладёт оригинал в staging S3
-- (staging/<id>) и в ОДНОЙ транзакции пишет: строку вложения (queued), задание и строку outbox.
-- Только после COMMIT отвечает 202. Сообщение в брокер отправляет отдельный цикл (relay):
-- так «намерение обработать» не теряется, даже если брокер недоступен или API упал сразу
-- после COMMIT (transactional outbox);
-- * worker переводит задание queued -> processing -> ready/failed и пишет варианты.
--
-- Состояния вложения (attachments.status, наружу отдаются как есть):
-- queued — оригинал в staging, задание сохранено, ждёт worker (или повтора после паузы);
-- processing — worker взял задание под lease (аренду) с крайним сроком;
-- ready — оригинал опубликован в originals/<id>, все варианты записаны и закоммичены;
-- failed — постоянная ошибка или исчерпаны попытки; error_code — краткий машинный код.
-- Старый статус pending (lab4: загрузка, прерванная между S3 и COMMIT) больше не нужен:
-- такие строки никогда не были видны клиенту, их объекты уберёт уборщик как «сироты».
DELETE FROM attachments a
WHERE a.status = 'pending'
AND NOT EXISTS (SELECT 1 FROM message_attachments ma WHERE ma.attachment_id = a.id);
ALTER TABLE attachments DROP CONSTRAINT attachments_status_check;
ALTER TABLE attachments ADD CONSTRAINT attachments_status_check
CHECK (status IN ('queued', 'processing', 'ready', 'failed'));
ALTER TABLE attachments
ADD COLUMN error_code text CHECK (error_code ~ '^[a-z_]{1,64}$'),
-- staging/<id>: где лежит принятый оригинал до обработки. NULL у вложений lab4 (их не было).
ADD COLUMN staging_key text UNIQUE;
-- error_code заполнен ровно у failed.
ALTER TABLE attachments ADD CONSTRAINT attachments_error_only_when_failed
CHECK ((status = 'failed') = (error_code IS NOT NULL));
DROP INDEX IF EXISTS attachments_pending_idx;
-- Задание обработки: одна строка на (вложение, версия pipeline). job_id не меняется при повторах.
CREATE TABLE attachment_jobs (
job_id uuid PRIMARY KEY,
attachment_id uuid NOT NULL REFERENCES attachments (id),
pipeline_version integer NOT NULL CHECK (pipeline_version >= 1),
status text NOT NULL CHECK (status IN ('queued', 'processing', 'ready', 'failed')),
-- Номер управляемой попытки. Растёт при каждом повторе (временная ошибка, истёк lease, replay);
-- сообщение брокера несёт этот номер, и сообщение со старым номером считается устаревшим дублем.
attempt integer NOT NULL CHECK (attempt >= 1),
max_attempts integer NOT NULL CHECK (max_attempts >= 1),
next_attempt_at timestamptz NOT NULL DEFAULT now(),
-- Lease: кто обрабатывает, «жетон» аренды и до какого времени аренда действует.
-- Результат принимается, только если жетон совпадает (fencing): опоздавший worker,
-- у которого аренду уже забрали, ничего не перезапишет.
lease_owner text,
lease_token uuid,
lease_until timestamptz,
last_error_code text CHECK (last_error_code ~ '^[a-z_]{1,64}$'),
last_error text CHECK (char_length(last_error) <= 300), -- без stack trace и секретов
created_at timestamptz NOT NULL DEFAULT now(),
updated_at timestamptz NOT NULL DEFAULT now(),
finished_at timestamptz,
CONSTRAINT attachment_jobs_one_per_version UNIQUE (attachment_id, pipeline_version),
CONSTRAINT attachment_jobs_lease_only_when_processing
CHECK ((status = 'processing') = (lease_token IS NOT NULL AND lease_until IS NOT NULL AND lease_owner IS NOT NULL))
);
-- Поиск «зависших» заданий (истёк lease) и заданий в очереди.
CREATE INDEX attachment_jobs_lease_idx ON attachment_jobs (lease_until) WHERE status = 'processing';
CREATE INDEX attachment_jobs_queued_idx ON attachment_jobs (next_attempt_at) WHERE status = 'queued';
-- Transactional outbox: сообщения для брокера, записанные в той же транзакции, что и задание.
-- payload — ровно тело сообщения по contracts/jobs.schema.json: только ID и служебные поля,
-- без байтов файла, ключей S3, URL и паролей.
CREATE TABLE outbox (
id bigserial PRIMARY KEY,
job_id uuid NOT NULL REFERENCES attachment_jobs (job_id),
attempt integer NOT NULL CHECK (attempt >= 1),
payload jsonb NOT NULL,
available_at timestamptz NOT NULL DEFAULT now(), -- не раньше (отложенный повтор с backoff)
created_at timestamptz NOT NULL DEFAULT now(),
published_at timestamptz, -- брокер подтвердил приём (publisher confirm)
published_by text
);
-- Relay читает только неотправленные строки, у которых подошло время: частичный индекс маленький.
CREATE INDEX outbox_unpublished_idx ON outbox (available_at, id) WHERE published_at IS NULL;
CREATE INDEX outbox_job_idx ON outbox (job_id);
-- Варианты. Первичный ключ = ключ эффекта из контракта (attachment_id, pipeline_version, variant):
-- повтор задания не может создать второй набор вариантов.
CREATE TABLE attachment_variants (
attachment_id uuid NOT NULL REFERENCES attachments (id),
pipeline_version integer NOT NULL CHECK (pipeline_version >= 1),
name text NOT NULL CHECK (name IN ('thumbnail', 'crop', 'optimized')),
storage_key text NOT NULL UNIQUE,
content_type text NOT NULL CHECK (content_type IN ('image/jpeg', 'image/png', 'image/webp')),
size_bytes bigint NOT NULL CHECK (size_bytes > 0),
width integer NOT NULL CHECK (width > 0),
height integer NOT NULL CHECK (height > 0),
sha256 text NOT NULL CHECK (sha256 ~ '^[a-f0-9]{64}$'),
job_id uuid NOT NULL REFERENCES attachment_jobs (job_id),
created_at timestamptz NOT NULL DEFAULT now(),
PRIMARY KEY (attachment_id, pipeline_version, name)
);
-- Журнал заданий: что и когда происходило (взято, повтор, lease истёк, дубль, replay оператора).
-- Нужен для расследования и для аудита ручного replay. Без секретов и содержимого файлов.
CREATE TABLE job_events (
id bigserial PRIMARY KEY,
job_id uuid NOT NULL,
attachment_id uuid NOT NULL,
attempt integer,
event text NOT NULL CHECK (event ~ '^[a-z_]{1,40}$'),
actor text NOT NULL,
detail text CHECK (char_length(detail) <= 300),
created_at timestamptz NOT NULL DEFAULT now()
);
CREATE INDEX job_events_job_idx ON job_events (job_id, id);
+36
View File
@@ -0,0 +1,36 @@
-- lab7: минимальные права ролей приложения.
--
-- Роли messenger_api и messenger_worker (LOGIN, пароль) создаёт при ПЕРВОЙ инициализации volume
-- скрипт infra/postgres/initdb/10-roles.sh: пароли есть только в secrets/ оператора и в OpenBao.
-- Здесь — только права. Таблицами владеет роль messenger (ей входит лишь сервис migrate и оператор);
-- роли приложения не могут менять схему (CREATE/ALTER/DROP/TRUNCATE), читать чужие таблицы и
-- удалять пользователей, чаты и сообщения (в API курса нет delete).
--
-- worker не видит ни пользователей (и hash их паролей), ни сессий, ни чатов, ни сообщений:
-- только вложения, задания, outbox, варианты и журнал заданий.
DO $$
BEGIN
IF NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'messenger_api')
OR NOT EXISTS (SELECT 1 FROM pg_roles WHERE rolname = 'messenger_worker') THEN
RAISE EXCEPTION 'roles messenger_api/messenger_worker are missing: volume was initialised without infra/postgres/initdb';
END IF;
END
$$;
REVOKE ALL ON ALL TABLES IN SCHEMA public FROM PUBLIC;
REVOKE CREATE ON SCHEMA public FROM PUBLIC;
GRANT USAGE ON SCHEMA public TO messenger_api, messenger_worker;
-- API: всё, что нужно эндпоинтам, relay и метрикам очереди.
GRANT SELECT ON schema_migrations TO messenger_api, messenger_worker;
GRANT SELECT, INSERT, UPDATE ON users, chats, chat_members, messages, message_attachments TO messenger_api;
GRANT SELECT, INSERT, UPDATE, DELETE ON sessions, attachments, attachment_jobs, outbox,
attachment_variants, job_events TO messenger_api;
-- worker: обработка заданий, lease, повторы, уборка объектов и старого outbox.
GRANT SELECT, INSERT, UPDATE ON attachments, attachment_jobs, attachment_variants, job_events TO messenger_worker;
GRANT SELECT, INSERT, UPDATE, DELETE ON outbox TO messenger_worker;
GRANT DELETE ON attachment_variants TO messenger_worker;
-- bigserial (outbox.id, job_events.id)
GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO messenger_api, messenger_worker;
+62
View File
@@ -0,0 +1,62 @@
# Все зависимости закреплены точными версиями (включая транзитивные),
# чтобы сборка образа через месяц дала то же самое, что сегодня.
annotated-types==0.8.0
anyio==4.15.1
argon2-cffi==25.1.0 # Argon2id для паролей
argon2-cffi-bindings==26.1.0
cryptography==50.0.2 # с lab7: проверка CRL в API (tlsserver.py) и локальный CA (scripts/pki.py)
boto3==1.43.116 # клиент S3 (SeaweedFS) — с lab4
botocore==1.43.116
cffi==2.1.1
click==8.5.0
fastapi==0.115.12
h11==0.16.0
idna==3.20
jmespath==1.1.0
numpy==2.3.5 # нужен simplejpeg — с lab5
pika==1.4.4 # клиент RabbitMQ (relay и worker) — с lab5
pillow==13.0.0 # заголовок картинки в API, обработка в worker — с lab4
psycopg==3.3.6 # драйвер PostgreSQL
psycopg-binary==3.3.6
psycopg-pool==3.3.3 # пул соединений
pycparser==3.1
pydantic==2.13.5
pydantic_core==2.46.5
python-dateutil==2.9.0.post0
s3transfer==0.19.3
simplejpeg==1.9.0 # строгая проверка JPEG (libjpeg-turbo) в worker — с lab5
six==1.17.0
starlette==0.46.2
typing-inspection==0.4.4
typing_extensions==4.16.0
urllib3==2.8.0
uvicorn==0.34.3
valkey==6.1.1 # клиент Valkey (кэш сессий)
# --- с lab6: наблюдаемость (OpenTelemetry SDK, автоинструментация) и их зависимости ---
asgiref==3.13.0
certifi==2026.10.23
charset-normalizer==3.5.2
googleapis-common-protos==1.76.0
opentelemetry-api==1.45.2 # API OpenTelemetry (трассы, метрики) — с lab6
opentelemetry-exporter-http-transport==0.66b2
opentelemetry-exporter-otlp-common==0.66b2
opentelemetry-exporter-otlp-proto-common==1.45.2
opentelemetry-exporter-otlp-proto-http==1.45.2 # отправка OTLP/HTTP в otel-collector — с lab6
opentelemetry-instrumentation==0.66b2
opentelemetry-instrumentation-asgi==0.66b2
opentelemetry-instrumentation-botocore==0.66b2 # спаны запросов к S3 — с lab6
opentelemetry-instrumentation-dbapi==0.66b2
opentelemetry-instrumentation-fastapi==0.66b2 # server span и HTTP-метрики на каждый запрос — с lab6
opentelemetry-instrumentation-logging==0.66b2 # LoggingHandler: логи -> OTLP с trace_id/span_id — с lab6
opentelemetry-instrumentation-psycopg==0.66b2 # SQL-спаны (без параметров) — с lab6
opentelemetry-instrumentation-system-metrics==0.66b2 # CPU и память процесса — с lab6
opentelemetry-propagator-aws-xray==1.0.2
opentelemetry-proto==1.45.2
opentelemetry-sdk==1.45.2 # SDK: провайдеры, BatchProcessor, выборка трасс — с lab6
opentelemetry-semantic-conventions==0.66b2
opentelemetry-util-http==0.66b2
packaging==26.3
protobuf==7.36.2
psutil==7.2.2
requests==2.34.2
wrapt==2.5.2
+252
View File
@@ -0,0 +1,252 @@
"""OpenBao operator tool for the lab7 stand (Python standard library only).
Runs in the short-lived "ops" container (make bao-init / bao-unseal / bao-bootstrap / ...).
It is the ONLY place that reads the operator material in secrets/operator/:
unseal-key-1..3 Shamir shares (threshold 2). In real life: three different people/places.
root-token initial root token (used only by these operator commands)
The files are created with mode 600, never mounted into services, never printed.
Commands:
status initialized / sealed / version (no token needed)
init operator init (3 shares, threshold 2); refuses to run twice
unseal submit shares until unsealed (needed after every OpenBao restart)
seal seal OpenBao (incident drill: sealed OpenBao)
bootstrap idempotent: kv-v2 at secret/, cert auth, audit device, policies,
cert roles for api/worker, application secrets from secrets/*
rotate-db new password for DB role messenger_api: ALTER ROLE + new KV version
revoke-tokens revoke every token issued by the cert auth method (forces re-login)
token-ttl ROLE TTL change token TTL of a cert role (e.g. expiry drill: api 30s)
Plain ASCII on purpose (scripts/check_contract.py reads scripts/*.py with the default encoding).
"""
import json
import os
import secrets as rnd
import ssl
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
SECRETS = Path(os.environ.get("SECRETS_DIR", ROOT / "secrets"))
OPERATOR = SECRETS / "operator"
POLICIES = Path(os.environ.get("BAO_POLICY_DIR", ROOT / "infra" / "openbao" / "policies"))
ADDR = os.environ.get("BAO_ADDR", "https://openbao:8200").rstrip("/")
CACERT = os.environ.get("BAO_CACERT", str(SECRETS / "tls" / "ca" / "ca.crt"))
SHARES, THRESHOLD = 3, 2
# role -> (certificate CN, policy, secret path). One policy per service, nothing shared.
ROLES = {"messenger-api": ("api", "messenger-api", "messenger/api"),
"messenger-worker": ("worker", "messenger-worker", "messenger/worker")}
TOKEN_TTL, TOKEN_MAX_TTL = os.environ.get("BAO_TOKEN_TTL", "15m"), os.environ.get("BAO_TOKEN_MAX_TTL", "1h")
CTX = ssl.create_default_context(cafile=CACERT) # server certificate and hostname are verified
class BaoError(Exception):
def __init__(self, status, errors):
super().__init__(f"HTTP {status}: {'; '.join(errors) or 'no details'}")
self.status = status
def call(method, path, body=None, token=None, ok=(200, 204)):
data = None if body is None else json.dumps(body).encode()
request = urllib.request.Request(ADDR + "/v1/" + path.lstrip("/"), data=data, method=method)
request.add_header("Content-Type", "application/json")
if token:
request.add_header("X-Vault-Token", token)
try:
with urllib.request.urlopen(request, context=CTX, timeout=10) as response:
raw = response.read()
status = response.status
except urllib.error.HTTPError as exc:
raw, status = exc.read(), exc.code
payload = json.loads(raw) if raw.strip() else {}
if status not in ok:
# Error bodies of OpenBao contain no secret values; tokens are never echoed.
raise BaoError(status, payload.get("errors", []))
return payload
def secret_file(name: str) -> str:
return (SECRETS / name).read_text(encoding="utf-8").strip()
def write_private(path: Path, value: str):
path.parent.mkdir(parents=True, exist_ok=True)
os.chmod(path.parent, 0o700)
fd = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600)
with os.fdopen(fd, "w") as fh:
fh.write(value)
def root_token() -> str:
path = OPERATOR / "root-token"
if not path.exists():
sys.exit("secrets/operator/root-token not found: run make bao-init first")
return path.read_text().strip()
def cmd_status(_args):
health = call("GET", "sys/seal-status")
print(f"initialized={health['initialized']} sealed={health['sealed']} "
f"progress={health.get('progress', 0)}/{health.get('t', 0)} version={health.get('version')} "
f"storage={health.get('storage_type')}")
return 0 if not health["sealed"] else 2
def cmd_init(_args):
if call("GET", "sys/init")["initialized"]:
print("OpenBao already initialized: nothing to do (shares and root token stay with the operator)")
return 0
result = call("PUT", "sys/init", {"secret_shares": SHARES, "secret_threshold": THRESHOLD})
for number, share in enumerate(result["keys_base64"], start=1):
write_private(OPERATOR / f"unseal-key-{number}", share)
write_private(OPERATOR / "root-token", result["root_token"])
print(f"initialized: {SHARES} unseal shares (threshold {THRESHOLD}) and root token saved to secrets/operator/ "
"(mode 600, not printed). Keep the shares apart: in production every share goes to a different person.")
return 0
def cmd_unseal(_args):
status = call("GET", "sys/seal-status")
if not status["initialized"]:
sys.exit("not initialized: run make bao-init")
if not status["sealed"]:
print("already unsealed")
return 0
keys = sorted(OPERATOR.glob("unseal-key-*"))
if len(keys) < THRESHOLD:
sys.exit(f"need {THRESHOLD} shares in secrets/operator/unseal-key-N")
for path in keys[:THRESHOLD]:
status = call("PUT", "sys/unseal", {"key": path.read_text().strip()})
print(f"sealed={status['sealed']} (used {THRESHOLD} of {len(keys)} shares)")
return 0 if not status["sealed"] else 1
def cmd_seal(_args):
call("PUT", "sys/seal", token=root_token())
print("sealed: services keep their cached secrets, new logins and reads fail until make bao-unseal")
return 0
def cmd_bootstrap(_args):
token = root_token()
if "secret/" not in call("GET", "sys/mounts", token=token)["data"]:
call("POST", "sys/mounts/secret", {"type": "kv", "options": {"version": "2"}}, token=token)
print("enabled kv-v2 at secret/")
if "cert/" not in call("GET", "sys/auth", token=token)["data"]:
call("POST", "sys/auth/cert", {"type": "cert"}, token=token)
print("enabled cert auth at auth/cert/")
# Audit device is declared in infra/openbao/bao.hcl: OpenBao 2.4 refuses to enable it via the API.
ca_pem = Path(CACERT).read_text()
for role, (common_name, policy, secret_path) in ROLES.items():
call("PUT", f"sys/policies/acl/{policy}",
{"policy": (POLICIES / f"{policy}.hcl").read_text(encoding="utf-8")}, token=token)
call("POST", f"auth/cert/certs/{role}", {
"display_name": role,
"certificate": ca_pem, # trust anchor: our CA only
"allowed_common_names": [common_name], # and only this identity
"token_policies": [policy],
"token_ttl": TOKEN_TTL, "token_max_ttl": TOKEN_MAX_TTL,
"token_no_default_policy": False, # default policy = lookup-self / renew-self only
}, token=token)
put_kv(token, "messenger/api", {
"db_password": secret_file("db_api_password"),
"s3_access_key_id": secret_file("s3_api_access_key_id"),
"s3_secret_access_key": secret_file("s3_api_secret_access_key"),
"cache_password": secret_file("valkey_api_password"),
})
put_kv(token, "messenger/worker", {
"db_password": secret_file("db_worker_password"),
"s3_access_key_id": secret_file("s3_worker_access_key_id"),
"s3_secret_access_key": secret_file("s3_worker_secret_access_key"),
})
print(f"policies messenger-api, messenger-worker; cert roles (CN api / worker, token ttl {TOKEN_TTL}, "
f"max {TOKEN_MAX_TTL}); secrets secret/messenger/api and secret/messenger/worker written (values not printed)")
return 0
def put_kv(token, path, data):
current = None
try:
current = call("GET", f"secret/data/{path}", token=token)["data"]["data"]
except BaoError as exc:
if exc.status != 404:
raise
if current != data:
call("POST", f"secret/data/{path}", {"data": data}, token=token)
def cmd_rotate_db(_args):
"""Rotate the password of DB role messenger_api without rebuilding images or restarting the API.
Order: 1) ALTER ROLE in PostgreSQL, 2) new KV version in OpenBao, 3) the operator copy.
Between 1) and the next API refresh (BAO_REFRESH_SECONDS) NEW DB connections of the API fail
and are retried; connections that are already open keep working (PostgreSQL checks the password
only at login). The API drains its pool when it sees the new value, so every connection after
that is a new login with the new password.
"""
import psycopg # available in the application image the ops container runs from
from psycopg import sql
token = root_token()
new = rnd.token_hex(24)
owner = secret_file("postgres_password")
with psycopg.connect(host=os.environ.get("DB_HOST", "postgres"), port=int(os.environ.get("DB_PORT", "5432")),
dbname="messenger", user="messenger", password=owner,
sslmode="verify-full", sslrootcert=CACERT, connect_timeout=5, autocommit=True) as conn:
conn.execute(sql.SQL("ALTER ROLE messenger_api PASSWORD {}").format(sql.Literal(new)))
data = call("GET", "secret/data/messenger/api", token=token)["data"]["data"]
data["db_password"] = new
result = call("POST", "secret/data/messenger/api", {"data": data}, token=token)
(SECRETS / "db_api_password").write_text(new)
print(f"rotated DB password of messenger_api: PostgreSQL updated, KV secret/messenger/api now version "
f"{result['data']['version']} (value not printed)")
return 0
def cmd_revoke_tokens(_args):
call("PUT", "sys/leases/revoke-prefix/auth/cert/login", token=root_token())
print("revoked all tokens issued by auth/cert: services must log in again with their certificates")
return 0
def cmd_token_ttl(args):
if len(args) != 2 or args[0] not in ("api", "worker"):
sys.exit("usage: token-ttl api|worker TTL (e.g. 30s, 15m)")
role = f"messenger-{args[0]}"
token = root_token()
current = call("GET", f"auth/cert/certs/{role}", token=token)["data"]
max_ttl = args[1] if args[1].endswith("s") else TOKEN_MAX_TTL
call("POST", f"auth/cert/certs/{role}", {
"display_name": role, "certificate": current["certificate"],
"allowed_common_names": current["allowed_common_names"], "token_policies": current["token_policies"],
"token_ttl": args[1], "token_max_ttl": max_ttl}, token=token)
print(f"{role}: token_ttl={args[1]} token_max_ttl={max_ttl} (applies to NEW logins)")
return 0
COMMANDS = {"status": cmd_status, "init": cmd_init, "unseal": cmd_unseal, "seal": cmd_seal,
"bootstrap": cmd_bootstrap, "rotate-db": cmd_rotate_db, "revoke-tokens": cmd_revoke_tokens,
"token-ttl": cmd_token_ttl}
def main():
if len(sys.argv) < 2 or sys.argv[1] not in COMMANDS:
sys.exit("usage: bao.py " + "|".join(COMMANDS))
deadline = time.monotonic() + 60
while True: # OpenBao may still be starting after docker compose up
try:
return COMMANDS[sys.argv[1]](sys.argv[2:])
except (urllib.error.URLError, ConnectionError, TimeoutError) as exc:
if time.monotonic() > deadline:
sys.exit(f"OpenBao at {ADDR} is not reachable: {getattr(exc, 'reason', exc)}")
time.sleep(2)
except BaoError as exc:
sys.exit(f"OpenBao refused: {exc}")
if __name__ == "__main__":
sys.exit(main())
+68
View File
@@ -0,0 +1,68 @@
#!/bin/sh
# Создаёт локальные секреты стенда в каталоге secrets/ (он в .gitignore и в Git не попадает).
# Запуск один раз: sh scripts/init-secrets.sh (затем сертификаты: make pki)
# Повторный запуск безопасен: существующие файлы не меняются, недостающие досоздаются.
#
# Кто что получает (lab7):
# оператор (этот каталог) — всё; root token и unseal shares OpenBao появятся в secrets/operator/ (make bao-init)
# postgres — пароль владельца схемы и пароли ролей messenger_api/messenger_worker (только для
# первой инициализации volume, infra/postgres/initdb/10-roles.sh)
# migrate — пароль владельца схемы messenger (одноразовый сервис, не приложение)
# valkey — ACL-файл (пароли пользователей)
# s3 (SeaweedFS) — s3_config.json (пользователи и права); s3-init — ключи администратора
# grafana — пароль администратора
# api / worker — НИЧЕГО из этого каталога: свои пароли и ключи они читают из OpenBao
# (make bao-bootstrap переносит их туда), а входят в OpenBao сертификатом.
set -eu
cd "$(dirname "$0")/.."
umask 077 # каталог secrets/ доступен только владельцу
mkdir -p secrets
# 24 случайных байта -> 48 hex-символов. /dev/urandom есть и в Linux/macOS, и в Git Bash.
random_hex() { od -An -tx1 -N24 /dev/urandom | tr -d ' \n'; }
# Файл создаётся, только если его ещё нет (printf без перевода строки: в файле только значение).
make_secret() { [ -e "secrets/$1" ] || printf '%s%s' "$2" "$(random_hex | cut -c1-"$3")" > "secrets/$1"; }
# PostgreSQL: владелец схемы (migrate, оператор) и две роли приложения (с lab7 — раздельные).
make_secret postgres_password "" 48
make_secret db_api_password "" 48
make_secret db_worker_password "" 48
# Valkey: пользователь messenger (API). health — без пароля, только ping/info/dbsize.
make_secret valkey_api_password "" 48
printf '%s\n' \
'user default off' \
'user health on nopass -@all +ping +info +dbsize' \
"user messenger on >$(cat secrets/valkey_api_password) ~sess:* ~rl:* resetchannels -@all +get +mget +set +del +ping +incrby +ttl +multi +exec" \
> secrets/valkey_users.acl
# S3 (SeaweedFS): администратор (только s3-init) и РАЗНЫЕ пользователи для API и worker.
make_secret s3_root_user admin 12
make_secret s3_root_password "" 32
make_secret s3_api_access_key_id api 16
make_secret s3_api_secret_access_key "" 32
make_secret s3_worker_access_key_id wrk 16
make_secret s3_worker_secret_access_key "" 32
# Права по префиксам (с lab7):
# API — пишет только staging/ (принятый файл), читает только originals/ и variants/ (скачивание);
# не может подделать оригинал или вариант и не видит список объектов;
# worker — читает staging/ и originals/, пишет и удаляет в bucket (оригиналы, варианты, уборка),
# видит список (уборщик); не читает variants/ и не управляет bucket.
BUCKET=$(sed -n 's/^S3_BUCKET=//p' .env 2>/dev/null | tr -d '\r')
BUCKET=${BUCKET:-messenger-attachments}
printf '{"identities":[{"name":"admin","credentials":[{"accessKey":"%s","secretKey":"%s"}],"actions":["Admin","Read","List","Tagging","Write"]},{"name":"messenger-api","credentials":[{"accessKey":"%s","secretKey":"%s"}],"actions":["Write:%s/staging/*","Read:%s/originals/*","Read:%s/variants/*"]},{"name":"messenger-worker","credentials":[{"accessKey":"%s","secretKey":"%s"}],"actions":["Read:%s/staging/*","Read:%s/originals/*","Write:%s","List:%s"]}]}\n' \
"$(cat secrets/s3_root_user)" "$(cat secrets/s3_root_password)" \
"$(cat secrets/s3_api_access_key_id)" "$(cat secrets/s3_api_secret_access_key)" "$BUCKET" "$BUCKET" "$BUCKET" \
"$(cat secrets/s3_worker_access_key_id)" "$(cat secrets/s3_worker_secret_access_key)" "$BUCKET" "$BUCKET" "$BUCKET" "$BUCKET" \
> secrets/s3_config.json
# Grafana: пароль администратора (https://127.0.0.1:3000, пользователь admin).
make_secret grafana_admin_password "" 24
# С lab7 у брокера паролей нет: вход по клиентским сертификатам (make pki).
# Файлы читают процессы в контейнерах под своими пользователями (postgres, valkey, seaweedfs, grafana),
# поэтому сами файлы доступны на чтение; посторонних на хосте не пускает каталог (700).
chmod 644 secrets/*.json secrets/*.acl secrets/*_password secrets/*_key_id secrets/*_access_key secrets/s3_root_* 2>/dev/null || true
echo "Готово: secrets/ (PostgreSQL x3, Valkey, S3 admin/API/worker, Grafana; значения не выводятся). Дальше: make pki"
+284
View File
@@ -0,0 +1,284 @@
"""Local PKI of the lab7 stand: one CA, one leaf certificate per service identity, CRL.
Operator tool. Runs in the "pki" container (docker compose --profile tools run --rm pki ...),
writes ONLY into ./secrets (in .gitignore), never prints private keys.
Layout:
secrets/ca/ca.key CA private key: only this tool reads it (never mounted into services)
secrets/ca/state.json issued serials and revoked serials (no secrets inside)
secrets/tls/ca/ca.crt CA certificate: public, mounted into every service as /run/ca/ca.crt
secrets/tls/ca/crl.pem CRL signed by the CA: revoked leaf serials (API checks it for LB identity)
secrets/tls/<id>/tls.crt leaf certificate of identity <id> (CN = SAN DNS = <id>)
secrets/tls/<id>/tls.key its private key (mounted only into the container of that service)
secrets/tls/<id>/tls.pem cert + key in one file (HAProxy format)
secrets/tls-test/... certificates for NEGATIVE tests only: intruder (same CA, unknown identity),
rogue-lb (identity "lb" from a foreign CA), lb-expired (expired "lb")
Commands:
init create CA if missing, issue missing/expiring leaves, test certs, CRL (idempotent)
issue <id> [--days N] re-issue one leaf IN PLACE (rotation; files are overwritten, not replaced,
so bind mounts see the new content). Prints old and new serial.
revoke <id> --serial S add serial S of <id> to the CRL (S from "show" or from "issue" output)
revoke-previous <id> revoke the certificate that "issue" replaced (rotation: issue -> reload -> revoke)
crl re-sign the CRL (it is valid CRL_DAYS days; run before it expires)
show identities, serials, expiry dates
Plain ASCII on purpose (scripts/check_contract.py reads scripts/*.py with the default encoding).
"""
import argparse
import datetime as dt
import ipaddress
import json
import os
import sys
from pathlib import Path
from cryptography import x509
from cryptography.hazmat.primitives import hashes, serialization
from cryptography.hazmat.primitives.asymmetric import ec
from cryptography.x509.oid import ExtendedKeyUsageOID, NameOID
ROOT = Path(os.environ.get("PKI_ROOT", Path(__file__).resolve().parents[1] / "secrets"))
CA_DIR, PUB_DIR, TLS_DIR, TEST_DIR = ROOT / "ca", ROOT / "tls" / "ca", ROOT / "tls", ROOT / "tls-test"
CA_DAYS, LEAF_DAYS, CRL_DAYS, RENEW_BEFORE_DAYS = 365, 30, 30, 7
LOCAL = ["localhost", "127.0.0.1"]
# identity -> extra SAN names. CN = first SAN = identity. All leaves: serverAuth + clientAuth.
IDENTITIES = {
"lb": LOCAL, # external TLS ingress (8443) and mTLS CLIENT of every API replica
"api": [], # mTLS server for LB; client of postgres/s3/valkey/broker/collector/openbao
"worker": [], # client of postgres/s3/broker/collector/openbao
"postgres": LOCAL,
"valkey": LOCAL,
"s3": LOCAL,
"broker": LOCAL,
"otel-collector": LOCAL, # OTLP gateway server; client of prometheus/loki/tempo
"prometheus": LOCAL,
"loki": LOCAL,
"tempo": LOCAL,
"grafana": LOCAL, # HTTPS for the operator; client of prometheus/loki/tempo
"openbao": LOCAL,
}
def now():
return dt.datetime.now(dt.timezone.utc)
def write(path: Path, data: bytes, mode: int = 0o644):
"""Overwrite in place (same inode): containers that bind-mount the directory see the change."""
path.parent.mkdir(parents=True, exist_ok=True)
with open(path, "r+b" if path.exists() else "wb") as fh:
fh.seek(0)
fh.write(data)
fh.truncate()
os.chmod(path, mode)
def pem_key(key) -> bytes:
return key.private_bytes(serialization.Encoding.PEM, serialization.PrivateFormat.PKCS8,
serialization.NoEncryption())
def pem_cert(cert) -> bytes:
return cert.public_bytes(serialization.Encoding.PEM)
def load_state() -> dict:
path = CA_DIR / "state.json"
return json.loads(path.read_text()) if path.exists() else {"issued": {}, "revoked": []}
def save_state(state: dict):
write(CA_DIR / "state.json", json.dumps(state, indent=2, sort_keys=True).encode(), 0o600)
def new_ca(common_name: str):
key = ec.generate_private_key(ec.SECP256R1())
name = x509.Name([x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTUSI lab7"),
x509.NameAttribute(NameOID.COMMON_NAME, common_name)])
cert = (x509.CertificateBuilder().subject_name(name).issuer_name(name).public_key(key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(now() - dt.timedelta(minutes=5)).not_valid_after(now() + dt.timedelta(days=CA_DAYS))
.add_extension(x509.BasicConstraints(ca=True, path_length=0), critical=True)
.add_extension(x509.KeyUsage(digital_signature=False, content_commitment=False, key_encipherment=False,
data_encipherment=False, key_agreement=False, key_cert_sign=True,
crl_sign=True, encipher_only=False, decipher_only=False), critical=True)
.add_extension(x509.SubjectKeyIdentifier.from_public_key(key.public_key()), critical=False)
.sign(key, hashes.SHA256()))
return key, cert
def load_ca():
key = serialization.load_pem_private_key((CA_DIR / "ca.key").read_bytes(), None)
cert = x509.load_pem_x509_certificate((PUB_DIR / "ca.crt").read_bytes())
return key, cert
def leaf(ca_key, ca_cert, identity: str, extra: list, not_before=None, not_after=None):
key = ec.generate_private_key(ec.SECP256R1())
names = []
for value in [identity] + list(extra):
try:
names.append(x509.IPAddress(ipaddress.ip_address(value)))
except ValueError:
names.append(x509.DNSName(value))
not_before = not_before or now() - dt.timedelta(minutes=5)
not_after = not_after or now() + dt.timedelta(days=LEAF_DAYS)
cert = (x509.CertificateBuilder()
.subject_name(x509.Name([x509.NameAttribute(NameOID.ORGANIZATION_NAME, "MTUSI lab7"),
x509.NameAttribute(NameOID.COMMON_NAME, identity)]))
.issuer_name(ca_cert.subject).public_key(key.public_key())
.serial_number(x509.random_serial_number())
.not_valid_before(not_before).not_valid_after(not_after)
.add_extension(x509.BasicConstraints(ca=False, path_length=None), critical=True)
.add_extension(x509.KeyUsage(digital_signature=True, content_commitment=False, key_encipherment=False,
data_encipherment=False, key_agreement=True, key_cert_sign=False,
crl_sign=False, encipher_only=False, decipher_only=False), critical=True)
.add_extension(x509.ExtendedKeyUsage([ExtendedKeyUsageOID.SERVER_AUTH,
ExtendedKeyUsageOID.CLIENT_AUTH]), critical=False)
.add_extension(x509.SubjectAlternativeName(names), critical=False)
.add_extension(x509.AuthorityKeyIdentifier.from_issuer_public_key(ca_key.public_key()), critical=False)
.sign(ca_key, hashes.SHA256()))
return key, cert
def store_leaf(directory: Path, key, cert):
write(directory / "tls.key", pem_key(key))
write(directory / "tls.crt", pem_cert(cert))
write(directory / "tls.pem", pem_cert(cert) + pem_key(key))
def serial_hex(cert) -> str:
return format(cert.serial_number, "X")
def write_crl(ca_key, ca_cert, state):
builder = (x509.CertificateRevocationListBuilder().issuer_name(ca_cert.subject)
.last_update(now() - dt.timedelta(minutes=5)).next_update(now() + dt.timedelta(days=CRL_DAYS)))
for item in state["revoked"]:
builder = builder.add_revoked_certificate(
x509.RevokedCertificateBuilder().serial_number(int(item["serial"], 16))
.revocation_date(dt.datetime.fromisoformat(item["at"])).build())
crl = builder.sign(ca_key, hashes.SHA256())
write(PUB_DIR / "crl.pem", crl.public_bytes(serialization.Encoding.PEM))
return len(state["revoked"])
def issue(identity: str, days: int | None, state: dict, quiet=False) -> str:
ca_key, ca_cert = load_ca()
old = state["issued"].get(identity, {}).get("serial")
not_after = now() + dt.timedelta(days=days) if days else None
key, cert = leaf(ca_key, ca_cert, identity, IDENTITIES[identity], not_after=not_after)
store_leaf(TLS_DIR / identity, key, cert)
state["issued"][identity] = {"serial": serial_hex(cert), "not_after": cert.not_valid_after_utc.isoformat(),
"previous": old}
if not quiet:
print(f"{identity}: issued serial {serial_hex(cert)} (valid until {cert.not_valid_after_utc:%Y-%m-%d %H:%M} UTC)"
+ (f", previous serial {old}" if old else ""))
return serial_hex(cert)
def cmd_init(_args):
os.umask(0o022)
CA_DIR.mkdir(parents=True, exist_ok=True)
os.chmod(CA_DIR, 0o700)
state = load_state()
if not (CA_DIR / "ca.key").exists():
key, cert = new_ca("MTUSI lab7 local CA")
write(CA_DIR / "ca.key", pem_key(key), 0o600)
write(PUB_DIR / "ca.crt", pem_cert(cert))
state = {"issued": {}, "revoked": []}
print("CA created: secrets/tls/ca/ca.crt (public), secrets/ca/ca.key (private, operator only)")
ca_key, ca_cert = load_ca()
for identity in IDENTITIES:
path = TLS_DIR / identity / "tls.crt"
if path.exists():
cert = x509.load_pem_x509_certificate(path.read_bytes())
fresh = cert.not_valid_after_utc - now() > dt.timedelta(days=RENEW_BEFORE_DAYS)
if fresh and cert.issuer == ca_cert.subject:
continue
issue(identity, None, state)
# Negative-test material: never mounted into services.
if not (TEST_DIR / "intruder" / "tls.crt").exists():
store_leaf(TEST_DIR / "intruder", *leaf(ca_key, ca_cert, "intruder", []))
rogue_key, rogue_cert = new_ca("Rogue CA (negative tests)")
write(TEST_DIR / "rogue-ca" / "ca.crt", pem_cert(rogue_cert))
store_leaf(TEST_DIR / "rogue-lb", *leaf(rogue_key, rogue_cert, "lb", LOCAL))
store_leaf(TEST_DIR / "lb-expired", *leaf(ca_key, ca_cert, "lb", LOCAL,
not_before=now() - dt.timedelta(days=2),
not_after=now() - dt.timedelta(days=1)))
print("test certificates: secrets/tls-test/{intruder,rogue-lb,lb-expired,rogue-ca}")
revoked = write_crl(ca_key, ca_cert, state)
save_state(state)
print(f"CRL signed ({revoked} revoked serials, valid {CRL_DAYS} days). Private keys were not printed.")
def cmd_issue(args):
if args.identity not in IDENTITIES:
sys.exit(f"unknown identity {args.identity}; known: {', '.join(IDENTITIES)}")
state = load_state()
issue(args.identity, args.days, state)
save_state(state)
def cmd_revoke(args):
state = load_state()
serial = args.serial.upper().lstrip("0") or "0"
if state["issued"].get(args.identity, {}).get("serial") == serial:
sys.exit("refusing to revoke the CURRENT certificate of this identity: issue a new one first")
if not any(r["serial"] == serial for r in state["revoked"]):
state["revoked"].append({"identity": args.identity, "serial": serial, "at": now().isoformat()})
ca_key, ca_cert = load_ca()
count = write_crl(ca_key, ca_cert, state)
save_state(state)
print(f"revoked {args.identity} serial {serial}; CRL now lists {count} serials")
def cmd_revoke_previous(args):
"""Отозвать ПРЕДЫДУЩИЙ сертификат identity (после того как сервис перешёл на новый)."""
state = load_state()
previous = state["issued"].get(args.identity, {}).get("previous")
if not previous:
sys.exit(f"{args.identity}: no previous certificate recorded (run issue first)")
args.serial = previous
cmd_revoke(args)
def cmd_crl(_args):
state = load_state()
ca_key, ca_cert = load_ca()
print(f"CRL re-signed: {write_crl(ca_key, ca_cert, state)} revoked serials")
def cmd_show(_args):
state = load_state()
for identity, item in sorted(state["issued"].items()):
print(f"{identity:15} serial {item['serial']:>40} until {item['not_after'][:16]}")
for item in state["revoked"]:
print(f"revoked: {item['identity']} {item['serial']} at {item['at'][:19]}")
def main():
parser = argparse.ArgumentParser(description=__doc__.split("\n")[0])
sub = parser.add_subparsers(dest="command", required=True)
sub.add_parser("init").set_defaults(fn=cmd_init)
p = sub.add_parser("issue")
p.add_argument("identity")
p.add_argument("--days", type=int)
p.set_defaults(fn=cmd_issue)
p = sub.add_parser("revoke")
p.add_argument("identity")
p.add_argument("--serial", required=True)
p.set_defaults(fn=cmd_revoke)
p = sub.add_parser("revoke-previous")
p.add_argument("identity")
p.set_defaults(fn=cmd_revoke_previous)
sub.add_parser("crl").set_defaults(fn=cmd_crl)
sub.add_parser("show").set_defaults(fn=cmd_show)
args = parser.parse_args()
args.fn(args)
if __name__ == "__main__":
main()
+11
View File
@@ -0,0 +1,11 @@
@echo off
rem Windows restart hook for make test-persistence: same steps as scripts/restart.sh.
rem Python on Windows cannot run .sh directly (WinError 193), so this .cmd is used instead.
rem Restarts ALL api replicas, the worker and ALL stores (PostgreSQL, Valkey, S3 SeaweedFS, RabbitMQ),
rem then the balancer. Volumes are kept (no down -v, no queue purge). Same containers, new start time.
cd /d "%~dp0.."
docker compose stop api worker || exit /b 1
docker compose restart postgres valkey s3 broker || exit /b 1
docker compose start worker api || exit /b 1
docker compose restart lb || exit /b 1
exit /b 0
+12
View File
@@ -0,0 +1,12 @@
#!/bin/sh
# Restart hook для make test-persistence (Linux/macOS).
# Перезапускает ВСЕ реплики API, worker и ВСЕ используемые хранилища (PostgreSQL, Valkey, S3, RabbitMQ),
# а затем балансировщик. Volumes сохраняются: нет down -v, flush, purge очереди или повторного seed.
# Контейнеры те же (restart/stop/start, не recreate): ID не меняется, меняется время старта.
set -eu
cd "$(dirname "$0")/.."
docker compose stop api worker # API: readiness 503 -> уход из балансировки; worker доделывает задания
docker compose restart postgres valkey s3 broker # корректная остановка (SIGINT/SIGTERM) и запуск тех же контейнеров
docker compose start worker api # ждут PostgreSQL и брокер сами (повторные подключения)
docker compose restart lb # балансировщик заново находит реплики по DNS
+6
View File
@@ -0,0 +1,6 @@
@echo off
rem Failover hook for make test-failover on Windows (same as scripts/stop-one.sh).
rem Python on Windows cannot start .sh files directly (WinError 193), a .cmd file works.
rem Stops ONE api replica from TARGET_INSTANCE_ID; the logic is in scripts\stop_one.py.
python "%~dp0stop_one.py"
exit /b %ERRORLEVEL%
+9
View File
@@ -0,0 +1,9 @@
#!/bin/sh
# Failover hook для make test-failover (Linux/macOS): останавливает ОДНУ реплику API —
# ту, чей X-Instance-Id тест передал в TARGET_INSTANCE_ID, и оставляет её остановленной.
# Логика (проверка значения, поиск контейнера, docker stop) — в scripts/stop_one.py,
# общем для этого скрипта и для scripts/stop-one.cmd (Windows).
# Восстановить реплику после теста: make restore (docker compose up -d --wait).
set -eu
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
exec "${PYTHON:-python3}" "$(dirname "$0")/stop_one.py"
+58
View File
@@ -0,0 +1,58 @@
"""Failover hook logic for tests/resilience.py --mode failover (lab3, updated for lab7).
Called by scripts/stop-one.sh (Linux/macOS) and scripts/stop-one.cmd (Windows).
The test puts X-Instance-Id of the replica that served its first message into
TARGET_INSTANCE_ID. Since lab7 that header is a random per-process alias, not the
container hostname (contracts/README.md: "use an opaque replica alias, no hostname/IP").
Each API process writes its alias into /tmp/instance-id inside its own container
(tmpfs), so the operator -- who already has Docker access -- can map alias to
container, while an API client cannot. This script reads that file in every running
container of the "api" service of this Compose project and stops the matching one.
Postgres, Valkey, S3, the broker, OpenBao, the balancer and volumes are not touched.
The replica stays stopped; restore it with `make restore` or `docker start <id>`.
docker stop sends SIGTERM: the replica first answers 503 on /health/ready for
SHUTDOWN_DRAIN_SECONDS (HAProxy takes it out of rotation), then finishes started
requests and exits. --time 8: SIGKILL after 8 s at most, so the hook always returns
within the 10 s the test allows.
This file is plain ASCII on purpose: scripts/check_contract.py reads every
scripts/*.py with the default encoding, which is cp1251 on a Russian Windows.
"""
import os
import re
import subprocess
import sys
from pathlib import Path
ROOT = Path(__file__).resolve().parents[1]
STOP_TIMEOUT_SECONDS = 8
ALIAS_FILE = os.environ.get("INSTANCE_ID_FILE", "/tmp/instance-id")
def alias_of(container: str) -> str:
result = subprocess.run(["docker", "exec", container, "cat", ALIAS_FILE],
capture_output=True, text=True)
return result.stdout.strip() if result.returncode == 0 else ""
def main() -> int:
target = os.environ.get("TARGET_INSTANCE_ID", "").strip()
# The value comes from an HTTP header: accept only our own alias format.
if not re.fullmatch(r"[A-Za-z0-9_.-]{1,64}", target):
print("TARGET_INSTANCE_ID must be a replica alias (X-Instance-Id)", file=sys.stderr)
return 2
running = subprocess.run(["docker", "compose", "ps", "-q", "api"], cwd=ROOT,
capture_output=True, text=True, check=True).stdout.split()
matches = [container for container in running if alias_of(container) == target]
if len(matches) != 1:
print("no running api container with alias " + target, file=sys.stderr)
return 1
subprocess.run(["docker", "stop", "--time", str(STOP_TIMEOUT_SECONDS), matches[0]],
cwd=ROOT, check=True, stdout=subprocess.DEVNULL)
print("stopped api container " + matches[0][:12])
return 0
if __name__ == "__main__":
sys.exit(main())
+55 -6
View File
@@ -1,19 +1,68 @@
# Модель угроз — заполнить
# Модель угроз — lab7 (решение bvt2303-gadzhiev)
## Активы и акторы
TODO: пользовательские credentials/сессии, сообщения/вложения, service identities, CA/secrets, telemetry. Акторы: участник чата, посторонний пользователь, внешний клиент, скомпрометированный сервис, оператор. Опишите доступ атакующего и границы учебного стенда.
**Активы.** Пароли пользователей (хранятся как Argon2id-hash) и токены сессий (в БД только SHA-256);
сообщения и вложения участников чата; service identities (TLS leaf-сертификаты сервисов) и CA;
секреты приложения (пароли ролей БД, ключи S3, пароль Valkey — в OpenBao); root token и unseal shares
OpenBao; телеметрия (логи, метрики, трассы).
**Акторы.** Участник чата (есть сессия); посторонний зарегистрированный пользователь; внешний клиент
без сессии; **скомпрометированный сервис** (атакующий получил права одного контейнера, например worker);
оператор (есть CA, root token, unseal shares).
**Границы учебного стенда.** Всё на одном хосте Docker; внешний доступ только на `127.0.0.1`. Атакующая
модель: (а) внешний клиент на публичном `:8443`; (б) злоумышленник, попавший во внутреннюю сеть Docker
или получивший права одного сервиса. Вне модели: компрометация хоста/демона Docker и оператора, физический
доступ, стойкость самих TLS-библиотек. Даже «5» здесь — доказанная защита в этой модели, не сертификат.
## Границы доверия
TODO: схема и ссылка на заполненную contracts/trust-matrix.md; публичные/внутренние интерфейсы, процессы, секреты и их выдача.
Публичная граница одна: TLS-ingress `lb` на `127.0.0.1:8443` (+ `:8444` короткий TTL, `:8404` stats, `3000`
Grafana для оператора). Всё остальное — во внутренних сетях Docker (`edge`, `backend`, `otlp`, `telemetry`,
`vault`; все `internal`). Внутри каждая связь аутентифицирована и зашифрована по
[`contracts/trust-matrix.md`](../contracts/trust-matrix.md): plaintext-каналов без границы нет, доверенный
CA не даёт прав сам по себе (везде проверяется ещё и разрешённая identity). Секреты выдаёт OpenBao по
сертификату сервиса; первый секрет сервиса — его TLS-ключ, смонтированный только в его контейнер.
| Угроза и конкретный путь | Нарушаемый инвариант | Контроль | Отрицательный тест | Остаточное ограничение |
| --- | --- | --- | --- | --- |
| TODO | TODO | TODO | TODO | TODO |
| Сетевой перехватчик между `lb` и репликой читает/подменяет трафик с Bearer-токенами и сообщениями | Конфиденциальность и целостность внутреннего трафика | Обязательное mTLS LB→API (TLS 1.2+), шифрование + взаимная аутентификация | `tls_matrix.py` lb_to_api: plaintext `:8080` закрыт, без TLS соединения нет | Внутри TLS-сессии трафик виден самим сервисам; хост доверенный |
| Контейнер во внутренней сети выдаёт себя за балансировщик и шлёт запросы в API в обход сессий | Только `lb` обращается к бизнес-API | mTLS + allowlist `TLS_ALLOWED_CLIENTS=lb`: даже валидный сертификат нашего CA с другим CN отклоняется (`tlsserver.py`, `connection_made`) | `tls_matrix.py`: `intruder` и `worker` (наш CA) → отказ; `lb` → 200 | Компрометация самого ключа `lb` не покрывается (тогда — ротация + CRL) |
| Украдена база: атакующий перебирает пароли по hash offline | Стойкость хранения паролей | Argon2id m=19 МиБ, t=2, p=1 (замер — ниже), соль и параметры в строке hash; rehash старых при входе | `make argon2-bench` (стоимость); `test_limits.py` (rehash) | Offline-перебор слабых паролей всё равно возможен; политики сложности пароля нет |
| Поток входов с перебором пароля или дорогими Argon2-проверками кладёт реплику (login DoS) | Доступность входа и остального API | Лимит частоты входа (429 + Retry-After), общий для реплик через Valkey; бюджет одновременных Argon2 (`ARGON2_MAX_CONCURRENCY`, иначе 503) | `test_limits.py`: 429 после порога через разные реплики, верный пароль тоже 429 | Распределённый перебор с многих адресов смягчается слабее (лимит по username всё же срабатывает) |
| Скомпрометированный worker пытается читать переписку, пароли или чужие объекты S3 | Наименьшие привилегии сервиса | Роль `messenger_worker` в БД не видит users/sessions/messages; ключи S3 worker — только `staging/`+`originals/` R и bucket W/List; политика OpenBao worker читает только свой путь | `acl_matrix.py`: worker DENY на users/sessions, DENY read `variants/`, DENY чужой путь OpenBao | Worker всё же может писать объекты (обработка) — ограничено префиксом, не удалением bucket |
| Скомпрометированный сервис с валидным сертификатом нашего CA ходит к брокеру/Collector под чужой ролью | Identity ≠ «любой клиент нашего CA» | Брокер: пользователь = CN, права на уровне exchange/очереди; Collector: шлюз с allowlist CN `api`,`worker` | `tls_matrix.py`: worker не публикует (403), api не читает очередь (403); `lb`/`intruder` в Collector → 403 | — |
| Поддельный `X-User-Id` или чужой attachment_id: посторонний читает/прикрепляет чужое | Авторизация на уровне объекта | Identity только из Bearer-сессии; членство в чате и владение вложением проверяются в БД (с lab4) | `test_api.py`, `test_attachments.py` (посторонний → 404), `acl_matrix.py` | — |
| Секрет (пароль БД, ключ) утёк в Git, образ, лог или телеметрию | Секреты не покидают доверенную выдачу | Секреты только в `secrets/` (gitignore) и OpenBao; в образе и `.env` их нет; Collector удаляет `authorization`, `cookie`, `x-vault-token`, query; скрипты не печатают значений | `check_stack.py` (у api/worker нет secret-файлов и token-переменных); `check_telemetry.py` (нет запретных labels) | Значение секрета в памяти работающего процесса не защищается |
| Истёкший/отозванный токен или сертификат продолжает действовать | Своевременный отзыв доступа | Токены OpenBao 15 мин + re-auth; CRL перечитывается репликами за `TLS_CRL_CHECK_SECONDS`; ротация leaf без простоя | `make bao-revoke-tokens`, `make bao-token-ttl`, `make rotate-lb-cert`; REPORT.md «Эксперименты» | keep-alive соединение живёт до закрытия (≤ 5 c, `timeout http-keep-alive`) |
| Большой запрос (тело/загрузка) исчерпывает память/CPU | Доступность под нагрузкой запросов | `lb` режет тело > 10 МиБ (413); API: JSON > `MAX_JSON_BODY_BYTES` → 413, загрузка потоково > 10 МиБ → 413; worker в cgroup-лимите, попытка в RLIMIT_AS + таймаут | `test_attachments.py` (413 по CL и chunked), `test_limits.py` | — |
На 4 минимум 6 конкретных угроз. Не заменяйте сценарии словами «SQL injection», «безопасный Docker», «mTLS включён» без пути и проверки.
(6 угроз минимум для уровня 4 — здесь 9.)
## Lifecycle и инциденты
TODO: bootstrap, expiry/renewal, revoke/rotation, компрометация identity, sealed OpenBao и восстановление. Указать владельца CA/unseal и способ защиты bootstrap credentials. Сопоставить scan findings с реальной применимостью и исправлением/остаточным риском.
**Bootstrap.** `make secrets pki` создаёт пароли, CA и сертификаты локально. `make bao-init` — 3 unseal
shares (порог 2) и root token в `secrets/operator/` (600). `make bao-unseal`, `make bao-bootstrap` — политики,
роли cert-auth и секреты приложения в KV. Владелец CA и unseal — оператор; bootstrap-credentials защищены
правами файлов и `.gitignore`.
**Expiry/renewal.** Сертификаты 30 дней (`make pki` переиздаёт истекающие). Токены OpenBao 15 мин с renew
до 1 ч, затем вход заново по сертификату (`secretsource.py`). Пароль роли БД перечитывается за
`BAO_REFRESH_SECONDS`.
**Rotation/revoke.** `make rotate-db-secret` (пароль БД: ALTER ROLE + новая версия KV, пул пересоздаётся),
`make rotate-lb-cert` (leaf lb без пересборки, старый → CRL), `make bao-revoke-tokens` (отзыв всех токенов
cert-auth). Отзыв identity — удаление роли cert-auth или нового сертификата + старый серийник в CRL.
**Компрометация identity.** Трек 5 (если заявлен) — изолированный сценарий получения прав worker:
что доступно и что запрещено, отзыв identity, ротация secret, восстановление обработки. В этом решении
трек 5 не заявлен; `acl_matrix.py` показывает границы прав worker в работающем стенде.
**Sealed OpenBao / рестарт.** После рестарта OpenBao запечатан. Работающие API и worker продолжают на
секретах в памяти; новые процессы без OpenBao не стартуют (fail closed). Восстановление — `make bao-unseal`
(данные KV, политики, роли на месте). Детали и наблюдения — REPORT.md.
**Scan triage.** `make scan-deps` (pip-audit) и `make scan-images` (Trivy). Разбор применимости findings —
REPORT.md, раздел «Эксперименты и отказы»: по каждому CVE указано, достижим ли путь в нашем контексте
и что сделано (обновление, обход в коде или остаточный риск с обоснованием).
+1
View File
@@ -0,0 +1 @@
"""Учебный мессенджер МТУСИ: REST API по contracts/openapi.json, данные в PostgreSQL."""
+74
View File
@@ -0,0 +1,74 @@
"""Точка входа: `python -m messenger`.
В контейнере этот процесс — главный (PID 1) и сам получает SIGTERM от `docker stop`.
С lab3 остановка идёт в два шага, чтобы балансировщик успел увести трафик:
1. SIGTERM -> флаг draining: /health/ready сразу отвечает 503, но запросы ещё обслуживаются.
HAProxy видит 503 (проверка раз в 1 с, 2 неудачи подряд) и перестаёт слать сюда запросы.
2. Через SHUTDOWN_DRAIN_SECONDS — обычная остановка uvicorn: закрыть приём соединений,
доделать начатые запросы (не дольше GRACEFUL_SHUTDOWN_SECONDS) и выйти.
Без шага 1 запрос, пришедший в момент остановки, получил бы от балансировщика 502.
Повторный сигнал останавливает процесс сразу, без ожидания.
С lab6 до запуска сервера включается телеметрия (telemetry.py).
С lab7 порядок запуска такой:
1. телеметрия (OTLP по mTLS в Collector);
2. секреты из OpenBao по сертификату identity api (secretsource.py) — ДО создания клиентов БД,
Valkey и S3; без OpenBao процесс не стартует;
3. alias реплики пишется в /tmp/instance-id (его читает только оператор, scripts/stop_one.py);
4. uvicorn слушает HTTPS с обязательным клиентским сертификатом и проверкой identity (tlsserver.py),
а healthcheck Docker — на 127.0.0.1 контейнера (healthcheck.py).
"""
import logging
import threading
import uvicorn
from . import config, healthcheck, secretsource, telemetry, tlsserver
log = logging.getLogger("messenger")
def main():
telemetry.setup("messenger-api")
secretsource.load()
config.write_instance_id()
from .api import app, draining, readiness # после секретов: модуль создаёт клиентов при импорте
class DrainingServer(uvicorn.Server):
def handle_exit(self, sig, frame):
if draining.is_set() or config.SHUTDOWN_DRAIN_SECONDS == 0:
return super().handle_exit(sig, frame)
draining.set()
log.info("Сигнал %s: /health/ready -> 503, ухожу из балансировки, остановка через %s с",
sig, config.SHUTDOWN_DRAIN_SECONDS, extra={"event": "api.draining"})
# Таймер в отдельном потоке: обработчик сигнала должен вернуться сразу.
threading.Timer(config.SHUTDOWN_DRAIN_SECONDS, super().handle_exit, (sig, frame)).start()
telemetry.instrument_fastapi(app)
server_config = uvicorn.Config(
app,
host=config.APP_HOST,
port=config.APP_PORT,
http=tlsserver.IdentityCheckedH11Protocol, # проверка identity клиента после рукопожатия
access_log=False, # строку на каждый запрос пишет наш middleware (без тел и query)
timeout_graceful_shutdown=config.GRACEFUL_SHUTDOWN_SECONDS,
# Соединение от HAProxy держим дольше, чем HAProxy держит свои простаивающие соединения:
# тогда закрывает их HAProxy, и запрос не попадёт в соединение, которое закрывает API.
timeout_keep_alive=65,
log_config=None, # логи uvicorn идут через наш JSON-формат (telemetry.setup_logging)
proxy_headers=False, # X-Forwarded-For читаем сами (api.client_address), только от LB
)
server_config.load()
server_config.ssl = tlsserver.setup() # свой SSLContext: только наш CA, клиент обязателен
healthcheck.start(config.APP_HEALTH_PORT, readiness)
log.info("HTTPS + mTLS на порту %s, разрешённые клиенты: %s; alias реплики %s",
config.APP_PORT, ",".join(sorted(config.TLS_ALLOWED_CLIENTS)), config.INSTANCE_ID,
extra={"event": "api.tls"})
DrainingServer(server_config).run()
telemetry.shutdown()
if __name__ == "__main__":
main()
+529
View File
@@ -0,0 +1,529 @@
"""HTTP-слой: маршруты из contracts/openapi.json, проверка входных данных, единый формат ошибок.
Здесь нет правил предметной области (кто может писать в чат и т.п.) — они в store.py.
Что изменилось с lab2:
- в каждом ответе заголовок X-Instance-Id: какая реплика API обслужила запрос;
- POST сообщения требует Idempotency-Key: повтор того же запроса не создаёт второе сообщение;
- миграции больше не применяются при старте: их применяет отдельный сервис migrate,
а реплика только ждёт актуальную схему (db.wait_for_schema);
- по SIGTERM /health/ready сразу отвечает 503 (флаг draining, см. __main__.py).
В памяти процесса нет ничего, от чего зависит правильность ответа: данные и сессии —
в PostgreSQL, кэш сессий — в общем Valkey. Поэтому любой запрос может обслужить любая реплика.
Что добавилось в lab4:
- вложения: POST /chats/{id}/attachments (сырые байты PNG/JPEG), GET /attachments/{id}
и /content. Байты — в приватном S3 (objects.py), метаданные — в PostgreSQL (store.py),
на диске реплики оригинала нет;
- в сообщении поле attachment_ids; текст может быть пустым, если есть вложение;
- фоновый уборщик незавершённых загрузок (cleanup.py).
Что изменилось в lab5:
- POST вложения отвечает 202 queued: оригинал в staging S3, задание и outbox в PostgreSQL
(attachments.py). Картинку обрабатывает отдельный процесс worker (worker.py);
- в каждой реплике фоновый relay отправляет outbox в брокер (relay.py);
- GET вложения показывает любое состояние (queued/processing/ready/failed), варианты и error_code;
/content отвечает 409, пока вложение не готово, и умеет variant=thumbnail|crop|optimized;
- /health/ready проверяет и S3: без него не принять файл в staging (обязательный путь).
Брокер в readiness не входит: благодаря outbox его недоступность не мешает приёму;
- уборщик объектов S3 переехал в worker.
Что изменилось в lab7 (безопасность):
- реплика слушает только HTTPS с обязательным клиентским сертификатом балансировщика
(tlsserver.py, __main__.py); healthcheck Docker — отдельный слушатель на 127.0.0.1 контейнера;
- X-Instance-Id — случайный alias процесса, а не hostname контейнера;
- вход и регистрация ограничены по частоте (ratelimit.py, 429 + Retry-After), проверки пароля —
по числу одновременных (security.py, 503 + Retry-After); hash со старыми параметрами пересчитывается;
- тело JSON-запроса не больше MAX_JSON_BODY_BYTES (413), загрузка вложения — как раньше, 10 МиБ;
- пароли роли БД, ключи S3 и пароль Valkey приходят из OpenBao (secretsource.py), не из файлов.
Что добавилось в lab6 (наблюдаемость, telemetry.py):
- каждый HTTP-запрос — server span (инструментация FastAPI, __main__.py) и точка в гистограмме
http.server.request.duration (метод, маршрут-шаблон, код ответа); /health/* не учитывается;
- строка лога на запрос — структурная (JSON в stdout и OTLP-лог): event=http.request, маршрут-шаблон,
код, длительность, request_id, а trace_id/span_id добавляются автоматически. X-Request-Id ответа
записан и в span (messenger.request_id), и в лог — по нему HTTP-ошибка находится в логах и трассах;
- у загрузки в span записан attachment_id, а в строку outbox — traceparent этого span (jobs.enqueue):
по нему relay и worker продолжают ту же трассу (upload -> publish -> consume -> S3/DB);
- метрики очереди и outbox (queuestats.py) и пула соединений с БД.
"""
import hashlib
import json
import logging
import threading
import time
import uuid
from contextlib import asynccontextmanager
from dataclasses import asdict
from typing import Annotated
from fastapi import BackgroundTasks, Depends, FastAPI, Header, Query, Request, Response
from fastapi.exceptions import RequestValidationError
from fastapi.responses import JSONResponse, StreamingResponse
from pydantic import AfterValidator, BaseModel, ConfigDict, Field, model_validator
from starlette.concurrency import run_in_threadpool
from starlette.exceptions import HTTPException as StarletteHTTPException
from opentelemetry import trace
from . import attachments, config, db, faults, images, objects, secretsource, security, telemetry
from .queuestats import QueueStats
from .cursor import decode_cursor, encode_cursor
from .errors import AppError, InvalidRequest, PayloadTooLarge, Unauthorized, Unavailable
from .ratelimit import RateLimiter
from .relay import OutboxRelay
from .sessions import AuthContext, SessionCache, Sessions
from .store import VARIANT_ORDER, PostgresStore, User, sort_key
log = logging.getLogger("messenger")
# Один набор объектов на процесс. Пул соединений открывается при старте (lifespan).
pool = db.create_pool()
store = PostgresStore(pool)
cache = SessionCache(config.CACHE_URL)
sessions = Sessions(store, cache, config.SESSION_TTL_SECONDS)
limiter = RateLimiter(cache) # лимиты входа и регистрации, общие для реплик (с lab7)
secretsource.on_change(db.drain_pools) # ротация пароля БД -> новые соединения с новым паролем
relay = OutboxRelay() # outbox -> брокер (с lab5)
queue_stats = QueueStats() # метрики очереди заданий и outbox (с lab6)
# Выставляется по SIGTERM (__main__.py): реплика уходит из балансировки, но ещё отвечает.
draining = threading.Event()
monitors_stop = threading.Event() # остановка фоновой проверки S3
@asynccontextmanager
async def lifespan(_app: FastAPI):
config.validate()
config.validate_s3()
config.validate_broker()
await run_in_threadpool(db.wait_for_schema) # миграции применяет сервис migrate, мы только ждём
pool.open()
cache.start_monitor() # фоновая проверка Valkey раз в CACHE_CHECK_INTERVAL_SECONDS
objects.start_monitor(monitors_stop) # фоновая проверка S3 для /health/ready (с lab5)
relay.start() # отправка outbox в брокер (с lab5)
telemetry.observe_pool(pool, "messenger-api") # метрики пула соединений (с lab6)
queue_stats.start() # метрики очереди и outbox (с lab6)
log.info("Реплика %s запущена: версия %s, env=%s, TTL сессии=%s c, кэш сессий: %s",
config.INSTANCE_ID, config.APP_VERSION, config.APP_ENV, config.SESSION_TTL_SECONDS,
"Valkey" if cache.enabled else "выключен", extra={"event": "api.started"})
yield
queue_stats.stop()
relay.stop() # строки, которые не успели отправить, остаются в outbox
monitors_stop.set()
pool.close() # аккуратно закрываем соединения с БД при остановке
log.info("Реплика %s остановлена: соединения с PostgreSQL закрыты, данные остаются в базе",
config.INSTANCE_ID, extra={"event": "api.stopped"})
app = FastAPI(title="MTUSI Messenger, lab7", lifespan=lifespan,
docs_url=None, redoc_url=None, openapi_url=None) # лишних публичных маршрутов нет
# ---------- ошибки и служебная обёртка каждого запроса ----------
def error_response(request: Request, status: int, code: str, message: str,
headers: dict[str, str] | None = None) -> JSONResponse:
body = {"error": {"code": code, "message": message, "request_id": request.state.request_id}}
return JSONResponse(body, status_code=status, headers=headers)
# Эти два адреса доступны без токена. Всё остальное под /api/ требует Bearer.
PUBLIC_ENDPOINTS = {("POST", "/api/v1/users"), ("POST", "/api/v1/auth/sessions")}
def needs_bearer(request: Request) -> bool:
# С lab7 — путь из scope (по нему же идёт маршрутизация), а не request.url: request.url
# пересобирается из Host и пути (CVE-2026-54282 / CVE-2026-48710 в starlette 0.46, REPORT.md,
# разбор скана). Так «нужен ли токен» и «какой обработчик» решаются по одной и той же строке.
path = request.scope["path"]
return path.startswith("/api/") and (request.method, path) not in PUBLIC_ENDPOINTS
def authenticate(authorization: str | None) -> AuthContext:
"""Bearer-токен -> пользователь. Любая проблема с токеном -> 401 с WWW-Authenticate: Bearer."""
token = security.parse_bearer(authorization)
auth = sessions.authenticate(token) if token else None
if auth is None:
raise Unauthorized("Нужен действующий Bearer-токен сессии")
return auth
@app.middleware("http")
async def request_context(request: Request, call_next):
"""Выполняется вокруг каждого запроса: X-Request-Id, X-Instance-Id, аутентификация, лог.
Аутентификация стоит здесь, а не в обработчике: она выполняется ДО разбора тела
и поиска чата. Так соблюдается порядок из контракта: сначала «кто ты» (401),
потом «можно ли тебе этот объект» (404) и «правильный ли запрос» (400).
"""
request.state.request_id = uuid.uuid4().hex
started = time.perf_counter()
oversized = json_body_limited(request) and _declared_length(request) > config.MAX_JSON_BODY_BYTES
# Server span создан инструментацией FastAPI снаружи этого middleware (для /health/* его нет).
span = trace.get_current_span()
span.set_attribute("messenger.request_id", request.state.request_id)
try:
if oversized:
# С lab7: большое тело отклоняется по Content-Length до чтения и до проверки токена.
raise PayloadTooLarge(f"Тело запроса больше {config.MAX_JSON_BODY_BYTES} байт")
if needs_bearer(request):
# Проверка токена ходит в Valkey/PostgreSQL (блокирующий код) — выполняем в пуле потоков.
request.state.auth = await run_in_threadpool(authenticate, request.headers.get("Authorization"))
response = await call_next(request)
except AppError as exc: # 401 от аутентификации или 503, если хранилище недоступно
response = error_response(request, exc.status, exc.code, exc.message, exc.headers)
except Exception:
# Подробности (stack trace) — только в лог сервера, клиенту — общий ответ 500.
log.exception("Необработанная ошибка, request_id=%s", request.state.request_id,
extra={"event": "http.unhandled_error", "request_id": request.state.request_id})
response = error_response(request, 500, "internal_error", "Внутренняя ошибка сервера")
response.headers["X-Request-Id"] = request.state.request_id
# С lab3: в каждом ответе (и в ошибках, и в health) — какая реплика его создала.
response.headers["X-Instance-Id"] = config.INSTANCE_ID
# В лог не пишем тела, query-параметры, заголовки и даже сам путь (в нём ID чатов):
# только маршрут-шаблон. Успешные проверки /health/* балансировщика (2 в секунду) не пишем.
route = getattr(request.scope.get("route"), "path", None) or "unmatched"
if not (route.startswith("/health/") and response.status_code == 200):
duration_ms = round((time.perf_counter() - started) * 1000, 1)
log.log(logging.WARNING if response.status_code >= 500 else logging.INFO,
"%s %s -> %d (%.1f ms) request_id=%s", request.method, route, response.status_code,
duration_ms, request.state.request_id,
extra={"event": "http.request", "http.request.method": request.method, "http.route": route,
"http.response.status_code": response.status_code, "duration_ms": duration_ms,
"request_id": request.state.request_id})
return response
def json_body_limited(request_or_scope) -> bool:
"""Все запросы с телом, кроме загрузки вложения (у неё свой потоковый лимит MAX_UPLOAD_BYTES)."""
scope = getattr(request_or_scope, "scope", request_or_scope)
return scope["method"] in ("POST", "PUT", "PATCH", "DELETE") and not scope["path"].endswith("/attachments")
def _declared_length(request: Request) -> int:
try:
return int(request.headers.get("content-length") or 0)
except ValueError:
return 0
class BodyLimit:
"""Тело JSON-запроса читается заранее, но не больше MAX_JSON_BODY_BYTES + 1 байт.
Так ловится и тело без Content-Length (chunked): больше лимита -> 413 в формате контракта,
приложение такой запрос не видит. Внутри FastAPI исключение из receive превратилось бы в 400
(его оборачивает группа задач middleware), поэтому ответ отправляется прямо отсюда.
Загрузка вложения сюда не попадает: у неё свой потоковый лимит MAX_UPLOAD_BYTES (attachments.py).
"""
def __init__(self, inner):
self.inner = inner
async def __call__(self, scope, receive, send):
if scope["type"] != "http" or not json_body_limited(scope):
return await self.inner(scope, receive, send)
messages, size = [], 0
while True:
message = await receive()
messages.append(message)
if message["type"] != "http.request":
break
size += len(message.get("body", b""))
if size > config.MAX_JSON_BODY_BYTES:
request_id = uuid.uuid4().hex
body = json.dumps({"error": {"code": "payload_too_large", "request_id": request_id,
"message": f"Тело запроса больше {config.MAX_JSON_BODY_BYTES} байт"}},
ensure_ascii=False).encode()
await send({"type": "http.response.start", "status": 413, "headers": [
(b"content-type", b"application/json"), (b"content-length", str(len(body)).encode()),
(b"x-request-id", request_id.encode()), (b"x-instance-id", config.INSTANCE_ID.encode()),
(b"connection", b"close")]})
await send({"type": "http.response.body", "body": body})
return
if not message.get("more_body"):
break
replay = iter(messages)
async def buffered_receive():
return next(replay, None) or await receive()
return await self.inner(scope, buffered_receive, send)
def client_address(request: Request) -> str:
"""Адрес клиента: X-Forwarded-For ставит (перезаписывает) HAProxy, к реплике ходит только он."""
forwarded = request.headers.get("x-forwarded-for", "")
return forwarded.split(",")[-1].strip() or (request.client.host if request.client else "unknown")
@app.exception_handler(AppError)
async def handle_app_error(request: Request, exc: AppError):
return error_response(request, exc.status, exc.code, exc.message, exc.headers)
@app.exception_handler(RequestValidationError)
async def handle_validation_error(request: Request, exc: RequestValidationError):
# FastAPI по умолчанию отвечает 422 со своим форматом; контракт требует 400 и наш формат.
# Детали pydantic клиенту не отдаём: в них может быть эхо входных данных (например, пароль).
first = exc.errors()[0]
if first["type"] == "json_invalid":
message = "Тело запроса не является корректным JSON"
else:
message = "Неверное значение: " + ".".join(str(part) for part in first["loc"])
return error_response(request, 400, "invalid_request", message)
@app.exception_handler(StarletteHTTPException)
async def handle_http_error(request: Request, exc: StarletteHTTPException):
# Ошибки, которые создаёт сам фреймворк: неизвестный путь (404), не тот метод (405) и т.п.
if exc.status_code == 404:
return error_response(request, 404, "not_found", "Ресурс не найден")
if exc.status_code == 413:
return error_response(request, 413, "payload_too_large", f"Тело запроса больше {config.MAX_JSON_BODY_BYTES} байт")
return error_response(request, exc.status_code, "invalid_request", "Запрос не может быть обработан")
# ---------- входные данные (схемы из contracts/openapi.json) ----------
def _not_blank(value: str) -> str:
if not value.strip():
raise ValueError("строка состоит только из пробелов")
return value
# Длины в символах Unicode (code points): len("👋") == 1 в Python.
Name = Annotated[str, Field(min_length=1, max_length=100), AfterValidator(_not_blank)]
Text = Annotated[str, Field(min_length=1, max_length=4000), AfterValidator(_not_blank)]
Password = Annotated[str, Field(min_length=security.PASSWORD_MIN, max_length=security.PASSWORD_MAX),
AfterValidator(_not_blank)]
class StrictModel(BaseModel):
model_config = ConfigDict(extra="forbid") # лишние поля в JSON -> 400
class CreateUser(StrictModel):
username: Annotated[str, Field(pattern=r"^[a-z0-9_]{3,32}$")]
display_name: Name
password: Password
class CreateChat(StrictModel):
title: Name
member_ids: Annotated[list[uuid.UUID], Field(min_length=1, max_length=100)]
class CreateMessage(StrictModel):
# Поля sender_id нет: прислать его = лишнее поле = 400.
# С lab4 текст может быть пустым, но только если есть хотя бы одно вложение.
text: Annotated[str, Field(max_length=4000)]
# Отсутствующий attachment_ids равен []: model_dump даёт одинаковый отпечаток для повтора.
attachment_ids: Annotated[list[uuid.UUID], Field(max_length=10)] = []
@model_validator(mode="after")
def text_or_attachments(self):
if len(set(self.attachment_ids)) != len(self.attachment_ids):
raise ValueError("attachment_ids повторяются")
if not self.attachment_ids and not self.text.strip():
raise ValueError("нужен непустой текст или хотя бы одно вложение")
return self
# Ключ идемпотентности (с lab3): ASCII [A-Za-z0-9._:-], 1–128 символов. Нет или неверный -> 400.
IdempotencyKey = Annotated[str, Header(alias="Idempotency-Key", min_length=1, max_length=128,
pattern=r"^[A-Za-z0-9._:-]+$")]
def request_fingerprint(body: BaseModel) -> bytes:
"""SHA-256 «смысла» запроса: тело после разбора, ключи по алфавиту, без лишних пробелов.
Поэтому порядок полей и форматирование JSON не важны: {"text":"a"} и { "text" : "a" }
дают одинаковый отпечаток. Сравнивается при повторе с тем же Idempotency-Key.
"""
canonical = json.dumps(body.model_dump(mode="json"), sort_keys=True, ensure_ascii=False,
separators=(",", ":"))
return hashlib.sha256(canonical.encode("utf-8")).digest()
# ---------- текущий пользователь ----------
def current_auth(request: Request) -> AuthContext:
"""Сессия, которую middleware уже проверил для этого запроса."""
auth = getattr(request.state, "auth", None)
if auth is None: # защита от ошибки в PUBLIC_ENDPOINTS: без проверки токена доступа нет
raise Unauthorized("Нужен действующий Bearer-токен сессии")
return auth
def current_user(auth: Annotated[AuthContext, Depends(current_auth)]) -> User:
return auth.user
CurrentAuth = Annotated[AuthContext, Depends(current_auth)]
CurrentUser = Annotated[User, Depends(current_user)]
Limit = Annotated[int, Query(ge=1, le=100)]
Cursor = Annotated[str | None, Query(min_length=1)]
def page_response(scope: str, items: list, has_more: bool) -> dict:
next_cursor = encode_cursor(scope, sort_key(items[-1])) if has_more else None
return {"items": [asdict(item) for item in items], "next_cursor": next_cursor}
# ---------- маршруты ----------
# Обработчики объявлены через def (не async def): FastAPI запускает их в пуле потоков,
# поэтому запросы обрабатываются параллельно. Согласованность данных обеспечивает
# PostgreSQL (транзакции и ограничения), а не замок в памяти процесса.
@app.get("/health/live")
def health_live():
return {"status": "ok"} # процесс жив; от зависимостей не зависит
def readiness() -> bool:
"""То же, что /health/ready, для внутреннего healthcheck-слушателя (healthcheck.py)."""
try:
health_ready()
return True
except AppError:
return False
@app.get("/health/ready")
def health_ready():
# Готовность = можно обслужить обязательный синхронный путь. Критичны:
# - PostgreSQL (всё, что API хранит, и outbox);
# - S3 (с lab5): без него нельзя принять файл в staging, а без staging нельзя честно ответить 202.
# Не критичны: Valkey (без кэша сессий API работает через PostgreSQL) и брокер
# (задания копятся в outbox и уйдут в брокер, когда он вернётся), worker (задания ждут в очереди).
if draining.is_set():
# Получен SIGTERM: просим балансировщик больше не присылать запросы (см. __main__.py).
raise Unavailable("Реплика останавливается")
store.ping() # если БД недоступна -> Unavailable -> 503 в общем формате ошибки
if not objects.healthy():
raise Unavailable("Хранилище файлов недоступно")
return {"status": "ok"}
@app.post("/api/v1/users", status_code=201)
def register_user(request: Request, body: CreateUser):
limiter.check_register(client_address(request)) # до Argon2id: отказ почти бесплатный
password_hash = security.hash_password(body.password) # сам пароль нигде не сохраняется
return asdict(store.create_user(body.username, body.display_name, password_hash))
@app.post("/api/v1/auth/sessions", status_code=201)
def create_session(request: Request, response: Response, authorization: Annotated[str | None, Header()] = None):
credentials = security.parse_basic(authorization)
username = credentials[0] if credentials and security.USERNAME_RE.fullmatch(credentials[0]) else None
limiter.check_login(client_address(request), username) # 429 до дорогой проверки пароля
result = sessions.login(*credentials) if credentials else None
if result is None:
limiter.login_failed(username)
# Один и тот же ответ для «нет такого пользователя», «неверный пароль» и «кривой заголовок».
raise Unauthorized("Неверное имя пользователя или пароль", Unauthorized.BASIC)
token, expires_at, user = result
limiter.login_succeeded(username)
response.headers["Cache-Control"] = "no-store" # ответ с токеном нельзя кэшировать
return {"token": token, "token_type": "Bearer", "expires_at": expires_at, "user": asdict(user)}
@app.delete("/api/v1/auth/sessions/current", status_code=204)
def revoke_session(auth: CurrentAuth):
sessions.logout(auth)
return Response(status_code=204)
@app.get("/api/v1/users/me")
def get_me(user: CurrentUser):
return asdict(user)
@app.post("/api/v1/chats", status_code=201)
def create_chat(body: CreateChat, user: CurrentUser):
member_ids = [str(member_id) for member_id in body.member_ids]
return asdict(store.create_chat(user.id, body.title, member_ids))
@app.get("/api/v1/chats")
def list_chats(user: CurrentUser, limit: Limit = 50, cursor: Cursor = None):
scope = f"chats:{user.id}"
items, has_more = store.list_chats(user.id, decode_cursor(scope, cursor), limit)
return page_response(scope, items, has_more)
@app.get("/api/v1/chats/{chat_id}")
def get_chat(chat_id: uuid.UUID, user: CurrentUser):
return asdict(store.get_chat(user.id, str(chat_id)))
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
def send_message(chat_id: uuid.UUID, body: CreateMessage, user: CurrentUser,
idempotency_key: IdempotencyKey):
# Учебная точка отказа (lab6, инцидент 2): медленный обработчик при здоровой БД.
# Отдельного span нет намеренно: в трассе это «пустое» время server span без дочерних SQL-спанов.
time.sleep(faults.number("api_slow_handler"))
# Область ключа из контракта: пользователь + метод + путь чата + ключ.
# Метод и путь у этого обработчика всегда одни, поэтому в БД ключ уникален в паре (чат, отправитель).
message, replayed = store.add_message(user.id, str(chat_id), body.text,
idempotency_key, request_fingerprint(body),
tuple(str(a) for a in body.attachment_ids))
if replayed:
log.info("Повтор с тем же Idempotency-Key: возвращаю уже сохранённое сообщение %s", message.id,
extra={"event": "message.idempotent_replay"})
return asdict(message)
@app.get("/api/v1/chats/{chat_id}/messages")
def list_messages(chat_id: uuid.UUID, user: CurrentUser, limit: Limit = 50, cursor: Cursor = None):
scope = f"messages:{chat_id}"
items, has_more = store.list_messages(user.id, str(chat_id), decode_cursor(scope, cursor), limit)
return page_response(scope, items, has_more)
# ---------- вложения (с lab4; с lab5 — асинхронная обработка) ----------
@app.post("/api/v1/chats/{chat_id}/attachments", status_code=202)
async def upload_attachment(request: Request, chat_id: uuid.UUID, user: CurrentUser, background: BackgroundTasks,
filename: Annotated[str | None, Query()] = None):
# async: тело читается потоком (attachments.receive_body), а блокирующие шаги
# (проверка структуры, S3, БД) идут в пуле потоков. Дешёвые проверки — до чтения тела.
# 202 = файл принят на обработку (staging + задание сохранены), а не «готов».
chat = str(chat_id)
await run_in_threadpool(store.get_chat, user.id, chat) # посторонний -> 404, тело не читаем
name = images.check_filename(filename) # 400
declared = images.declared_type(request.headers.get("Content-Type")) # 415
attachments.check_content_length(request.headers.get("Content-Length")) # 413 до чтения тела
attachment = await attachments.upload(request, store, user.id, chat, name, declared)
# По attachment_id трасса загрузки находится в Tempo (технический ID синтетических данных, не label метрик).
trace.get_current_span().set_attribute("messenger.attachment.id", attachment.id)
# Разбудить relay ПОСЛЕ отправки ответа: задание уже в outbox, отправка в брокер — следующий шаг.
background.add_task(relay.nudge)
return asdict(attachment)
@app.get("/api/v1/attachments/{attachment_id}")
def get_attachment(attachment_id: uuid.UUID, user: CurrentUser):
attachment, _key = store.get_attachment(user.id, str(attachment_id))
return asdict(attachment)
@app.get("/api/v1/attachments/{attachment_id}/content")
def download_attachment(attachment_id: uuid.UUID, user: CurrentUser, variant: str = "original"):
if variant != "original" and variant not in VARIANT_ORDER:
raise InvalidRequest("Неверное значение: variant")
# Не участник -> 404; не готово (queued/processing/failed) -> 409; нет такого варианта -> 404.
key, content_type, size = store.get_content(user.id, str(attachment_id), variant)
try:
body = objects.open_stream(key)
except objects.MissingObject:
log.error("Нет объекта в S3 для готового вложения %s (%s)", attachment_id, variant,
extra={"event": "attachment.object_missing"})
raise Unavailable("Файл временно недоступен") from None
# Через API, без redirect на S3: доступ проверен выше. Отдаём кусками, без чтения в память целиком.
return StreamingResponse(objects.iter_chunks(body), media_type=content_type, headers={
"Content-Length": str(size),
"Cache-Control": "private, no-store",
"X-Content-Type-Options": "nosniff",
})
# С lab7: внешний слой — подсчёт тела без Content-Length (chunked) для JSON-запросов.
app.add_middleware(BodyLimit)
+121
View File
@@ -0,0 +1,121 @@
"""Приём вложения (с lab5 — асинхронный): POST /chats/{id}/attachments -> 202 queued.
Что именно сохранено в момент 202 (contracts/attachment-states.md, переход «нет -> queued»):
1. полный проверенный оригинал — в staging S3 (staging/<id>): PUT вернул 200, объект виден
всем репликам и worker и лежит в volume s3data, а не в памяти или на диске реплики API;
2. в PostgreSQL одной транзакцией (COMMIT с записью WAL на диск): строка вложения (queued),
задание (attempt=1) и строка outbox — «намерение обработать».
В брокер в этот момент сообщение может быть ещё не отправлено: это делает relay (relay.py)
через миллисекунды или позже, если брокер недоступен. Намерение уже не потеряется: оно в БД.
Шаги:
0. (api.py) токен, формат chat_id, участник ли чата, filename, Content-Type, Content-Length;
1. тело читается потоком: кусок за куском, с подсчётом размера и SHA-256. Как только размер
превысил 10 MiB — 413, дальше не читаем. В памяти не больше UPLOAD_SPOOL_BYTES (1 МиБ),
остальное во временном файле (SpooledTemporaryFile), который удаляется в конце запроса;
2. проверка картинки (images.py): тип по содержимому, пиксели по заголовку, структура файла.
Картинка НЕ декодируется и не уменьшается — это работа worker;
3. PUT оригинала в staging/<id> (ключ назначает сервер);
4. COMMIT: вложение + задание + outbox -> 202. После ответа будится relay этого же процесса.
Шаги 3–4 — одна транзакция под блокировкой ID вложения (store.receiving): пока она идёт,
уборщик этот staging не трогает (замечание к MR: уборка не должна удалять текущую работу).
Сбои:
- S3 недоступен на шаге 3 -> 503, в БД ничего нет; объект мог успеть записаться — тогда это
«сирота» без строки, его уберёт уборщик через grace period (cleanup.py);
- PostgreSQL недоступен на шаге 4 -> 503, то же самое;
- процесс API упал сразу после COMMIT -> клиент не получил ответ, но работа принята:
relay другой реплики отправит задание, worker его выполнит (проверка: make outbox-crash).
Клиент, прервавший передачу на шаге 1, ничего после себя не оставляет.
"""
import asyncio
import hashlib
import logging
import tempfile
import time
import uuid
from starlette.concurrency import run_in_threadpool
from starlette.requests import ClientDisconnect, Request
from . import config, faults, images, objects
from .errors import InvalidRequest, PayloadTooLarge
from .store import Attachment, PostgresStore
log = logging.getLogger("messenger.attachments")
def check_content_length(header: str | None) -> None:
"""Если клиент заранее сообщил размер больше лимита — 413 сразу, тело не читаем вовсе."""
if header is None:
return
if not header.strip().isdigit():
raise InvalidRequest("Неверный Content-Length")
if int(header) > config.MAX_UPLOAD_BYTES:
raise PayloadTooLarge(f"Файл больше {config.MAX_UPLOAD_BYTES} байт")
async def receive_body(request: Request):
"""Принять тело потоком. Возвращает (временный файл, размер, sha256). Память ограничена."""
spool = tempfile.SpooledTemporaryFile(max_size=config.UPLOAD_SPOOL_BYTES)
digest, size = hashlib.sha256(), 0
deadline = time.monotonic() + config.UPLOAD_TIMEOUT_SECONDS
stream = request.stream().__aiter__()
try:
while True:
left = deadline - time.monotonic()
if left <= 0:
raise InvalidRequest(f"Файл не получен за {config.UPLOAD_TIMEOUT_SECONDS} с")
try:
chunk = await asyncio.wait_for(stream.__anext__(), timeout=left)
except StopAsyncIteration:
break
except asyncio.TimeoutError:
raise InvalidRequest(f"Файл не получен за {config.UPLOAD_TIMEOUT_SECONDS} с") from None
size += len(chunk)
if size > config.MAX_UPLOAD_BYTES:
raise PayloadTooLarge(f"Файл больше {config.MAX_UPLOAD_BYTES} байт")
digest.update(chunk)
spool.write(chunk)
except ClientDisconnect:
spool.close()
log.info("Клиент прервал загрузку на %d байтах: ничего не сохранено", size,
extra={"event": "attachment.upload_aborted"})
raise InvalidRequest("Загрузка прервана клиентом") from None
except BaseException:
spool.close()
raise
if size == 0:
spool.close()
raise InvalidRequest("Пустое тело запроса: нужен файл PNG или JPEG")
return spool, size, digest.hexdigest()
def accept(store: PostgresStore, user_id: str, chat_id: str, filename: str,
spool, size: int, sha256: str, declared: str) -> Attachment:
"""Шаги 2–4 (блокирующий код, выполняется в пуле потоков)."""
info = images.inspect(spool, declared)
attachment_id = str(uuid.uuid4())
staging = objects.staging_key(attachment_id)
# Одна транзакция от PUT до COMMIT под блокировкой ID вложения (store.receiving): уборщик
# не тронет staging, пока загрузка не закончилась, даже если строки в БД ещё нет.
with store.receiving(attachment_id) as conn:
objects.put(staging, spool, size, info.content_type, sha256) # сбой -> 503, транзакция откатывается
faults.pause("api_pause_after_staging") # проверка окна «staging записан, строки ещё нет»
attachment = store.create_queued_attachment(
attachment_id, user_id, chat_id, filename, info.content_type, size, sha256, info.width, info.height,
staging_key=staging, storage_key=objects.original_key(attachment_id),
actor="api-" + config.INSTANCE_ID, conn=conn)
faults.hit("api_after_commit") # проверка окна «COMMIT прошёл, до отправки в брокер» (faults.py)
log.info("Вложение %s принято: %d байт, %s, задание в outbox", attachment_id, size, info.content_type,
extra={"event": "attachment.accepted", "attachment_id": attachment_id})
return attachment
async def upload(request: Request, store: PostgresStore, user_id: str, chat_id: str,
filename: str, declared: str) -> Attachment:
spool, size, sha256 = await receive_body(request)
try:
return await run_in_threadpool(accept, store, user_id, chat_id, filename, spool, size, sha256, declared)
finally:
spool.close() # временный буфер удаляется в любом случае: оригинал живёт только в S3
+232
View File
@@ -0,0 +1,232 @@
"""Брокер сообщений RabbitMQ (с lab5): топология, формат сообщения, публикация с подтверждением.
С lab7 соединение — AMQP поверх TLS (amqps, порт 5671) со взаимной проверкой сертификатов:
- клиент проверяет сертификат брокера нашим CA и имя broker (check_hostname);
- брокер требует клиентский сертификат и берёт имя пользователя из его CN (SASL EXTERNAL,
без пароля): api -> пользователь messenger-api, worker -> messenger-worker;
- права пользователей разные (infra/rabbitmq/definitions.json): messenger-api только публикует
в exchange attachments, messenger-worker только читает очередь attachments.process; объявлять
или менять топологию не может никто из них — её создаёт сам брокер из definitions.json при старте.
Поэтому declare() ниже — пассивная проверка «топология на месте», а не создание.
Топология (создаёт брокер из infra/rabbitmq/definitions.json, те же параметры):
- exchange `attachments` (direct) -> очередь `attachments.process` по ключу attachment.process.v1;
- очередь `attachments.process` — quorum queue: хранится на диске (volume брокера), переживает
перезапуск брокера; у каждого сообщения считается число неудачных доставок, после
BROKER_DELIVERY_LIMIT сообщение уходит в DLQ (защита от «ядовитого» сообщения, которое
раз за разом роняет обработчик);
- exchange `attachments.dlx` -> очередь `attachments.dead` (DLQ): сюда попадают сообщения,
которые worker отклонил окончательно (failed, исчерпаны попытки, неверный формат).
Подробности (error_code, попытки) — в PostgreSQL: таблица attachment_jobs — это реестр failed.
Две разные границы надёжности:
- publisher confirm: брокер -> отправитель «сообщение записано в очередь». Только после него
relay отмечает строку outbox отправленной;
- consumer ack: worker -> брокер «результат обработки уже сохранён, сообщение можно удалить».
Ack идёт только после COMMIT результата в PostgreSQL.
В сообщении только идентификаторы и служебные поля (contracts/jobs.schema.json): ни байтов
файла, ни ключей S3, ни URL, ни паролей. Worker берёт всё остальное из БД.
"""
import json
import re
import ssl
import uuid
from datetime import datetime, timezone
import pika
from pika.exceptions import AMQPError
from . import config
EXCHANGE = "attachments"
ROUTING_KEY = "attachment.process.v1"
QUEUE = "attachments.process"
DEAD_EXCHANGE = "attachments.dlx"
DEAD_QUEUE = "attachments.dead"
DEAD_ROUTING_KEY = "attachment.dead"
MESSAGE_TYPE = "attachment.process.v1"
SCHEMA_VERSION = 1
DELIVERY_LIMIT = 10
MAX_MESSAGE_BYTES = 4096
QUEUE_ARGUMENTS = {
"x-queue-type": "quorum",
"x-delivery-limit": DELIVERY_LIMIT,
"x-dead-letter-exchange": DEAD_EXCHANGE,
"x-dead-letter-routing-key": DEAD_ROUTING_KEY,
}
DEAD_QUEUE_ARGUMENTS = {"x-queue-type": "quorum", "x-max-length": 100_000}
_FIELDS = {"schema_version", "job_id", "type", "attachment_id", "pipeline_version", "attempt",
"created_at", "traceparent", "tracestate"}
_REQUIRED = _FIELDS - {"traceparent", "tracestate"}
_TRACEPARENT = re.compile(r"^00-[0-9a-f]{32}-[0-9a-f]{16}-[0-9a-f]{2}$")
# Ошибки связи с брокером: при любой из них соединение пересоздаётся.
BrokerError = (AMQPError, OSError)
class InvalidMessage(Exception):
"""Тело сообщения не соответствует jobs.schema.json (ошибка отправителя, повтор не поможет)."""
def iso_now() -> str:
return datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
def build_message(job_id: str, attachment_id: str, pipeline_version: int, attempt: int,
created_at: str | None = None) -> dict:
return {"schema_version": SCHEMA_VERSION, "job_id": str(job_id), "type": MESSAGE_TYPE,
"attachment_id": str(attachment_id), "pipeline_version": int(pipeline_version),
"attempt": int(attempt), "created_at": created_at or iso_now()}
def encode(message: dict) -> bytes:
return json.dumps(message, sort_keys=True, separators=(",", ":")).encode("ascii")
def _uuid(value) -> str:
if not isinstance(value, str):
raise InvalidMessage("uuid должен быть строкой")
try:
return str(uuid.UUID(value))
except ValueError:
raise InvalidMessage("неверный uuid") from None
def _positive_int(value, name: str) -> int:
if not isinstance(value, int) or isinstance(value, bool) or value < 1:
raise InvalidMessage(name + " должен быть целым >= 1")
return value
def parse(body: bytes) -> dict:
"""Разобрать и проверить сообщение по contracts/jobs.schema.json. Ошибка -> InvalidMessage."""
if len(body) > MAX_MESSAGE_BYTES:
raise InvalidMessage("слишком большое сообщение")
try:
message = json.loads(body.decode("utf-8"))
except (UnicodeDecodeError, ValueError, RecursionError):
raise InvalidMessage("не JSON") from None
if not isinstance(message, dict):
raise InvalidMessage("ожидался объект")
if set(message) - _FIELDS:
raise InvalidMessage("лишние поля")
if _REQUIRED - set(message):
raise InvalidMessage("нет обязательных полей")
if message["schema_version"] != SCHEMA_VERSION or isinstance(message["schema_version"], bool):
raise InvalidMessage("schema_version")
if message["type"] != MESSAGE_TYPE:
raise InvalidMessage("type")
result = {"schema_version": SCHEMA_VERSION, "type": MESSAGE_TYPE,
"job_id": _uuid(message["job_id"]), "attachment_id": _uuid(message["attachment_id"]),
"pipeline_version": _positive_int(message["pipeline_version"], "pipeline_version"),
"attempt": _positive_int(message["attempt"], "attempt")}
created = message["created_at"]
if not isinstance(created, str):
raise InvalidMessage("created_at")
try:
parsed = datetime.fromisoformat(created.replace("Z", "+00:00"))
except ValueError:
raise InvalidMessage("created_at") from None
if parsed.tzinfo is None:
raise InvalidMessage("created_at без часового пояса")
result["created_at"] = created
if "traceparent" in message:
if not isinstance(message["traceparent"], str) or not _TRACEPARENT.match(message["traceparent"]):
raise InvalidMessage("traceparent")
result["traceparent"] = message["traceparent"]
if "tracestate" in message:
if not isinstance(message["tracestate"], str) or len(message["tracestate"]) > 512:
raise InvalidMessage("tracestate")
result["tracestate"] = message["tracestate"]
return result
def ssl_options() -> pika.SSLOptions:
"""TLS к брокеру: проверка сертификата broker нашим CA + свой клиентский сертификат (identity)."""
context = ssl.create_default_context(cafile=config.TLS_CA_FILE)
context.minimum_version = ssl.TLSVersion.TLSv1_2
context.load_cert_chain(config.TLS_CERT_FILE, config.TLS_KEY_FILE)
return pika.SSLOptions(context, server_hostname=pika.URLParameters(config.BROKER_URL).host)
def parameters(role: str) -> pika.URLParameters:
params = pika.URLParameters(config.BROKER_URL)
if config.BROKER_URL.startswith("amqps://"):
params.ssl_options = ssl_options()
params.credentials = pika.credentials.ExternalCredentials() # имя пользователя = CN сертификата
# Heartbeat 10 с: брокер закрывает соединение зависшего процесса примерно через 20 с и возвращает
# в очередь выданные ему сообщения. Иначе замороженный worker продолжал бы «получать» задания
# (до prefetch) и держать их минуту и дольше. Наш цикл обслуживает heartbeat раз в секунду.
params.heartbeat = 10
params.blocked_connection_timeout = 10 # брокер заблокировал публикацию (нет памяти/диска) -> ошибка
params.socket_timeout = 5
params.stack_timeout = 10
params.connection_attempts = 1 # повторы подключения делает наш цикл, с паузами
params.client_properties = {"connection_name": f"{role}-{config.INSTANCE_ID}"}
return params
def connect(role: str) -> pika.BlockingConnection:
return pika.BlockingConnection(parameters(role))
def declare(channel, role: str = "relay") -> None:
"""Проверить, что топология на месте (passive: ничего не создаёт и не требует прав configure).
Нет exchange/очереди -> канал закрывается с 404, вызывающий цикл повторит позже.
Relay проверяет только exchange (читать очередь ему нельзя), worker — только свою очередь.
"""
if role == "worker":
channel.queue_declare(QUEUE, passive=True)
else:
channel.exchange_declare(EXCHANGE, passive=True)
class Publisher:
"""Соединение для публикации с publisher confirms. Используется одним потоком (relay)."""
def __init__(self, role: str):
self.role = role
self.connection = None
self.channel = None
def _open(self):
if self.channel is not None and self.channel.is_open and self.connection.is_open:
return self.channel
self.close()
self.connection = connect(self.role)
channel = self.connection.channel()
declare(channel)
channel.confirm_delivery() # каждая публикация ждёт подтверждения брокера
self.channel = channel
return channel
def publish(self, message: dict) -> None:
"""Отправить и дождаться publisher confirm. Без подтверждения — исключение."""
channel = self._open()
properties = pika.BasicProperties(
content_type="application/json",
delivery_mode=pika.DeliveryMode.Persistent,
message_id=f"{message['job_id']}:{message['attempt']}",
type=MESSAGE_TYPE,
app_id="messenger-relay",
)
# mandatory=True: если сообщение не попало ни в одну очередь, брокер вернёт его,
# и pika бросит UnroutableError — строка outbox останется неотправленной.
channel.basic_publish(EXCHANGE, ROUTING_KEY, encode(message), properties=properties, mandatory=True)
def service(self) -> None:
"""Обслужить соединение между публикациями (heartbeat), если оно открыто."""
if self.connection is not None and self.connection.is_open:
self.connection.process_data_events(time_limit=0)
def close(self) -> None:
try:
if self.connection is not None and self.connection.is_open:
self.connection.close()
except BrokerError:
pass
self.connection = self.channel = None
+138
View File
@@ -0,0 +1,138 @@
"""Уборка объектов S3 (с lab4; с lab5 — staging и варианты): фоновый поток worker и команда.
Зачем. Между записью байтов в S3 и COMMIT в PostgreSQL может случиться сбой, а staging после
обработки больше не нужен. Уборщик сверяет содержимое bucket с базой и удаляет то, на что
база не ссылается.
Что нужно и не удаляется:
- оригинал ready-вложения (originals/<id>) и все его варианты (variants/<id>/...);
- ВСЕ объекты вложения в работе (queued, processing): staging читает worker, а оригинал и
варианты он, возможно, пишет прямо сейчас, до COMMIT результата;
- все объекты failed-вложения, пока не прошёл STAGING_RETENTION_SECONDS (24 ч): оператор может
сделать replay, и worker запишет оригинал и варианты заново в те же ключи;
- staging загрузки, которая ещё идёт (PUT уже был, COMMIT строки вложения — ещё нет).
Под удаление попадают объекты старше grace period (ATTACHMENT_GRACE_SECONDS, 15 мин):
- staging уже готового вложения (worker удаляет его сам сразу после COMMIT, сюда попадает,
только если тогда не получилось);
- объекты failed-вложения после retention (сначала staging помечается удалённым в БД);
- «сироты»: объекты без строки в БД (API упал между PUT в staging и COMMIT).
Как уборщик не удаляет текущую работу (замечание к MR). Прежняя версия читала ссылки из БД
один раз и удаляла по этому снимку: если между чтением и удалением оператор делал replay,
staging уже queued-задания удалялся, и worker получал source_missing. Теперь:
1. список объектов и снимок ссылок из БД только отбирают кандидатов (заведомо нужное не трогаем);
2. по каждому вложению-кандидату решение принимается заново, в короткой транзакции под
блокировками (PostgresStore.cleanup_attachment): advisory-блокировка ID вложения (её держит
идущая загрузка), затем строки задания и вложения (их меняют worker и replay). Пока блокировки
у уборщика, состояние не может поменяться;
3. у failed-вложения после retention сначала в БД помечается, что исходника нет
(staging_key = NULL, запись в журнале), и только после COMMIT объекты удаляются из S3:
replay, ждавший блокировку или пришедший позже, видит это и безопасно отказывает;
4. из S3 удаляется только то, что после COMMIT уже не может понадобиться никогда (сирота без
загрузки, staging готового, объекты failed без исходника). Поэтому медленный S3 не держит
блокировки, а оборванная сессия БД не открывает окно для гонки.
Готовые вложения без объекта (missing) только считаются и пишутся в лог: решает человек.
Повторный и одновременный запуск безопасен: удаление идемпотентно, вложение обрабатывает
только тот, кто взял его блокировку.
Запуск вручную (внутри контейнера api или worker):
python -m messenger.cleanup --dry-run # только показать, ничего не удалять
python -m messenger.cleanup # удалить по правилам выше
python -m messenger.cleanup --grace-seconds 5 # для теста: меньший grace period
python -m messenger.cleanup --attachment <id> # только объекты одного вложения
Вывод — одна строка JSON со счётчиками, без ключей доступа.
"""
import argparse
import json
import logging
import sys
import time
import uuid
from collections import Counter, defaultdict
from datetime import datetime, timedelta, timezone
from . import config, faults, objects
from .errors import AppError
from .store import PostgresStore
log = logging.getLogger("messenger.cleanup")
def run_once(store: PostgresStore, grace_seconds: int, retention_seconds: int, dry_run: bool = False,
attachment_id: str | None = None) -> dict:
started = time.monotonic()
if attachment_id is None:
listed = objects.list_objects("")
else:
listed = [item for prefix in objects.prefixes_of(attachment_id) for item in objects.list_objects(prefix)]
refs = store.storage_references(retention_seconds)
faults.pause("cleanup_pause") # проверка гонки: окно между чтением ссылок и удалением
border = datetime.now(timezone.utc) - timedelta(seconds=grace_seconds)
candidates = defaultdict(list) # ID вложения -> его объекты, которые МОГУТ быть лишними
for key, modified in listed:
if key not in refs["needed"] and modified < border:
candidates[objects.attachment_of(key)].append(key)
counts = {"staging_after_ready": 0, "staging_failed_expired": 0, "orphan": 0}
kept, busy, deleted = Counter(), 0, 0
for owner, keys in candidates.items():
if owner is None:
# Ключ не того вида, что пишут API и worker: никакая текущая работа на него не ссылается.
counts["orphan"] += len(keys)
if not dry_run:
for key in keys:
objects.delete(key)
deleted += len(keys)
continue
outcome = store.cleanup_attachment(owner, keys, retention_seconds, None if dry_run else objects.delete)
if outcome is None:
busy += len(keys) # идёт загрузка или переход состояния: в следующий раз
continue
for _key, reason in outcome["delete"]:
counts[reason] += 1
for _key, why in outcome["keep"]:
kept[why] += 1 # снимок говорил «лишний», а текущее состояние — «нужен»
if not dry_run:
deleted += len(outcome["delete"])
in_bucket = {key for key, _ in listed}
missing = len(refs["ready_originals"] - in_bucket) if attachment_id is None else 0
if missing:
log.error("В БД есть %d готовых вложений без оригинала в S3 (нужна ручная проверка)", missing)
outbox_deleted = 0 if dry_run else store.delete_old_outbox(config.OUTBOX_RETENTION_SECONDS)
by_prefix = {}
for key, _ in listed:
prefix = key.split("/", 1)[0] + "/"
by_prefix[prefix] = by_prefix.get(prefix, 0) + 1
return {"dry_run": dry_run, "grace_seconds": grace_seconds, "retention_seconds": retention_seconds,
"to_delete": counts, "deleted": deleted, "kept_after_recheck": dict(kept), "skipped_busy": busy,
"missing_ready_originals": missing, "objects_in_bucket": len(listed), "by_prefix": by_prefix,
"outbox_rows_deleted": outbox_deleted, "seconds": round(time.monotonic() - started, 3)}
def main(argv=None) -> int:
parser = argparse.ArgumentParser(description="Уборка объектов S3 и сверка с БД")
parser.add_argument("--dry-run", action="store_true", help="только посчитать, ничего не удалять")
parser.add_argument("--grace-seconds", type=int, default=config.ATTACHMENT_GRACE_SECONDS)
parser.add_argument("--retention-seconds", type=int, default=config.STAGING_RETENTION_SECONDS)
parser.add_argument("--attachment", type=uuid.UUID, help="только объекты одного вложения")
args = parser.parse_args(argv)
logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(name)s: %(message)s")
from . import secretsource
secretsource.load() # с lab7: пароль роли БД и ключи S3 — из OpenBao (identity контейнера)
config.validate()
config.validate_s3()
from . import db
pool = db.create_pool(application_name="messenger-cleanup", max_size=2)
pool.open()
try:
print(json.dumps(run_once(PostgresStore(pool), args.grace_seconds, args.retention_seconds, args.dry_run,
str(args.attachment) if args.attachment else None)))
except AppError as exc:
print(json.dumps({"error": exc.message}, ensure_ascii=False))
return 1
finally:
pool.close()
return 0
if __name__ == "__main__":
sys.exit(main())
+282
View File
@@ -0,0 +1,282 @@
"""Настройки из переменных окружения.
Конфигурация не зашита в код и в образ: один и тот же образ запускается
с разными настройками (API, worker, API с коротким TTL сессии, сервис миграций).
Секреты (адреса БД и Valkey с паролями) передаются не значением переменной,
а путём к файлу: *_FILE=/run/secrets/... Так пароль не виден в `docker inspect`.
"""
import os
import secrets
from pathlib import Path
def _int(name: str, default: int, minimum: int = 1) -> int:
value = int(os.environ.get(name, str(default)))
if value < minimum:
raise ValueError(f"{name} должен быть не меньше {minimum}")
return value
def _float(name: str, default: float, minimum: float = 0.0) -> float:
value = float(os.environ.get(name, str(default)))
if value < minimum:
raise ValueError(f"{name} должен быть не меньше {minimum}")
return value
def _secret(file_var: str, plain_var: str) -> str:
"""Значение секрета: из файла, указанного в *_FILE, иначе из обычной переменной.
strip() убирает перевод строки в конце файла, в том числе \\r из Windows-редакторов:
иначе он попал бы внутрь пароля и подключение к БД не прошло бы.
"""
path = os.environ.get(file_var, "").strip()
if path:
return Path(path).read_text(encoding="utf-8").strip()
return os.environ.get(plain_var, "").strip()
APP_HOST = os.environ.get("APP_HOST", "0.0.0.0") # 0.0.0.0 = слушать на всех интерфейсах контейнера
APP_PORT = _int("APP_PORT", 8080)
APP_ENV = os.environ.get("APP_ENV", "lab")
# Версия сборки (build arg APP_VERSION в Dockerfile). Пишется в лог при старте;
# по ней student-tests/rolling_update.py проверяет, что все реплики заменены новой версией.
APP_VERSION = os.environ.get("APP_VERSION", "dev")
# --- реплики (с lab3) ---
# X-Instance-Id: какая реплика обслужила запрос. С lab7 это случайный alias процесса
# (контракт: «без раскрытия hostname/IP»): по нему нельзя узнать ID контейнера или адрес в сети.
# Значение не меняется, пока жив процесс. Сопоставление alias -> контейнер знает только оператор:
# процесс записывает alias в INSTANCE_ID_FILE (tmpfs контейнера), его читает scripts/stop_one.py.
INSTANCE_ID = os.environ.get("INSTANCE_ID", "").strip() or "r-" + secrets.token_hex(6)
INSTANCE_ID_FILE = os.environ.get("INSTANCE_ID_FILE", "/tmp/instance-id")
# Остановка по SIGTERM в два шага (см. __main__.py):
# 1) SHUTDOWN_DRAIN_SECONDS: /health/ready уже отвечает 503, но запросы ещё обслуживаются.
# HAProxy проверяет готовность раз в 1 с и после 2 неудач подряд (через ~1,5 с)
# перестаёт слать сюда запросы. 3 с — с запасом;
# 2) GRACEFUL_SHUTDOWN_SECONDS: uvicorn закрывает приём и доделывает начатые запросы.
# Самый долгий запрос: ожидание соединения из пула (3 с) + statement_timeout (5 с) = 8 с.
# Docker ждёт дольше суммы (stop_grace_period: 15s в compose.yaml), потом SIGKILL.
SHUTDOWN_DRAIN_SECONDS = _int("SHUTDOWN_DRAIN_SECONDS", 3, minimum=0)
GRACEFUL_SHUTDOWN_SECONDS = _int("GRACEFUL_SHUTDOWN_SECONDS", 8)
# --- сессии ---
SESSION_TTL_SECONDS = _int("SESSION_TTL_SECONDS", 3600)
# Источник истины для сессий. Поддерживается только postgres: Valkey в этой работе — кэш.
SESSION_STORE = os.environ.get("SESSION_STORE", "postgres").strip()
# Сколько секунд запись о сессии может жить в кэше (не дольше самой сессии).
# Это верхняя граница «устаревания»: см. sessions.py и REPORT.md.
SESSION_CACHE_TTL_SECONDS = _int("SESSION_CACHE_TTL_SECONDS", 30)
# --- PostgreSQL ---
# С lab7 адрес БД — НЕ секрет: имя роли, хост, sslmode=verify-full и путь к CA, без пароля.
# Пароль своей роли (messenger_api / messenger_worker) процесс получает из OpenBao (secretsource.py);
# сервис migrate (роль-владелец схемы) — из файла DB_PASSWORD_FILE.
DATABASE_URL = _secret("DATABASE_URL_FILE", "DATABASE_URL")
DB_PASSWORD = _secret("DB_PASSWORD_FILE", "DB_PASSWORD") # заполняется secretsource.load()
DB_POOL_MIN_SIZE = _int("DB_POOL_MIN_SIZE", 1)
DB_POOL_MAX_SIZE = _int("DB_POOL_MAX_SIZE", 10) # пул ограничен: не больше 10 соединений с БД
DB_POOL_TIMEOUT_SECONDS = _int("DB_POOL_TIMEOUT_SECONDS", 3) # ждать свободное соединение не дольше
DB_CONNECT_TIMEOUT_SECONDS = _int("DB_CONNECT_TIMEOUT_SECONDS", 3)
DB_STATEMENT_TIMEOUT_MS = _int("DB_STATEMENT_TIMEOUT_MS", 5000) # один SQL-запрос не дольше 5 с
DB_STARTUP_WAIT_SECONDS = _int("DB_STARTUP_WAIT_SECONDS", 60) # сколько ждать БД и миграции при старте
# --- Valkey (кэш сессий, общий для всех реплик) ---
CACHE_URL = _secret("CACHE_URL_FILE", "CACHE_URL") # пусто = работать без кэша (с lab7: valkeys://, без пароля)
CACHE_PASSWORD = _secret("CACHE_PASSWORD_FILE", "CACHE_PASSWORD") # из OpenBao (secretsource.py)
CACHE_TIMEOUT_MS = _int("CACHE_TIMEOUT_MS", 300) # кэш должен отвечать быстро, иначе обходим его
CACHE_POOL_MAX_SIZE = _int("CACHE_POOL_MAX_SIZE", 20)
# Как часто фоновый поток каждой реплики проверяет Valkey (PING). Так реплика замечает сбой
# Valkey, даже если в этот момент через неё не шли запросы (см. sessions.py).
CACHE_CHECK_INTERVAL_SECONDS = _int("CACHE_CHECK_INTERVAL_SECONDS", 1)
# IDEMPOTENCY_TTL_SECONDS из .env.example не используется: ключ идемпотентности хранится
# в строке сообщения столько же, сколько само сообщение (бессрочно, то есть дольше 24 ч
# из контракта). См. migrations/004_message_idempotency.sql и REPORT.md.
# --- S3 (с lab4): байты вложений в приватном bucket SeaweedFS, метаданные — в PostgreSQL ---
S3_ENDPOINT = os.environ.get("S3_ENDPOINT", "https://s3:9000").strip()
S3_REGION = os.environ.get("S3_REGION", "us-east-1").strip()
S3_BUCKET = os.environ.get("S3_BUCKET", "messenger-attachments").strip()
# С lab7 у API и worker РАЗНЫЕ пользователи S3 с правами на разные префиксы (secrets/s3_config.json),
# ключи процесс получает из OpenBao. Ключи администратора S3 сюда не передаются.
S3_ACCESS_KEY_ID = _secret("S3_ACCESS_KEY_ID_FILE", "S3_ACCESS_KEY_ID")
S3_SECRET_ACCESS_KEY = _secret("S3_SECRET_ACCESS_KEY_FILE", "S3_SECRET_ACCESS_KEY")
# Таймауты S3: недоступный S3 даёт быстрый 503, а не зависший запрос.
# Ответ на запрос клиента всё равно не дольше S3_OPERATION_TIMEOUT_SECONDS (6 с), см. ниже.
S3_CONNECT_TIMEOUT_SECONDS = _int("S3_CONNECT_TIMEOUT_SECONDS", 2)
S3_READ_TIMEOUT_SECONDS = _int("S3_READ_TIMEOUT_SECONDS", 5)
S3_MAX_ATTEMPTS = _int("S3_MAX_ATTEMPTS", 2) # 1 попытка + 1 повтор при сетевой ошибке
# Общий предел на одну операцию S3 (включая поиск имени в DNS, который таймауты выше не покрывают).
S3_OPERATION_TIMEOUT_SECONDS = _int("S3_OPERATION_TIMEOUT_SECONDS", 6)
# Readiness с lab5 зависит и от S3: без него нельзя принять файл в staging (обязательный путь).
# Фоновый поток реплики проверяет bucket раз в S3_HEALTH_INTERVAL_SECONDS; если успешной проверки
# не было дольше S3_HEALTH_MAX_AGE_SECONDS, /health/ready отвечает 503.
S3_HEALTH_INTERVAL_SECONDS = _float("S3_HEALTH_INTERVAL_SECONDS", 1.0, minimum=0.2)
S3_HEALTH_MAX_AGE_SECONDS = _float("S3_HEALTH_MAX_AGE_SECONDS", 3.0, minimum=1.0)
# --- приём картинок (API) ---
MAX_UPLOAD_BYTES = _int("MAX_UPLOAD_BYTES", 10 * 1024 * 1024) # 10 MiB = 10 485 760 байт (контракт)
MAX_IMAGE_PIXELS = _int("MAX_IMAGE_PIXELS", 40_000_000) # 40 млн пикселей (контракт)
# Тело читается кусками; в памяти держится не больше UPLOAD_SPOOL_BYTES на загрузку,
# остальное — во временном файле, который удаляется сразу после запроса (это буфер, а не хранилище).
UPLOAD_SPOOL_BYTES = _int("UPLOAD_SPOOL_BYTES", 1024 * 1024)
# Если клиент передаёт файл дольше этого, загрузка прерывается (400): медленный клиент
# не держит память и соединение бесконечно.
UPLOAD_TIMEOUT_SECONDS = _int("UPLOAD_TIMEOUT_SECONDS", 60)
# С lab5 API картинку НЕ декодирует (это работа worker), а только проверяет структуру файла
# потоком: блоки PNG и их CRC, сжатые данные IDAT, маркеры JPEG. Памяти почти не нужно,
# но это работа процессора, поэтому одновременных проверок на реплику не больше этого числа.
IMAGE_CHECK_CONCURRENCY = _int("IMAGE_CHECK_CONCURRENCY", 2)
IMAGE_CHECK_WAIT_SECONDS = _int("IMAGE_CHECK_WAIT_SECONDS", 10) # дольше ждать очередь — 503
# --- брокер, outbox и worker (с lab5) ---
# С lab7: amqps://broker:5671/messenger — без пароля. Вход по клиентскому сертификату
# (SASL EXTERNAL): имя пользователя RabbitMQ = CN сертификата (api или worker), права — по пользователю.
BROKER_URL = _secret("BROKER_URL_FILE", "BROKER_URL")
# Версия pipeline: часть ключа эффекта (attachment_id, pipeline_version, variant). В курсе одна — 1.
PIPELINE_VERSION = 1
# Relay (в каждой реплике API) отправляет строки outbox в брокер: сразу после загрузки
# (сигнал из того же процесса) и раз в RELAY_POLL_SECONDS — строки других процессов и отложенные повторы.
RELAY_POLL_SECONDS = _float("RELAY_POLL_SECONDS", 1.0, minimum=0.1)
RELAY_BATCH_SIZE = _int("RELAY_BATCH_SIZE", 50)
# Worker: сколько заданий одновременно (= prefetch брокера: больше неподтверждённых сообщений
# worker не получает). Каждое задание — отдельный дочерний процесс с лимитами (sandbox.py).
WORKER_CONCURRENCY = _int("WORKER_CONCURRENCY", 2)
# Лимит времени одной попытки: дочерний процесс, не уложившийся в него, убивается (SIGKILL).
JOB_TIMEOUT_SECONDS = _int("JOB_TIMEOUT_SECONDS", 60)
# Лимит памяти одной попытки: адресное пространство дочернего процесса (RLIMIT_AS).
# Самая тяжёлая допустимая картинка (PNG RGBA 40 Мп) требует ~480 МиБ, см. REPORT.md.
WORKER_MEMORY_LIMIT_MB = _int("WORKER_MEMORY_LIMIT_MB", 640, minimum=64)
# Ограниченный повтор: всего попыток (первая + повторы). Потом — failed с retry_exhausted.
JOB_MAX_ATTEMPTS = _int("JOB_MAX_ATTEMPTS", 5)
# Backoff с jitter: пауза перед попыткой n+1 — случайная в [d/2, d], d = min(MAX, BASE * 2^(n-1)).
RETRY_BASE_SECONDS = _float("RETRY_BASE_SECONDS", 2.0, minimum=0.1)
RETRY_MAX_SECONDS = _float("RETRY_MAX_SECONDS", 60.0, minimum=0.1)
# Lease: worker «арендует» задание на JOB_LEASE_SECONDS и продлевает аренду каждые
# JOB_HEARTBEAT_SECONDS, пока работает. Долгая задача продлевает аренду, зависший или мёртвый
# worker — нет: аренда истекает, и задание возвращается в очередь (новая попытка).
JOB_LEASE_SECONDS = _int("JOB_LEASE_SECONDS", 30, minimum=3)
JOB_HEARTBEAT_SECONDS = _float("JOB_HEARTBEAT_SECONDS", 10.0, minimum=0.5)
# Как часто worker ищет задания с истёкшей арендой.
REAPER_INTERVAL_SECONDS = _float("REAPER_INTERVAL_SECONDS", 5.0, minimum=0.5)
# Страховка от потерянного сообщения: задание в queued дольше этого без свежей отправки
# отправляется ещё раз (дубль безопасен: обработка идемпотентна).
QUEUED_REPUBLISH_SECONDS = _int("QUEUED_REPUBLISH_SECONDS", 600, minimum=10)
# Качество вариантов (размеры 256 / 128 / 1280 заданы контрактом и не настраиваются).
JPEG_QUALITY = _int("JPEG_QUALITY", 85)
WEBP_QUALITY = _int("WEBP_QUALITY", 80)
WEBP_METHOD = _int("WEBP_METHOD", 4, minimum=0) # 0 — быстро, 6 — медленно и чуть меньше файл
# --- уборка объектов S3 (cleanup.py, фоновый поток worker) ---
# Grace period: объект, на который не ссылается БД, удаляется, только если ему больше 15 минут.
# Это намного дольше самой долгой загрузки и самой долгой попытки обработки, поэтому
# идущую прямо сейчас работу уборщик не заденет.
ATTACHMENT_GRACE_SECONDS = _int("ATTACHMENT_GRACE_SECONDS", 900)
CLEANUP_INTERVAL_SECONDS = _int("CLEANUP_INTERVAL_SECONDS", 300)
# Staging-оригинал failed-вложения хранится столько, чтобы оператор успел сделать replay.
STAGING_RETENTION_SECONDS = _int("STAGING_RETENTION_SECONDS", 86400)
# Отправленные строки outbox и журнал заданий хранятся неделю (для расследований), потом удаляются.
OUTBOX_RETENTION_SECONDS = _int("OUTBOX_RETENTION_SECONDS", 7 * 86400)
# --- TLS (с lab7) ---
# Свой CA стенда (scripts/pki.py). CA-сертификат публичный; ключ CA есть только у оператора.
TLS_CA_FILE = os.environ.get("TLS_CA_FILE", "/run/ca/ca.crt")
TLS_CRL_FILE = os.environ.get("TLS_CRL_FILE", "/run/ca/crl.pem") # отозванные серийные номера
# Сертификат и ключ этого процесса (identity api или worker): им процесс представляется
# брокеру, Collector, OpenBao, а API — ещё и балансировщику как сервер.
TLS_CERT_FILE = os.environ.get("TLS_CERT_FILE", "/run/tls/tls.crt")
TLS_KEY_FILE = os.environ.get("TLS_KEY_FILE", "/run/tls/tls.key")
# Какие identity (SAN DNS клиентского сертификата) могут подключаться к API. Доверенного CA мало:
# сертификат worker или любой другой от того же CA получит отказ.
TLS_ALLOWED_CLIENTS = frozenset(x.strip() for x in os.environ.get("TLS_ALLOWED_CLIENTS", "lb").split(",") if x.strip())
TLS_CRL_CHECK_SECONDS = _float("TLS_CRL_CHECK_SECONDS", 5.0, minimum=1.0)
# Healthcheck Docker: отдельный слушатель только на 127.0.0.1 ВНУТРИ контейнера и только
# /health/live и /health/ready. Из сети он недоступен, бизнес-API на нём нет.
APP_HEALTH_PORT = _int("APP_HEALTH_PORT", 8081)
# --- OpenBao (с lab7) ---
# Пусто = секреты из файлов *_FILE (только для локальной отладки и одноразовых инструментов).
BAO_ADDR = os.environ.get("BAO_ADDR", "").strip().rstrip("/")
BAO_CACERT = os.environ.get("BAO_CACERT", TLS_CA_FILE)
BAO_AUTH_PATH = os.environ.get("BAO_AUTH_PATH", "cert")
BAO_ROLE = os.environ.get("BAO_ROLE", "messenger-api") # роль cert auth
BAO_SECRET_PATH = os.environ.get("BAO_SECRET_PATH", "secret/data/messenger/api")
BAO_REFRESH_SECONDS = _float("BAO_REFRESH_SECONDS", 10.0, minimum=1.0)
BAO_STARTUP_WAIT_SECONDS = _int("BAO_STARTUP_WAIT_SECONDS", 90)
# --- пароли и вход (с lab7) ---
# Argon2id: базовый минимум OWASP m=19 МиБ, t=2, p=1; выбор обоснован замером (REPORT.md).
# Хеш со старыми параметрами пересчитывается при успешном входе (security.needs_rehash).
ARGON2_MEMORY_KIB = _int("ARGON2_MEMORY_KIB", 19456, minimum=19456)
ARGON2_ITERATIONS = _int("ARGON2_ITERATIONS", 2, minimum=2)
ARGON2_PARALLELISM = _int("ARGON2_PARALLELISM", 1)
# Бюджет дорогих проверок пароля на реплику: одновременно не больше ARGON2_MAX_CONCURRENCY
# (каждая — ARGON2_MEMORY_KIB памяти и ~1 ядро на десятки мс). Кто ждёт дольше ARGON2_QUEUE_SECONDS — 503.
ARGON2_MAX_CONCURRENCY = _int("ARGON2_MAX_CONCURRENCY", 2)
ARGON2_QUEUE_SECONDS = _float("ARGON2_QUEUE_SECONDS", 2.0, minimum=0.1)
# Лимиты частоты (общие для реплик, счётчики в Valkey; при недоступном Valkey — локальные в реплике).
LOGIN_RATE_PER_IP = _int("LOGIN_RATE_PER_IP", 120) # попыток входа с одного адреса за окно
LOGIN_RATE_WINDOW_SECONDS = _int("LOGIN_RATE_WINDOW_SECONDS", 60)
LOGIN_FAILURES_PER_USER = _int("LOGIN_FAILURES_PER_USER", 10) # неудачных входов в один username за окно
LOGIN_FAILURE_WINDOW_SECONDS = _int("LOGIN_FAILURE_WINDOW_SECONDS", 300)
REGISTER_RATE_PER_IP = _int("REGISTER_RATE_PER_IP", 300) # регистраций с одного адреса за окно
REGISTER_RATE_WINDOW_SECONDS = _int("REGISTER_RATE_WINDOW_SECONDS", 60)
# Тело JSON-запроса (всё, кроме загрузки вложения) — не больше этого; больше -> 413.
MAX_JSON_BODY_BYTES = _int("MAX_JSON_BODY_BYTES", 65536)
def write_instance_id() -> None:
"""Записать alias процесса для оператора (scripts/stop_one.py). Ошибка записи не мешает работе."""
try:
Path(INSTANCE_ID_FILE).write_text(INSTANCE_ID, encoding="ascii")
except OSError:
pass
def _migrations_dir() -> Path:
"""Каталог SQL-миграций: в образе /srv/migrations, в репозитории ./migrations."""
explicit = os.environ.get("MIGRATIONS_DIR")
if explicit:
return Path(explicit)
here = Path(__file__).resolve()
for candidate in (here.parents[1] / "migrations", here.parents[2] / "migrations"):
if candidate.is_dir():
return candidate
return here.parents[1] / "migrations"
MIGRATIONS_DIR = _migrations_dir()
def validate() -> None:
"""Проверка при старте: лучше упасть сразу с понятной ошибкой, чем на первом запросе."""
if not DATABASE_URL:
raise RuntimeError("Не задан адрес PostgreSQL: DATABASE_URL_FILE (или DATABASE_URL)")
if not DB_PASSWORD:
raise RuntimeError("Нет пароля роли БД: OpenBao (BAO_ADDR) или DB_PASSWORD_FILE")
if SESSION_STORE != "postgres":
raise RuntimeError("SESSION_STORE поддерживает только значение postgres (Valkey здесь — кэш)")
if DB_POOL_MIN_SIZE > DB_POOL_MAX_SIZE:
raise RuntimeError("DB_POOL_MIN_SIZE больше DB_POOL_MAX_SIZE")
def validate_s3() -> None:
"""Для API и worker (не для migrate): без ключей S3 вложения работать не смогут."""
if not (S3_ENDPOINT and S3_BUCKET and S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY):
raise RuntimeError("Не заданы S3_ENDPOINT, S3_BUCKET или ключи S3 (S3_*_FILE)")
if ATTACHMENT_GRACE_SECONDS < max(UPLOAD_TIMEOUT_SECONDS, JOB_TIMEOUT_SECONDS) + 60:
raise RuntimeError("ATTACHMENT_GRACE_SECONDS должен быть заметно больше времени загрузки и обработки")
def validate_broker() -> None:
"""Для API (relay) и worker: адрес брокера и согласованность сроков."""
if not BROKER_URL:
raise RuntimeError("Не задан адрес брокера: BROKER_URL")
if JOB_HEARTBEAT_SECONDS * 2 >= JOB_LEASE_SECONDS:
raise RuntimeError("JOB_HEARTBEAT_SECONDS должен быть меньше половины JOB_LEASE_SECONDS")
if RETRY_BASE_SECONDS > RETRY_MAX_SECONDS:
raise RuntimeError("RETRY_BASE_SECONDS больше RETRY_MAX_SECONDS")
+44
View File
@@ -0,0 +1,44 @@
"""Непрозрачный курсор пагинации.
Внутри курсора: «область» (какой именно список листаем) и ключ последнего
элемента страницы (created_at, id). Всё это упаковано в base64, клиент курсор
не разбирает, а просто передаёт обратно. Сервер проверяет, что курсор выдан
для того же списка: курсор от другого чата даёт 400.
С lab2 ключ уходит в SQL-запрос, поэтому перед этим он проверяется:
испорченное время или UUID должны дать 400, а не ошибку базы данных (500).
"""
import base64
import json
import uuid
from datetime import datetime, timezone
from .errors import InvalidRequest
def encode_cursor(scope: str, key: tuple[str, str]) -> str:
raw = json.dumps([scope, *key]).encode()
return base64.urlsafe_b64encode(raw).decode()
def decode_cursor(scope: str, cursor: str | None) -> tuple[datetime, uuid.UUID] | None:
if cursor is None:
return None
try:
data = json.loads(base64.urlsafe_b64decode(cursor.encode("ascii")))
except (ValueError, RecursionError): # не ASCII, не base64, не JSON или слишком глубокая вложенность
raise InvalidRequest("Неверный cursor") from None
well_formed = isinstance(data, list) and len(data) == 3 and all(isinstance(x, str) for x in data)
if not well_formed or data[0] != scope:
raise InvalidRequest("Неверный cursor")
try:
created_at = datetime.fromisoformat(data[1].replace("Z", "+00:00"))
item_id = uuid.UUID(data[2])
if created_at.tzinfo is None:
raise ValueError("время без часового пояса")
# Перевод в UTC может выйти за пределы годов 1–9999 (например, 0001-01-01T00:00+14:00):
# Python бросает OverflowError. Это тоже испорченный курсор -> 400, а не 500.
created_at = created_at.astimezone(timezone.utc)
except (ValueError, OverflowError):
raise InvalidRequest("Неверный cursor") from None
return created_at, item_id
+180
View File
@@ -0,0 +1,180 @@
"""Подключение к PostgreSQL: пул соединений, таймауты и миграции.
Пул — это набор заранее открытых соединений. Запрос берёт соединение из пула,
выполняет SQL и возвращает его обратно. Пул ограничен (DB_POOL_MAX_SIZE), поэтому
даже под нагрузкой API не откроет к базе больше соединений, чем она выдержит.
С lab3 миграции применяет ТОЛЬКО отдельный одноразовый сервис migrate
(`python -m messenger.migrate`, см. compose.yaml). Реплики API при старте лишь ждут,
пока схема станет актуальной (wait_for_schema), и сами ничего не меняют.
Так нет гонки «две реплики одновременно меняют схему».
С lab7:
- соединение только по TLS с проверкой сертификата и имени сервера: sslmode=verify-full и
sslrootcert (наш CA) заданы в DATABASE_URL, а pg_hba.conf отвергает соединения без TLS;
- у каждого процесса своя роль с минимальными правами (migrations/007_roles.sql):
messenger_api, messenger_worker; migrate входит ролью-владельцем схемы messenger;
- пароль не входит в адрес: он берётся из config.DB_PASSWORD (OpenBao) В МОМЕНТ открытия
каждого соединения. После ротации пароля пул сбрасывается (drain_pools), и все новые
соединения входят с новым паролем, а старый перестаёт работать для новых входов.
"""
import logging
import time
import psycopg
from psycopg_pool import ConnectionPool
from . import config
log = logging.getLogger("messenger.db")
# Произвольное постоянное число: «номер замка» для миграций (pg_advisory_lock).
# Если миграции всё-таки запустят дважды одновременно (например, два `docker compose run migrate`),
# выполнит их только один процесс, второй подождёт и увидит, что всё уже применено.
MIGRATION_LOCK_ID = 2026_0002
_pools: list = [] # пулы процесса: их сбрасывает ротация пароля (drain_pools)
def connection_kwargs(application_name: str = "messenger-api") -> dict:
return {
"password": config.DB_PASSWORD, # текущий пароль (может смениться после ротации)
"connect_timeout": config.DB_CONNECT_TIMEOUT_SECONDS,
"application_name": application_name,
# Таймауты на стороне сервера: зависший запрос или забытая транзакция
# не будут держать соединение и блокировки бесконечно.
"options": (f"-c statement_timeout={config.DB_STATEMENT_TIMEOUT_MS}"
" -c idle_in_transaction_session_timeout=10000"),
}
def create_pool(application_name: str = "messenger-api", max_size: int | None = None) -> ConnectionPool:
pool = ConnectionPool(
conninfo=config.DATABASE_URL,
# Функция, а не словарь: пул вызывает её при каждом новом соединении и берёт актуальный пароль.
kwargs=lambda: connection_kwargs(application_name),
min_size=min(config.DB_POOL_MIN_SIZE, max_size or config.DB_POOL_MAX_SIZE),
max_size=max_size or config.DB_POOL_MAX_SIZE,
timeout=config.DB_POOL_TIMEOUT_SECONDS, # сколько ждать свободное соединение из пула
# Перед выдачей соединение проверяется: после рестарта PostgreSQL старые
# соединения «мертвы», и пул заменит их, а не отдаст запросу.
check=ConnectionPool.check_connection,
open=False,
name="messenger",
)
_pools.append(pool)
return pool
def drain_pools(changed: set) -> None:
"""Слушатель secretsource: сменился пароль БД -> закрыть простаивающие соединения пулов.
Соединения, занятые запросами, закрываются после возврата в пул. Новые открываются уже
с новым паролем — так ротация проверяется НОВЫМ подключением, а не старым соединением,
которое PostgreSQL не перепроверяет.
"""
if "db_password" not in changed:
return
for pool in _pools:
if not pool.closed:
pool.drain()
log.warning("Пароль роли БД сменился: пулы соединений пересоздаются (%d)", len(_pools),
extra={"event": "db.pool_drained"})
def migration_files() -> list:
"""Файлы migrations/NNN_*.sql этой версии приложения, по порядку."""
files = sorted(config.MIGRATIONS_DIR.glob("*.sql"))
if not files:
raise RuntimeError(f"Нет файлов миграций в {config.MIGRATIONS_DIR}")
return files
def _connect(application_name: str):
return psycopg.connect(config.DATABASE_URL, autocommit=True, password=config.DB_PASSWORD,
connect_timeout=config.DB_CONNECT_TIMEOUT_SECONDS,
application_name=application_name)
def migrate() -> list[str]:
"""Применяет новые файлы migrations/NNN_*.sql по порядку. Возвращает список применённых.
Каждая миграция и запись о ней выполняются в одной транзакции: либо файл применён
полностью и отмечен, либо ничего не изменилось. Повторный запуск ничего не дублирует.
"""
files = migration_files()
applied_now = []
# Отдельное соединение без statement_timeout: создание индекса на большой таблице может быть долгим.
with _connect("messenger-migrate") as conn:
conn.execute("SELECT pg_advisory_lock(%s)", (MIGRATION_LOCK_ID,))
try:
conn.execute("""
CREATE TABLE IF NOT EXISTS schema_migrations (
version text PRIMARY KEY,
applied_at timestamptz NOT NULL DEFAULT now()
)""")
done = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")}
for path in files:
if path.stem in done:
continue
with conn.transaction():
# Без параметров psycopg разрешает несколько SQL-команд в одном вызове.
conn.execute(path.read_text(encoding="utf-8"))
conn.execute("INSERT INTO schema_migrations (version) VALUES (%s)", (path.stem,))
applied_now.append(path.stem)
finally:
conn.execute("SELECT pg_advisory_unlock(%s)", (MIGRATION_LOCK_ID,))
return applied_now
def migrate_with_retry() -> None:
"""Для сервиса migrate: БД может подниматься дольше — ждём её, а не падаем сразу."""
deadline = time.monotonic() + config.DB_STARTUP_WAIT_SECONDS
while True:
try:
applied = migrate()
if applied:
log.info("Миграции применены: %s", ", ".join(applied))
else:
log.info("Миграции: новых нет, схема актуальна")
return
except psycopg.OperationalError as exc:
if time.monotonic() > deadline:
raise
log.warning("PostgreSQL пока недоступен (%s), повтор через 1 с", type(exc).__name__)
time.sleep(1)
def pending_migrations() -> list[str]:
"""Какие миграции этой версии ещё не применены (только чтение, схему не меняет)."""
expected = [path.stem for path in migration_files()]
with _connect("messenger-api-schema-check") as conn:
try:
done = {row[0] for row in conn.execute("SELECT version FROM schema_migrations")}
except psycopg.errors.UndefinedTable:
done = set() # миграции ещё ни разу не запускались
return [version for version in expected if version not in done]
def wait_for_schema() -> None:
"""Для реплики API: дождаться, пока сервис migrate применит все миграции этой версии.
Реплика схему не меняет. Если за DB_STARTUP_WAIT_SECONDS схема так и не стала
актуальной, процесс завершается с ошибкой: лучше не стартовать, чем работать
со схемой, которой код не понимает.
"""
deadline = time.monotonic() + config.DB_STARTUP_WAIT_SECONDS
while True:
try:
pending = pending_migrations()
if not pending:
log.info("Схема БД актуальна (миграции применены сервисом migrate)")
return
reason = "не применены миграции " + ", ".join(pending)
except psycopg.OperationalError as exc:
reason = f"PostgreSQL недоступен ({type(exc).__name__})"
if time.monotonic() > deadline:
raise RuntimeError(f"Схема БД не готова: {reason}. Запустите сервис migrate")
log.warning("Жду схему БД: %s; повтор через 1 с", reason)
time.sleep(1)
+61
View File
@@ -0,0 +1,61 @@
"""Ошибки приложения.
Каждый класс знает свой HTTP-статус и код из контракта, поэтому в api.py
достаточно одного обработчика, который превращает любую из них в JSON-ответ.
"""
class AppError(Exception):
status = 500
code = "internal_error"
def __init__(self, message: str, headers: dict[str, str] | None = None):
super().__init__(message)
self.message = message
self.headers = headers or {}
class InvalidRequest(AppError):
status, code = 400, "invalid_request"
class Unauthorized(AppError):
"""401. Контракт требует заголовок WWW-Authenticate: какую схему ждёт сервер."""
status, code = 401, "unauthorized"
BASIC = 'Basic realm="messenger", charset="UTF-8"' # только для POST /auth/sessions
BEARER = 'Bearer realm="messenger"' # для всех остальных защищённых запросов
def __init__(self, message: str, challenge: str = BEARER):
super().__init__(message, {"WWW-Authenticate": challenge})
class NotFound(AppError):
status, code = 404, "not_found"
class Conflict(AppError):
status, code = 409, "conflict"
class PayloadTooLarge(AppError):
"""413: файл больше MAX_UPLOAD_BYTES или картинка больше MAX_IMAGE_PIXELS (с lab4)."""
status, code = 413, "payload_too_large"
class UnsupportedMediaType(AppError):
"""415: не PNG/JPEG, повреждённый файл или Content-Type не совпадает с содержимым (с lab4)."""
status, code = 415, "unsupported_media_type"
class Unavailable(AppError):
"""503: нужная зависимость (PostgreSQL) недоступна. Клиент может повторить позже."""
status, code = 503, "unavailable"
class RateLimited(AppError):
"""429 (с lab7): превышен лимит частоты входа/регистрации. Retry-After — через сколько секунд можно снова."""
status, code = 429, "rate_limited"
def __init__(self, message: str, retry_after: int):
super().__init__(message, {"Retry-After": str(max(1, int(retry_after)))})
+96
View File
@@ -0,0 +1,96 @@
"""Внедрение отказов для проверок lab5 (только на учебном стенде, FAULTS_ENABLED=1).
Окна отказа из contracts/attachment-states.md нужно не описать, а воспроизвести: процесс должен
упасть ровно в нужном месте. Для этого в коде расставлены «точки отказа» hit("имя"). Точка
срабатывает, только если:
1. переменная FAULTS_ENABLED=1 (в .env учебного стенда, см. .env.example; в рабочей среде её нет — точки молчат);
2. внутри контейнера есть файл /tmp/faults/<имя>. Тест создаёт его через `docker exec`.
Срабатывание одноразовое: файл удаляется ДО падения, поэтому перезапущенный процесс
работает уже нормально. Падение — os._exit(137): мгновенно, без finally, без закрытия соединений
и без ack — так же, как при SIGKILL или OOM killer.
Точки:
- api_after_commit API: вложение, задание и outbox закоммичены, ответ 202 не отправлен;
- relay_before_publish relay: строки outbox взяты, в брокер ещё ничего не отправлено;
- relay_after_publish relay: брокер подтвердил приём, но строки ещё не отмечены отправленными;
- worker_after_objects worker: оригинал и варианты записаны в S3, COMMIT результата и ack не было;
- worker_after_commit worker: результат закоммичен, ack не отправлен.
Ещё два файла не роняют процесс, а меняют поведение (содержимое файла — число):
- worker_slow каждая обработка дополнительно «работает» N секунд (долгая задача);
- worker_transient следующие N попыток завершаются временной ошибкой (как недоступный S3);
- api_slow_handler (с lab6) обработчик POST сообщения «думает» N секунд до обращения к БД:
медленный HTTP handler при здоровой БД (сравнение с медленной БД в инциденте 2).
Точки-паузы (замечание к MR про уборщика): процесс один раз ждёт N секунд в опасном месте, чтобы
тест закрепил порядок событий («барьер») и вклинился в окно между двумя шагами:
- cleanup_pause уборщик прочитал ссылки из БД, но ещё ничего не удалял;
- cleanup_pause_locked уборщик под блокировкой вложения решил удалить и пометил staging удалённым,
COMMIT ещё не сделан (replay в это время ждёт блокировку);
- api_pause_after_staging API записал файл в staging, строки вложения в БД ещё нет;
- worker_pause_after_objects worker записал оригинал и варианты в S3, COMMIT результата ещё нет.
"""
import logging
import os
import time
log = logging.getLogger("messenger.faults")
ENABLED = os.environ.get("FAULTS_ENABLED", "").strip() == "1"
DIRECTORY = os.environ.get("FAULTS_DIR", "/tmp/faults")
def _path(name: str) -> str:
return os.path.join(DIRECTORY, name)
def hit(name: str) -> None:
"""Если точка включена — удалить её файл и мгновенно завершить процесс."""
if not ENABLED:
return
path = _path(name)
try:
os.remove(path)
except FileNotFoundError:
return
log.warning("FAULT %s: процесс завершается без ack/ответа (внедрённый отказ)", name)
for handler in logging.getLogger().handlers:
handler.flush()
os._exit(137)
def number(name: str) -> float:
"""Число из файла точки (worker_slow, worker_transient) или 0, если точка выключена."""
if not ENABLED:
return 0
try:
with open(_path(name), encoding="ascii") as f:
return float(f.read().strip() or 0)
except (FileNotFoundError, ValueError):
return 0
def pause(name: str) -> None:
"""Точка-пауза: если включена, удалить её файл (сработает один раз) и подождать N секунд."""
seconds = number(name)
if seconds <= 0:
return
try:
os.remove(_path(name))
except FileNotFoundError:
return
log.warning("FAULT %s: пауза %.1f с (внедрённая задержка для проверки гонок)", name, seconds)
time.sleep(seconds)
def consume(name: str) -> bool:
"""Для worker_transient: уменьшить счётчик на 1. True — эта попытка должна «упасть»."""
left = int(number(name))
if left <= 0:
return False
path = _path(name)
if left == 1:
os.remove(path)
else:
with open(path, "w", encoding="ascii") as f:
f.write(str(left - 1))
return True
+31
View File
@@ -0,0 +1,31 @@
"""Внутренний healthcheck-слушатель реплики (с lab7).
Основной порт API принимает только mTLS от балансировщика, а у Docker healthcheck клиентского
сертификата нет и быть не должно. Поэтому отдельный крошечный HTTP-сервер слушает 127.0.0.1
ВНУТРИ контейнера (из сети Docker его не видно) и отвечает только на GET /health/live и
/health/ready кодом 200 или 503 без тела. Бизнес-API через него недоступен: обхода mTLS нет.
"""
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
def start(port: int, ready) -> ThreadingHTTPServer:
class Handler(BaseHTTPRequestHandler):
def do_GET(self): # noqa: N802 (имя метода задаёт http.server)
if self.path == "/health/live":
code = 200
elif self.path == "/health/ready":
code = 200 if ready() else 503
else:
code = 404
self.send_response(code)
self.send_header("Content-Length", "0")
self.end_headers()
def log_message(self, *args): # проверки раз в несколько секунд в лог не пишем
pass
server = ThreadingHTTPServer(("127.0.0.1", port), Handler)
server.daemon_threads = True
threading.Thread(target=server.serve_forever, name="healthcheck", daemon=True).start()
return server
+641
View File
@@ -0,0 +1,641 @@
"""Проверка загружаемой картинки в API: имя файла, тип по содержимому, размер в пикселях, структура.
С lab5 API картинку не декодирует и не уменьшает: это тяжёлая работа, её делает worker
(imaging.py) в отдельном процессе с лимитами. Но «заведомо повреждённые и чужие» файлы
(contracts/README.md) отклоняются сразу, кодом 415, дешёвыми проверками без пиксельного буфера:
1. имя файла и заявленный Content-Type — до чтения тела (api.py);
2. размер в байтах — пока тело читается кусками (attachments.py);
3. тип по первым байтам («магическим числам»): PNG начинается с \\x89PNG, JPEG — с FF D8 FF;
Content-Type клиента обязан совпасть с настоящим типом, иначе 415 (подмена MIME);
4. ширина и высота — из заголовка, ДО распаковки пикселей: «бомба» (маленький файл
на 50 млн пикселей) отклоняется с 413, не заняв память;
5. структура файла, потоком, без пиксельного буфера:
- PNG: порядок и размеры обязательных блоков (IHDR, PLTE, IDAT, IEND), контрольная сумма
CRC каждого блока, допустимые сочетания глубины и типа цвета, размер палитры и tRNS,
ничего после IEND. Сжатые данные IDAT распаковываются порциями по 1 МиБ и только
считаются: распакованных байт должно быть ровно столько, сколько требуют ширина,
высота и формат пикселя (иначе файл обрезан или испорчен), а первый байт каждой строки —
допустимый тип фильтра 0–4 (Pillow неверный тип молча пропускает);
- JPEG: всё, что строгий декодер worker проверяет по маркерам и заголовкам: маркеры и длины
сегментов, кадр SOF, таблицы DQT/DHT, связь каждого скана SOS с компонентами кадра,
параметры сканов, порядок и число маркеров RST, маркер конца EOI (подробно — ниже, у check_jpeg).
Глубокую проверку (каждый пиксель, строгое декодирование сжатых данных JPEG) делает worker:
если файл не декодируется, вложение получает failed с error_code=invalid_image.
"""
import struct
import threading
import unicodedata
import warnings
import zlib
from dataclasses import dataclass
from PIL import Image
from . import config
from .errors import InvalidRequest, PayloadTooLarge, Unavailable, UnsupportedMediaType
ALLOWED_TYPES = ("image/png", "image/jpeg")
_SIGNATURES = {"image/png": b"\x89PNG\r\n\x1a\n", "image/jpeg": b"\xff\xd8\xff"}
_PIL_FORMAT = {"image/png": "PNG", "image/jpeg": "JPEG"}
# Символы управления направлением текста: позволяют показать «photo‮gnp.exe» как «photoexe.png».
_BIDI_CONTROLS = set("‪‫‬‭‮⁦⁧⁨⁩")
# Pillow сам считает «бомбой» картинку больше MAX_IMAGE_PIXELS: предупреждение делаем ошибкой.
Image.MAX_IMAGE_PIXELS = config.MAX_IMAGE_PIXELS
warnings.simplefilter("error", Image.DecompressionBombWarning)
_check_slots = threading.BoundedSemaphore(config.IMAGE_CHECK_CONCURRENCY)
_READ_BLOCK = 1024 * 1024
class Broken(Exception):
"""Структура файла нарушена (причина — короткий текст без содержимого файла)."""
@dataclass(frozen=True)
class ImageInfo:
content_type: str
width: int
height: int
def check_filename(filename: str | None) -> str:
"""filename — только отображаемое имя: в путь или ключ S3 он не попадает, но опасные отклоняем."""
if filename is None:
raise InvalidRequest("Нужен параметр filename")
if not 1 <= len(filename) <= 255 or not filename.strip():
raise InvalidRequest("filename: от 1 до 255 символов, не только пробелы")
if filename in (".", ".."):
raise InvalidRequest("filename не может быть . или ..")
for char in filename:
# Cc — управляющие символы (C0, DEL, C1); Zl/Zp — разделители строк и абзацев U+2028/U+2029.
if (char in "/\\" or unicodedata.category(char) in ("Cc", "Zl", "Zp") or char in _BIDI_CONTROLS):
raise InvalidRequest("filename содержит недопустимые символы (/, \\, управляющие)")
return filename
def declared_type(content_type_header: str | None) -> str:
"""Content-Type запроса: только image/png или image/jpeg (параметры после ; игнорируются)."""
media_type = (content_type_header or "").split(";", 1)[0].strip().lower()
if media_type not in ALLOWED_TYPES:
raise UnsupportedMediaType("Принимаются только image/png и image/jpeg")
return media_type
def sniff(head: bytes) -> str | None:
for media_type, signature in _SIGNATURES.items():
if head.startswith(signature):
return media_type
return None
def inspect(fileobj, declared: str) -> ImageInfo:
"""Проверить содержимое (файл уже целиком принят, размер в байтах проверен). Блокирующий код."""
fileobj.seek(0)
actual = sniff(fileobj.read(16))
if actual is None:
raise UnsupportedMediaType("Содержимое не является PNG или JPEG")
if actual != declared:
raise UnsupportedMediaType("Content-Type не совпадает с содержимым файла")
width, height = _header_size(fileobj, _PIL_FORMAT[actual])
if width * height > config.MAX_IMAGE_PIXELS:
raise PayloadTooLarge(f"Картинка больше {config.MAX_IMAGE_PIXELS} пикселей")
if not _check_slots.acquire(timeout=config.IMAGE_CHECK_WAIT_SECONDS):
raise Unavailable("Сервер занят проверкой картинок, повторите позже")
try:
fileobj.seek(0)
if actual == "image/png":
check_png(fileobj, width, height)
else:
check_jpeg(fileobj.read(), width, height)
except Broken as exc:
raise UnsupportedMediaType("Файл повреждён или не является корректной картинкой: " + str(exc)) from None
finally:
_check_slots.release()
return ImageInfo(actual, width, height)
def _header_size(fileobj, fmt: str) -> tuple[int, int]:
"""Ширина и высота из заголовка: Image.open читает только заголовок, пиксели не распаковывает."""
fileobj.seek(0)
try:
with Image.open(fileobj, formats=[fmt]) as img:
width, height = img.size
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
raise PayloadTooLarge(f"Картинка больше {config.MAX_IMAGE_PIXELS} пикселей") from None
except (OSError, SyntaxError, ValueError, EOFError, struct.error, IndexError, TypeError, zlib.error):
raise UnsupportedMediaType("Файл повреждён или не является корректной картинкой") from None
if width < 1 or height < 1:
raise UnsupportedMediaType("У картинки нулевой размер")
return width, height
# ---------- PNG ----------
_PNG_CHANNELS = {0: 1, 2: 3, 3: 1, 4: 2, 6: 4} # тип цвета -> каналов в пикселе
_PNG_DEPTHS = {0: {1, 2, 4, 8, 16}, 2: {8, 16}, 3: {1, 2, 4, 8}, 4: {8, 16}, 6: {8, 16}}
_ADAM7 = ((0, 0, 8, 8), (4, 0, 8, 8), (0, 4, 4, 8), (2, 0, 4, 4), (0, 2, 2, 4), (1, 0, 2, 2), (0, 1, 1, 2))
_PNG_CRITICAL = {b"IHDR", b"PLTE", b"IDAT", b"IEND"}
def png_passes(width: int, height: int, depth: int, color_type: int, interlace: int) -> list[tuple[int, int, int]]:
"""Как устроены распакованные данные IDAT: [(смещение прохода, строк, байт в строке с байтом фильтра)].
Без чересстрочности проход один; с Adam7 — до семи, у каждого свои ширина и высота.
"""
bits = depth * _PNG_CHANNELS[color_type]
sizes = ([(width, height)] if interlace == 0 else
[((width - x0 + dx - 1) // dx if width > x0 else 0, (height - y0 + dy - 1) // dy if height > y0 else 0)
for x0, y0, dx, dy in _ADAM7])
passes, offset = [], 0
for w, h in sizes:
if w and h:
row = 1 + (w * bits + 7) // 8
passes.append((offset, h, row))
offset += h * row
return passes
def png_raw_size(width: int, height: int, depth: int, color_type: int, interlace: int) -> int:
"""Сколько байт должно получиться после распаковки IDAT: строки + байт фильтра у каждой строки."""
return sum(rows * row for _start, rows, row in png_passes(width, height, depth, color_type, interlace))
def _check_filters(chunk: bytes, position: int, passes) -> None:
"""Первый байт каждой строки в этом куске распакованных данных — тип фильтра 0..4.
Байты фильтра стоят через равные промежутки, поэтому берутся срезом (это делает C-код),
без цикла Python по строкам: даже картинка 1×40 000 000 проверяется быстро.
"""
end = position + len(chunk)
for start, rows, row in passes:
stop = start + rows * row
if stop <= position or start >= end:
continue
first = max(position, start)
k = -(-(first - start) // row) # номер первой строки, начинающейся в этом куске
local = start + k * row - position
limit = min(end, stop) - position
if local < limit and max(chunk[local:limit:row]) > 4:
raise Broken("неверный тип фильтра строки")
def check_png(f, width: int, height: int) -> None:
f.seek(8)
ihdr = None
palette = None
seen_idat = idat_closed = seen_iend = False
inflater = zlib.decompressobj()
produced, expected, passes = 0, 0, []
def inflate(data: bytes) -> None:
nonlocal produced
if inflater.eof:
if data:
raise Broken("данные IDAT после конца сжатого потока")
return
try:
while data:
out = inflater.decompress(data, _READ_BLOCK) # не больше 1 МиБ за раз: память ограничена
if produced + len(out) > expected:
raise Broken("сжатых данных больше, чем пикселей")
_check_filters(out, produced, passes)
produced += len(out)
if inflater.eof:
if inflater.unused_data or inflater.unconsumed_tail:
raise Broken("данные IDAT после конца сжатого потока")
return
data = inflater.unconsumed_tail
except zlib.error:
raise Broken("сжатые данные IDAT испорчены") from None
while True:
head = f.read(8)
if not head:
break
if len(head) < 8:
raise Broken("файл обрывается внутри блока")
length, kind = struct.unpack(">I4s", head)
if length > 0x7FFFFFFF or not all(65 <= b <= 90 or 97 <= b <= 122 for b in kind):
raise Broken("неверный заголовок блока")
if seen_iend:
raise Broken("данные после IEND")
if ihdr is None and kind != b"IHDR":
raise Broken("первым должен быть IHDR")
if kind[0] < 97 and kind not in _PNG_CRITICAL: # заглавная первая буква = обязательный блок
raise Broken("неизвестный обязательный блок")
if kind == b"IDAT":
if idat_closed:
raise Broken("блоки IDAT идут не подряд")
seen_idat = True
elif seen_idat:
idat_closed = True
keep = kind in (b"IHDR", b"PLTE", b"tRNS")
if keep and length > 768:
raise Broken("слишком длинный служебный блок")
crc = zlib.crc32(kind)
kept = bytearray()
left = length
while left:
piece = f.read(min(left, _READ_BLOCK))
if not piece:
raise Broken("файл обрывается внутри блока")
left -= len(piece)
crc = zlib.crc32(piece, crc)
if keep:
kept += piece
if kind == b"IDAT":
inflate(piece)
stored = f.read(4)
if len(stored) < 4 or struct.unpack(">I", stored)[0] != crc & 0xFFFFFFFF:
raise Broken("неверная контрольная сумма блока")
if kind == b"IHDR":
if ihdr is not None or length != 13:
raise Broken("неверный IHDR")
w, h, depth, color, compression, filter_method, interlace = struct.unpack(">IIBBBBB", bytes(kept))
if (w, h) != (width, height) or color not in _PNG_DEPTHS or depth not in _PNG_DEPTHS[color]:
raise Broken("недопустимые параметры IHDR")
if compression != 0 or filter_method != 0 or interlace not in (0, 1):
raise Broken("недопустимые параметры IHDR")
ihdr = (depth, color)
passes = png_passes(w, h, depth, color, interlace)
expected = sum(rows * row for _start, rows, row in passes)
elif kind == b"PLTE":
depth, color = ihdr
if palette is not None or seen_idat or color in (0, 4):
raise Broken("неуместный PLTE")
entries, rest = divmod(length, 3)
if rest or not 1 <= entries <= 256 or (color == 3 and entries > 2 ** depth):
raise Broken("неверный размер палитры")
palette = entries
elif kind == b"tRNS":
depth, color = ihdr
allowed = {0: 2, 2: 6}.get(color)
if seen_idat or color in (4, 6):
raise Broken("неуместный tRNS")
if color == 3 and (palette is None or length > palette):
raise Broken("tRNS длиннее палитры")
if allowed is not None and length != allowed:
raise Broken("неверный размер tRNS")
elif kind == b"IDAT":
if ihdr[1] == 3 and palette is None:
raise Broken("нет палитры у картинки с палитрой")
elif kind == b"IEND":
if length != 0:
raise Broken("неверный IEND")
seen_iend = True
if not seen_iend:
raise Broken("нет IEND: файл обрезан")
if not seen_idat:
raise Broken("нет данных изображения (IDAT)")
if not inflater.eof:
raise Broken("сжатый поток IDAT обрывается")
if produced != expected:
raise Broken("распакованных данных меньше, чем пикселей")
# ---------- JPEG ----------
#
# Где граница между 415 и failed (contracts/README.md: «заведомо повреждённые/чужие форматы — 415»).
# Worker декодирует JPEG библиотекой libjpeg-turbo в строгом режиме (imaging.py): любое её
# предупреждение — ошибка. Всё, что она проверяет по маркерам и заголовкам, то есть ДО распаковки
# сжатых данных, API проверяет здесь сам, теми же правилами. Поэтому такой файл получает 415 сразу,
# а не 202 и потом failed. На worker остаются только ошибки внутри сжатых данных скана: их не найти,
# не декодировав каждый блок 8×8 (это и есть тяжёлая работа, которую API не делает).
#
# Что проверяется (правила libjpeg-turbo: jdmarker.c, jdinput.c, jdhuff.c, jdphuff.c, turbojpeg.c,
# и спецификации JPEG ITU-T T.81; совпадение с настоящим декодером проверяет тест в образе,
# student-tests/worker/test_imaging.py):
# - маркеры: только известные, без мусора между сегментами, длины сегментов, один SOI, EOI в конце;
# - кадр SOF: baseline/extended/progressive с кодом Хаффмана, 8 бит, размеры до 65500, 1/3/4 компонента
# с разными идентификаторами, коэффициенты субдискретизации 1–4 и схема, которую понимает декодер;
# - таблицы DQT/DHT/DAC/DRI: номера, размеры, коды Хаффмана помещаются в свою длину (иначе
# «Bogus Huffman table»), символы DC-таблиц 0–15; таблица должна быть определена до скана;
# - скан SOS: каждый компонент есть в SOF и не повторяется в скане, блоков в MCU не больше 10,
# параметры Ss/Se/Ah/Al (для последовательного JPEG 0/63/0/0, для прогрессивного — допустимая
# последовательность сканов), маркеры RST идут по порядку и их ровно столько, сколько задаёт DRI;
# - APP0 JFIF версии 1 и допустимый код преобразования Adobe (APP14).
# Кадры, которые декодирует libjpeg-turbo в Pillow: baseline, extended, progressive (код Хаффмана).
_SOF_SUPPORTED = {0xC0, 0xC1, 0xC2}
_SOF_OTHER = {0xC3, 0xC5, 0xC6, 0xC7, 0xC9, 0xCA, 0xCB, 0xCD, 0xCE, 0xCF} # lossless, arithmetic, hierarchical
# Сегменты, которые декодер разбирает или пропускает: DHT, DAC, DQT, DNL, DRI, APP0–APP15, COM.
# Остальные маркеры (JPG, DHP, EXP, JPGn, RES, TEM, RSTn вне скана) декодер считает ошибкой.
_SEGMENTS = {0xC4, 0xCC, 0xDB, 0xDC, 0xDD, 0xFE} | set(range(0xE0, 0xF0))
_JPEG_MAX_DIMENSION = 65500 # JPEG_MAX_DIMENSION libjpeg
_MAX_BLOCKS_IN_MCU = 10 # D_MAX_BLOCKS_IN_MCU libjpeg
# Схемы субдискретизации, которые понимает декодер worker (TurboJPEG): коэффициенты яркости при
# коэффициентах цветности 1×1 — 4:4:4, 4:2:2, 4:2:0, 4:4:0, 4:1:1. Оттенки серого — любые.
_LUMA_FACTORS = {(1, 1), (2, 1), (2, 2), (1, 2), (4, 1)}
def _subsampling_supported(factors: list[tuple[int, int]]) -> bool:
"""Распознаёт ли TurboJPEG схему субдискретизации (как getSubsamp в turbojpeg.c)."""
if len(factors) == 1:
return True
luma, chroma, black = factors[0], factors[1:3], factors[3:] # black — 4-й канал CMYK/YCCK
if luma in _LUMA_FACTORS and all(c == (1, 1) for c in chroma) and all(k == luma for k in black):
return True
if (luma == (2, 2) and chroma[0] == chroma[1] and chroma[0] in ((1, 2), (2, 1))
and all(k == (2, 2) for k in black)):
return True # 4:2:2 и 4:4:0, записанные «нестандартно» (яркость 2×2)
return luma[0] * luma[1] <= 3 and all(f == luma for f in factors[1:]) # 4:4:4: все коэффициенты равны
def _huffman_codes_fit(counts: bytes) -> bool:
"""Канонические коды Хаффмана помещаются в свои длины, и нет кода из одних единиц (рисунок C.2 T.81)."""
code = 0
for length, count in enumerate(counts, start=1):
code += count
if code >= 1 << length:
return False
code <<= 1
return True
@dataclass
class _Component:
ident: int
h: int
v: int
quant: int
quant_latched: bool = False # таблица квантования берётся при первом скане компонента
scans: int = 0
coef_bits: list | None = None # прогрессивный JPEG: последний Al каждого коэффициента, -1 — ещё не было
class _JpegCheck:
def __init__(self, data: bytes, width: int, height: int):
self.data, self.n, self.width, self.height = data, len(data), width, height
self.i = 2
self.components: list[_Component] | None = None
self.progressive = False
self.hmax = self.vmax = 1
self.quant: set[int] = set()
self.huffman: dict[tuple[int, int], tuple[bytes, bytes]] = {} # (0 — DC / 1 — AC, номер) -> (счётчики, символы)
self.restart_interval = 0
self.jfif = False
self.adobe_transform = None
self.scans = 0
self.full_scan = False # первый последовательный скан уже содержал все компоненты
def run(self) -> None:
if not self.data.startswith(b"\xff\xd8"):
raise Broken("нет маркера начала SOI")
while True:
marker = self._marker()
if marker == 0xD9: # EOI: конец картинки
break
if marker in _SOF_OTHER:
raise Broken("неподдерживаемый вид JPEG (lossless, arithmetic или hierarchical)")
if marker == 0xD8:
raise Broken("второй маркер SOI")
if marker not in _SOF_SUPPORTED and marker != 0xDA and marker not in _SEGMENTS:
raise Broken(f"недопустимый маркер 0x{marker:02X}")
segment = self._segment()
if marker in _SOF_SUPPORTED:
self._frame(marker, segment)
elif marker == 0xDA:
self._scan(segment)
elif marker == 0xC4:
self._dht(segment)
elif marker == 0xDB:
self._dqt(segment)
elif marker == 0xCC:
self._dac(segment)
elif marker == 0xDD:
if len(segment) != 2:
raise Broken("неверная длина DRI")
self.restart_interval = (segment[0] << 8) | segment[1]
elif marker == 0xE0 and len(segment) >= 14 and segment[:5] == b"JFIF\x00":
if segment[5] != 1:
raise Broken("неизвестная версия JFIF")
self.jfif = self.jfif or self.scans == 0
elif marker == 0xEE and len(segment) >= 12 and segment[:5] == b"Adobe" and self.scans == 0:
self.adobe_transform = segment[11]
if self.components is None or self.scans == 0:
raise Broken("нет данных изображения")
if not self.progressive and any(c.scans == 0 for c in self.components):
raise Broken("не все компоненты цвета закодированы в сканах")
# Данные ПОСЛЕ EOI допускаются: так устроены многие реальные фото (превью, «живые фото»).
# Клиенту файл отдаётся с Content-Type image/jpeg и nosniff, а варианты делаются заново.
def _marker(self) -> int:
data, n = self.data, self.n
if self.i >= n or data[self.i] != 0xFF:
raise Broken("лишние байты там, где должен быть маркер: файл испорчен или обрезан")
while self.i < n and data[self.i] == 0xFF: # байты-заполнители перед маркером
self.i += 1
if self.i >= n:
raise Broken("файл обрывается на маркере")
self.i += 1
return data[self.i - 1]
def _segment(self) -> bytes:
i = self.i
if i + 2 > self.n:
raise Broken("файл обрывается в сегменте")
length = (self.data[i] << 8) | self.data[i + 1]
if length < 2 or i + length > self.n:
raise Broken("неверная длина сегмента")
self.i = i + length
return self.data[i + 2:i + length]
def _frame(self, marker: int, segment: bytes) -> None:
if self.components is not None:
raise Broken("второй заголовок кадра SOF")
if len(segment) < 6:
raise Broken("неверный заголовок кадра SOF")
precision, rows, cols, count = struct.unpack(">BHHB", segment[:6])
if precision != 8:
raise Broken("поддерживается только 8 бит на канал")
if (cols, rows) != (self.width, self.height):
raise Broken("неверный заголовок кадра SOF")
if cols > _JPEG_MAX_DIMENSION or rows > _JPEG_MAX_DIMENSION:
raise Broken(f"ширина или высота больше {_JPEG_MAX_DIMENSION}")
if count not in (1, 3, 4) or len(segment) != 6 + 3 * count:
raise Broken("неверное число компонентов цвета в SOF (допустимо 1, 3 или 4)")
components = []
for k in range(count):
ident, factors, quant = segment[6 + 3 * k:9 + 3 * k]
h, v = factors >> 4, factors & 15
if not (1 <= h <= 4 and 1 <= v <= 4):
raise Broken("недопустимые коэффициенты субдискретизации")
if quant > 3:
raise Broken("неверный номер таблицы квантования")
if any(c.ident == ident for c in components):
raise Broken("повторяется идентификатор компонента в SOF")
components.append(_Component(ident, h, v, quant))
self.components = components
self.progressive = marker == 0xC2
self.hmax = max(c.h for c in components)
self.vmax = max(c.v for c in components)
def _dht(self, segment: bytes) -> None:
rest = segment
while rest:
if len(rest) < 17:
raise Broken("неверная таблица Хаффмана DHT")
index, counts = rest[0], rest[1:17]
total = sum(counts)
if total > 256 or total > len(rest) - 17:
raise Broken("неверная таблица Хаффмана DHT")
kind, number = (1, index - 0x10) if index & 0x10 else (0, index)
if not 0 <= number <= 3:
raise Broken("неверный номер таблицы Хаффмана")
self.huffman[(kind, number)] = (bytes(counts), bytes(rest[17:17 + total]))
rest = rest[17 + total:]
def _dqt(self, segment: bytes) -> None:
rest = segment
while rest:
precision, number = rest[0] >> 4, rest[0] & 15
if precision > 1 or number > 3:
raise Broken("неверная таблица квантования DQT")
size = 1 + 64 * (precision + 1)
if len(rest) < size:
raise Broken("таблица квантования DQT обрезана")
self.quant.add(number)
rest = rest[size:]
def _dac(self, segment: bytes) -> None:
if len(segment) % 2:
raise Broken("неверная длина DAC")
for k in range(0, len(segment), 2):
index, value = segment[k], segment[k + 1]
if index >= 32 or (index < 16 and (value & 15) > (value >> 4)):
raise Broken("неверный сегмент DAC")
def _huffman_table(self, kind: int, number: int) -> None:
"""Таблица, которую использует скан: определена и правильна (jpeg_make_d_derived_tbl)."""
if number > 3:
raise Broken("номер таблицы Хаффмана больше 3")
table = self.huffman.get((kind, number))
if table is None:
if not self.progressive and number <= 1:
return # последовательный декодер подставит стандартную таблицу (так пишет Motion JPEG)
raise Broken("скан использует неопределённую таблицу Хаффмана")
counts, symbols = table
if not symbols or not _huffman_codes_fit(counts):
raise Broken("неверная таблица Хаффмана: коды не помещаются в свою длину")
if kind == 0 and max(symbols) > 15:
raise Broken("неверная таблица Хаффмана DC")
def _first_scan(self) -> None:
"""Перед первым сканом декодер выбирает цветовое пространство и схему субдискретизации."""
count = len(self.components)
if count == 3 and not self.jfif and self.adobe_transform not in (None, 0, 1):
raise Broken("неизвестный код цветового преобразования Adobe")
if count == 4 and self.adobe_transform not in (None, 0, 2):
raise Broken("неизвестный код цветового преобразования Adobe")
if not _subsampling_supported([(c.h, c.v) for c in self.components]):
raise Broken("неподдерживаемая схема субдискретизации цвета")
def _scan(self, segment: bytes) -> None:
if self.components is None:
raise Broken("скан раньше заголовка кадра")
if self.scans == 0:
self._first_scan()
count = segment[0] if segment else 0
if not 1 <= count <= 4 or len(segment) != 4 + 2 * count:
raise Broken("неверный заголовок скана SOS")
members = []
for k in range(count):
ident, tables = segment[1 + 2 * k], segment[2 + 2 * k]
component = next((c for c in self.components if c.ident == ident), None)
if component is None:
raise Broken("скан ссылается на компонент, которого нет в заголовке кадра SOF")
if any(component is m[0] for m in members):
raise Broken("компонент повторяется в одном скане")
members.append((component, tables >> 4, tables & 15))
if count > 1 and sum(c.h * c.v for c, _dc, _ac in members) > _MAX_BLOCKS_IN_MCU:
raise Broken("слишком много блоков в MCU")
ss, se, ah, al = segment[-3], segment[-2], segment[-1] >> 4, segment[-1] & 15
if self.progressive:
self._progressive(members, ss, se, ah, al)
else:
self._sequential(members, ss, se, ah, al)
for component, _dc, _ac in members:
if not component.quant_latched:
if component.quant not in self.quant:
raise Broken("компонент использует неопределённую таблицу квантования")
component.quant_latched = True
restarts = self._entropy_data()
expected = (self._mcus(members) - 1) // self.restart_interval if self.restart_interval else 0
if restarts != expected:
raise Broken("маркеров RST не столько, сколько задаёт интервал DRI")
self.scans += 1
def _sequential(self, members, ss, se, ah, al) -> None:
if (ss, se, ah, al) != (0, 63, 0, 0):
raise Broken("неверные параметры Ss/Se/Ah/Al для последовательного JPEG")
if self.full_scan:
raise Broken("лишний скан: первый скан уже содержал все компоненты")
if self.scans == 0 and len(members) == len(self.components):
self.full_scan = True
for component, dc, ac in members:
if component.scans:
raise Broken("компонент закодирован в двух сканах")
component.scans += 1
self._huffman_table(0, dc)
self._huffman_table(1, ac)
def _progressive(self, members, ss, se, ah, al) -> None:
dc_band = ss == 0
bad = se != 0 if dc_band else (ss > se or se > 63 or len(members) != 1)
if bad or (ah and al != ah - 1) or al > 13:
raise Broken("неверные параметры прогрессивного скана")
for component, dc, ac in members:
bits = component.coef_bits = component.coef_bits or [-1] * 64
if not dc_band and bits[0] < 0:
raise Broken("прогрессивный скан: коэффициенты AC раньше DC")
for k in range(ss, se + 1):
if ah != max(bits[k], 0):
raise Broken("нарушена последовательность прогрессивных сканов")
bits[k] = al
component.scans += 1
if dc_band:
if ah == 0: # уточняющему DC-скану таблица не нужна
self._huffman_table(0, dc)
else:
self._huffman_table(1, ac)
def _mcus(self, members) -> int:
"""Сколько MCU в скане (per_scan_setup libjpeg): от этого зависит число маркеров RST."""
if len(members) == 1:
c = members[0][0]
return (-(-self.width * c.h // (self.hmax * 8))) * (-(-self.height * c.v // (self.vmax * 8)))
return (-(-self.width // (self.hmax * 8))) * (-(-self.height // (self.vmax * 8)))
def _entropy_data(self) -> int:
"""Пройти сжатые данные скана до следующего маркера. Возвращает число маркеров RST."""
data, n = self.data, self.n
start = i = self.i
restarts = 0
while True:
j = data.find(b"\xff", i)
if j < 0 or j + 1 >= n:
raise Broken("скан обрывается: нет маркера конца EOI (файл обрезан)")
following = data[j + 1]
if following == 0x00: # FF 00 — байт FF внутри данных
i = j + 2
elif following == 0xFF: # заполнитель перед маркером
i = j + 1
elif 0xD0 <= following <= 0xD7: # RSTn: номера идут по кругу 0..7, с 0 в каждом скане
if following != 0xD0 + restarts % 8:
raise Broken("маркеры RST идут не по порядку")
restarts += 1
i = j + 2
else:
break
if j == start:
raise Broken("пустой скан: нет сжатых данных изображения")
self.i = j
return restarts
def check_jpeg(data: bytes, width: int, height: int) -> None:
_JpegCheck(data, width, height).run()
+272
View File
@@ -0,0 +1,272 @@
"""Обработка картинки в worker (с lab5): полное декодирование и три варианта.
Модуль выполняется в ОТДЕЛЬНОМ дочернем процессе (sandbox.py), а не в самом worker:
у дочернего процесса свой лимит памяти и общий лимит времени. Если картинка оказалась
слишком «тяжёлой», убивается только дочерний процесс, worker продолжает работать.
Модуль ничего не знает про S3, PostgreSQL и брокер: на входе путь к файлу-оригиналу,
на выходе файлы вариантов в каталоге out_dir и их описание.
Варианты (contracts/README.md, «Фоновая обработка»):
- thumbnail — JPEG, вписан в 256×256 с сохранением пропорций, маленькие НЕ увеличиваются;
- crop — JPEG 128×128, центральный квадрат (маленькие увеличиваются, это разрешено контрактом);
- optimized — WebP, вписан в 1280×1280, маленькие НЕ увеличиваются.
Общие правила: размеры округляются вниз, минимум 1 px; ориентация из EXIF применяется;
у JPEG прозрачность накладывается на белый фон (в JPEG нет альфа-канала), WebP прозрачность
сохраняет. В варианты не попадают EXIF, XMP и ICC-профиль: метаданные (место съёмки, модель
камеры) не утекают. Параметры качества — в config.py (JPEG_QUALITY, WEBP_QUALITY, WEBP_METHOD).
Повтор той же задачи даёт те же самые байты (тот же вход, те же параметры, та же версия Pillow),
поэтому повторная запись варианта под тем же ключом S3 ничего не меняет (идемпотентность).
"""
import hashlib
import math
import os
import warnings
from dataclasses import dataclass
from PIL import Image
# simplejpeg — libjpeg-turbo в строгом режиме: любое предупреждение декодера (битые сжатые
# данные, обрыв скана) — ошибка. Pillow такие предупреждения молча пропускает и дорисовывает
# серым, поэтому JPEG сначала проверяется строго, а обрабатывается уже Pillow.
import simplejpeg
EXIF_ORIENTATION = 0x0112
# Как привести картинку к правильной ориентации (номер из EXIF -> операция Pillow).
_TRANSPOSE = {
2: Image.Transpose.FLIP_LEFT_RIGHT,
3: Image.Transpose.ROTATE_180,
4: Image.Transpose.FLIP_TOP_BOTTOM,
5: Image.Transpose.TRANSPOSE,
6: Image.Transpose.ROTATE_270,
7: Image.Transpose.TRANSVERSE,
8: Image.Transpose.ROTATE_90,
}
_SWAPS_AXES = {5, 6, 7, 8} # эти ориентации меняют местами ширину и высоту
_FORMAT = {"image/png": "PNG", "image/jpeg": "JPEG"}
class ImageError(Exception):
"""Ошибка, которая зависит только от самого файла: повтор её не исправит (постоянная)."""
code = "invalid_image"
class InvalidImage(ImageError):
code = "invalid_image"
class ImageTooLarge(ImageError):
code = "image_too_large"
@dataclass(frozen=True)
class Params:
max_pixels: int = 40_000_000
thumbnail: int = 256
crop: int = 128
optimized: int = 1280
jpeg_quality: int = 85
webp_quality: int = 80
webp_method: int = 4
def fit(width: int, height: int, box: int) -> tuple[int, int]:
"""Вписать в квадрат box×box без увеличения. Округление вниз, минимум 1 px.
Целочисленная арифметика, без float: 320×200 в 256 даёт ровно 256×160.
"""
if width <= box and height <= box:
return width, height
if width >= height:
return box, max(1, height * box // width)
return max(1, width * box // height), box
def _sha256(path: str) -> str:
digest = hashlib.sha256()
with open(path, "rb") as f:
for block in iter(lambda: f.read(1024 * 1024), b""):
digest.update(block)
return digest.hexdigest()
def _strict_jpeg_check(data: bytes) -> None:
"""Строгая проверка всех сжатых данных JPEG. Декодирование в масштабе 1/8: памяти в 64 раза меньше."""
try:
_h, _w, colorspace, _sub = simplejpeg.decode_jpeg_header(data)
target = "CMYK" if colorspace in ("CMYK", "YCCK") else ("GRAY" if colorspace == "Gray" else "RGB")
simplejpeg.decode_jpeg(data, colorspace=target, strict=True, min_factor=8)
except (ValueError, KeyError):
# KeyError: simplejpeg не знает некоторых схем субдискретизации TurboJPEG 3 (например, 4:4:1).
# API такие JPEG отклоняет сам (images._subsampling_supported), здесь — вторая линия защиты.
raise InvalidImage("JPEG повреждён или не поддерживается: libjpeg-turbo в строгом режиме нашёл ошибку") from None
def _orientation(img) -> int:
try:
value = int(img.getexif().get(EXIF_ORIENTATION, 1))
except Exception: # битый EXIF не мешает обработке: считаем ориентацию обычной
return 1
return value if value in range(1, 9) else 1
def _normalize(img):
"""Режим, с которым умеют работать resize и кодировщики: RGB, RGBA или L (оттенки серого).
Если режим уже подходит, возвращается та же картинка, без копии: у 40 Мп RGBA копия — это
ещё 160 МиБ.
"""
if img.mode in ("I;16", "I"):
# 16 бит -> 8 бит: делим на 257 (65535 -> 255), иначе convert("L") обрезал бы яркость до 255.
return img.point(lambda value: value * (1 / 257)).convert("L")
if img.mode.startswith("I;16"): # редкий порядок байтов: через 32-битный режим
return img.convert("I").point(lambda value: value * (1 / 257)).convert("L")
if img.has_transparency_data:
target = "RGBA"
elif img.mode in ("1", "L"):
target = "L"
else:
target = "RGB"
return img if img.mode == target else img.convert(target)
def _on_white(img):
"""JPEG не хранит прозрачность: накладываем на белый фон, как требует контракт."""
if img.mode != "RGBA":
return img
background = Image.new("RGB", img.size, (255, 255, 255))
background.paste(img, mask=img.getchannel("A"))
return background
def _resize(img, size, box=None):
if box is None and img.size == size:
return img
# reducing_gap: сначала быстрое уменьшение в целое число раз, потом точный LANCZOS.
return img.resize(size, Image.Resampling.LANCZOS, box=box, reducing_gap=3.0)
def _save(img, path: str, fmt: str, params: Params) -> None:
img.info = {} # ни EXIF, ни XMP, ни ICC-профиля исходника в вариант не переносим
if fmt == "JPEG":
img.save(path, "JPEG", quality=params.jpeg_quality, optimize=True)
else:
img.save(path, "WEBP", quality=params.webp_quality, method=params.webp_method)
def process(src_path: str, out_dir: str, content_type: str, params: Params = Params()) -> dict:
"""Проверить и обработать оригинал. Возвращает описание исходника и трёх вариантов.
Ошибки: InvalidImage (нельзя декодировать), ImageTooLarge (лимит пикселей), MemoryError
(не хватило лимита памяти процесса) — все постоянные. Остальное — неожиданная ошибка.
"""
fmt = _FORMAT.get(content_type)
if fmt is None:
raise InvalidImage("Неподдерживаемый тип")
Image.MAX_IMAGE_PIXELS = params.max_pixels
with warnings.catch_warnings():
warnings.simplefilter("error", Image.DecompressionBombWarning)
try:
img = Image.open(src_path, formats=[fmt])
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
raise ImageTooLarge("Картинка больше лимита пикселей") from None
except (OSError, SyntaxError, ValueError, EOFError):
raise InvalidImage("Файл не открывается как " + fmt) from None
with img:
width, height = img.size
if width < 1 or height < 1:
raise InvalidImage("Нулевой размер")
if width * height > params.max_pixels:
raise ImageTooLarge("Картинка больше лимита пикселей")
if fmt == "JPEG":
with open(src_path, "rb") as f:
_strict_jpeg_check(f.read())
orientation = _orientation(img)
# Размеры с учётом ориентации (как картинку увидит человек).
ow, oh = (height, width) if orientation in _SWAPS_AXES else (width, height)
thumb_o, opt_o = fit(ow, oh, params.thumbnail), fit(ow, oh, params.optimized)
if fmt == "JPEG":
# draft: libjpeg сразу декодирует в уменьшенном масштабе (1/2, 1/4, 1/8), если
# этого хватает для самого большого варианта. Память и время — в разы меньше.
need = min(1.0, max(opt_o[0] / ow, opt_o[1] / oh, params.crop / min(ow, oh)))
img.draft(img.mode, (math.ceil(width * need), math.ceil(height * need)))
try:
img.load()
except (Image.DecompressionBombError, Image.DecompressionBombWarning):
raise ImageTooLarge("Картинка больше лимита пикселей") from None
except MemoryError:
raise
except (OSError, SyntaxError, ValueError, EOFError, IndexError, TypeError):
raise InvalidImage("Файл повреждён: декодирование не удалось") from None
base = _normalize(img)
mode = base.mode
if base is not img:
img.close() # декодированный исходник больше не нужен: освобождаем память
transpose = _TRANSPOSE.get(orientation)
def stored(size): # размер с учётом ориентации -> размер в ориентации файла
return (size[1], size[0]) if orientation in _SWAPS_AXES else size
def oriented(image):
return image.transpose(transpose) if transpose is not None else image
# Память: полноразмерная картинка нужна только для ОДНОГО resize — в optimized (≤1280).
# thumbnail и crop делаются уже из него, а оригинал сразу освобождается. Исключение —
# очень вытянутые картинки, у которых короткая сторона optimized меньше 128 px:
# для них crop берётся из полноразмерной картинки, чтобы не терять качество.
optimized_stored = _resize(base, stored(opt_o))
source_for_crop = optimized_stored if min(optimized_stored.size) >= params.crop else base
if optimized_stored is not base and source_for_crop is not base:
base.close() # полноразмерная картинка больше не нужна
del base
os.makedirs(out_dir, exist_ok=True)
variants = []
def emit(name, image, fmt_out, ext):
path = os.path.join(out_dir, name + ext)
_save(image, path, fmt_out, params)
variants.append({"name": name, "path": path,
"content_type": "image/jpeg" if fmt_out == "JPEG" else "image/webp",
"width": image.size[0], "height": image.size[1],
"size_bytes": os.path.getsize(path), "sha256": _sha256(path)})
thumb = oriented(_resize(optimized_stored, stored(thumb_o)))
if thumb.size != thumb_o:
raise RuntimeError("thumbnail: неожиданный размер")
emit("thumbnail", _on_white(thumb), "JPEG", ".jpg")
cw, ch = source_for_crop.size # центральный квадрат; от поворота его положение не зависит
side = min(cw, ch)
left, top = (cw - side) // 2, (ch - side) // 2
crop = oriented(_resize(source_for_crop, (params.crop, params.crop), box=(left, top, left + side, top + side)))
emit("crop", _on_white(crop), "JPEG", ".jpg")
del source_for_crop
optimized = oriented(optimized_stored)
if optimized.size != opt_o:
raise RuntimeError("optimized: неожиданный размер")
if optimized.mode == "L":
optimized = optimized.convert("RGB")
emit("optimized", optimized, "WEBP", ".webp")
return {"source": {"width": width, "height": height, "orientation": orientation, "mode": mode},
"variants": variants}
def sniff_bytes(data: bytes) -> str | None:
"""Тип по первым байтам (для самопроверки worker)."""
if data.startswith(b"\x89PNG\r\n\x1a\n"):
return "image/png"
if data.startswith(b"\xff\xd8\xff"):
return "image/jpeg"
return None
if __name__ == "__main__": # ручная проверка: python -m messenger.imaging файл.png каталог
import json
import sys
with open(sys.argv[1], "rb") as f:
kind = sniff_bytes(f.read(16))
print(json.dumps(process(sys.argv[1], sys.argv[2], kind or ""), ensure_ascii=False, indent=1))
+486
View File
@@ -0,0 +1,486 @@
"""Задания обработки вложений в PostgreSQL (с lab5): состояния, lease, повторы, outbox, replay.
Источник истины о задании — строка attachment_jobs, а не сообщение в брокере. Брокер только
доставляет «напоминание»: обработай задание job_id, попытку attempt. Поэтому дубль, устаревшее
или потерянное сообщение ничего не ломают — решение принимается по строке задания:
сообщение (job_id, attempt) что делает worker
задание ready / failed -> ack, ничего не делает (повтор не создаёт второй набор)
attempt в сообщении устарел -> ack, ничего не делает (есть сообщение новее)
processing, lease действует -> ack, ничего не делает (задание уже обрабатывается)
processing, lease истёк -> попытка считается неудачной, назначается следующая
queued, attempt совпадает -> взять под lease и обработать
Переходы (contracts/attachment-states.md):
queued -> processing claim(): lease с жетоном (token) и сроком (lease_until);
processing -> ready complete(): только с тем же жетоном (fencing);
processing -> queued retry() при временной ошибке или reap() при истёкшем lease:
attempt+1, пауза backoff с jitter, новая строка outbox;
processing -> failed fail() при постоянной ошибке или когда попытки исчерпаны;
failed -> queued replay(): явная команда оператора, с записью в журнал.
Каждый переход — одна транзакция: строка задания, статус вложения, outbox и журнал
меняются вместе или не меняются вовсе.
С lab6 в каждой строке outbox есть W3C traceparent (contracts/jobs.schema.json, необязательное поле):
- при загрузке — span HTTP-запроса upload;
- при повторе из worker — span обработки задания (consumer), поэтому повтор — продолжение той же трассы;
- без активного span (истёкший lease в фоновом потоке, страховочная переотправка, replay оператора) —
traceparent прошлой строки этого задания: цепочка не рвётся.
complete() возвращает время от durable acceptance (attachments.created_at, транзакция загрузки)
до COMMIT ready — для гистограммы messenger.attachment.time_to_ready.
"""
import argparse
import json
import logging
import random
import sys
import uuid
from contextlib import contextmanager
from dataclasses import dataclass
import psycopg
from psycopg.types.json import Jsonb
from psycopg_pool import PoolTimeout
from . import broker, config, telemetry
from .errors import Unavailable
log = logging.getLogger("messenger.jobs")
def backoff(attempt: int) -> float:
"""Пауза перед попыткой attempt+1. «Равный jitter»: случайно в [d/2, d], d = min(MAX, BASE·2^(attempt-1)).
Удвоение даёт временному сбою время пройти. Случайная часть разводит по времени задания,
упавшие одновременно (например, все при остановке S3): иначе они повторялись бы одной волной.
"""
limit = min(config.RETRY_MAX_SECONDS, config.RETRY_BASE_SECONDS * 2 ** (attempt - 1))
return limit / 2 + random.uniform(0, limit / 2)
def predecessor_of(owner: str | None, me: str) -> bool:
"""owner — прошлая жизнь ЭТОГО ЖЕ контейнера (тот же hostname, другой запуск)?
В контейнере один процесс worker. Если lease держит прежний запуск того же контейнера,
значит, тот процесс точно мёртв (контейнер перезапустился): ждать истечения lease не нужно.
"""
if not owner:
return False
return owner.partition("/")[0] == me.partition("/")[0] and owner != me
@dataclass(frozen=True)
class Lease:
job_id: str
attachment_id: str
pipeline_version: int
attempt: int
max_attempts: int
token: str
staging_key: str | None
storage_key: str
content_type: str
size_bytes: int
sha256: str
width: int
height: int
@dataclass(frozen=True)
class Decision:
kind: str # claimed | ready | failed | stale | in_progress | rescheduled | unknown
lease: Lease | None = None
detail: str = ""
def event(conn, job_id, attachment_id, attempt, name: str, actor: str, detail: str | None = None) -> None:
conn.execute("""INSERT INTO job_events (job_id, attachment_id, attempt, event, actor, detail)
VALUES (%s, %s, %s, %s, %s, %s)""",
(job_id, attachment_id, attempt, name, actor[:120], detail[:300] if detail else None))
def enqueue(conn, job_id, attachment_id, pipeline_version: int, attempt: int, delay_seconds: float = 0.0) -> None:
"""Строка outbox в ТЕКУЩЕЙ транзакции: сообщение уйдёт в брокер не раньше чем через delay_seconds."""
payload = broker.build_message(str(job_id), str(attachment_id), pipeline_version, attempt)
telemetry.inject(payload)
if "traceparent" not in payload:
row = conn.execute("""SELECT payload->>'traceparent', payload->>'tracestate' FROM outbox
WHERE job_id = %s AND payload ? 'traceparent' ORDER BY id DESC LIMIT 1""",
(job_id,)).fetchone()
if row is not None:
payload["traceparent"] = row[0]
if row[1]:
payload["tracestate"] = row[1]
conn.execute("""INSERT INTO outbox (job_id, attempt, payload, available_at)
VALUES (%s, %s, %s, now() + make_interval(secs => %s))""",
(job_id, attempt, Jsonb(payload), delay_seconds))
def create(conn, attachment_id, actor: str) -> uuid.UUID:
"""Новое задание для только что принятого вложения (в транзакции загрузки, см. store.py)."""
job_id = uuid.uuid4()
conn.execute("""INSERT INTO attachment_jobs (job_id, attachment_id, pipeline_version, status, attempt, max_attempts)
VALUES (%s, %s, %s, 'queued', 1, %s)""",
(job_id, attachment_id, config.PIPELINE_VERSION, config.JOB_MAX_ATTEMPTS))
enqueue(conn, job_id, attachment_id, config.PIPELINE_VERSION, 1)
event(conn, job_id, attachment_id, 1, "queued", actor, "загрузка принята, оригинал в staging")
return job_id
_CLEAR_LEASE = "lease_owner = NULL, lease_token = NULL, lease_until = NULL"
class LockBusy(Exception):
"""Строку задания дольше lock_timeout держит другая транзакция (уборщик, worker)."""
class JobStore:
def __init__(self, pool, actor: str):
self.pool = pool
self.actor = actor # кто выполняет переходы: worker-<id> или operator
@contextmanager
def _tx(self):
try:
with self.pool.connection() as conn:
with conn.transaction():
yield conn
except (psycopg.OperationalError, PoolTimeout) as exc:
log.warning("PostgreSQL недоступен: %s", type(exc).__name__)
raise Unavailable("PostgreSQL недоступен") from None
# ---------- переход «попытка закончилась неудачей» ----------
def _attempt_over(self, conn, job_id, attachment_id, version, attempt, max_attempts,
code: str, message: str, permanent: bool) -> str:
"""processing -> queued (следующая попытка через backoff) или -> failed. Возвращает retry|failed."""
if permanent or attempt >= max_attempts:
final = code if permanent else "retry_exhausted"
conn.execute(f"""UPDATE attachment_jobs SET status = 'failed', {_CLEAR_LEASE},
last_error_code = %s, last_error = %s, finished_at = now(), updated_at = now()
WHERE job_id = %s""", (code, message[:300], job_id))
conn.execute("""UPDATE attachments SET status = 'failed', error_code = %s, updated_at = now()
WHERE id = %s AND status IN ('queued', 'processing')""", (final, attachment_id))
event(conn, job_id, attachment_id, attempt, "failed", self.actor,
f"{final}; последняя ошибка {code}: {message}")
return "failed"
delay = backoff(attempt)
conn.execute(f"""UPDATE attachment_jobs SET status = 'queued', attempt = attempt + 1, {_CLEAR_LEASE},
next_attempt_at = now() + make_interval(secs => %s),
last_error_code = %s, last_error = %s, updated_at = now()
WHERE job_id = %s""", (delay, code, message[:300], job_id))
conn.execute("""UPDATE attachments SET status = 'queued', updated_at = now()
WHERE id = %s AND status IN ('queued', 'processing')""", (attachment_id,))
enqueue(conn, job_id, attachment_id, version, attempt + 1, delay)
event(conn, job_id, attachment_id, attempt, "retry_scheduled", self.actor,
f"{code}: {message}; попытка {attempt + 1} через {delay:.1f} с")
return "retry"
# ---------- worker ----------
def claim(self, message: dict, worker_id: str) -> Decision:
"""Решить, что делать с доставленным сообщением, и при необходимости взять задание под lease."""
with self._tx() as conn:
row = conn.execute(
"""SELECT j.job_id, j.attachment_id, j.pipeline_version, j.status, j.attempt, j.max_attempts,
j.lease_owner, j.lease_until < now(),
a.staging_key, a.storage_key, a.content_type, a.size_bytes, a.sha256, a.width, a.height
FROM attachment_jobs j JOIN attachments a ON a.id = j.attachment_id
WHERE j.job_id = %s FOR UPDATE OF j""", (uuid.UUID(message["job_id"]),)).fetchone()
if row is None:
return Decision("unknown", detail="нет такого задания")
(job_id, attachment_id, version, status, attempt, max_attempts, owner, expired,
staging_key, storage_key, content_type, size_bytes, sha256, width, height) = row
if str(attachment_id) != message["attachment_id"] or version != message["pipeline_version"]:
return Decision("unknown", detail="сообщение не совпадает с заданием")
if status in ("ready", "failed"):
event(conn, job_id, attachment_id, message["attempt"], "duplicate_ignored", self.actor,
f"задание уже {status}: повторная доставка, ack без обработки")
return Decision(status)
if message["attempt"] != attempt:
event(conn, job_id, attachment_id, message["attempt"], "stale_ignored", self.actor,
f"устаревшее сообщение: актуальная попытка {attempt}")
return Decision("stale")
if status == "processing":
if owner == worker_id:
return Decision("in_progress", detail="уже обрабатывается этим worker")
dead = predecessor_of(owner, worker_id)
if not expired and not dead:
event(conn, job_id, attachment_id, attempt, "duplicate_in_progress", self.actor,
"задание под действующим lease другого worker")
return Decision("in_progress")
reason = "прежний запуск этого контейнера упал" if dead else "lease истёк"
event(conn, job_id, attachment_id, attempt, "lease_expired", self.actor, reason)
outcome = self._attempt_over(conn, job_id, attachment_id, version, attempt, max_attempts,
"worker_crashed", reason, permanent=False)
return Decision("rescheduled", detail=outcome)
token = uuid.uuid4()
conn.execute("""UPDATE attachment_jobs SET status = 'processing', lease_owner = %s, lease_token = %s,
lease_until = now() + make_interval(secs => %s), updated_at = now()
WHERE job_id = %s""", (worker_id, token, config.JOB_LEASE_SECONDS, job_id))
conn.execute("""UPDATE attachments SET status = 'processing', updated_at = now()
WHERE id = %s AND status IN ('queued', 'processing')""", (attachment_id,))
event(conn, job_id, attachment_id, attempt, "claimed", self.actor,
f"lease на {config.JOB_LEASE_SECONDS} с")
return Decision("claimed", Lease(str(job_id), str(attachment_id), version, attempt, max_attempts, str(token),
staging_key, storage_key, content_type, int(size_bytes), sha256,
int(width), int(height)))
def renew(self, tokens: list[str]) -> set[str]:
"""Продлить lease заданий, которые этот worker ещё обрабатывает. Возвращает продлённые жетоны.
Жетона нет в ответе — lease уже забрали (истёк и задание переназначено): работу надо бросить.
"""
if not tokens:
return set()
with self._tx() as conn:
rows = conn.execute("""UPDATE attachment_jobs
SET lease_until = now() + make_interval(secs => %s), updated_at = now()
WHERE status = 'processing' AND lease_token = ANY(%s::uuid[])
RETURNING lease_token""",
(config.JOB_LEASE_SECONDS, [uuid.UUID(t) for t in tokens])).fetchall()
return {str(r[0]) for r in rows}
def _fenced(self, conn, lease: Lease):
"""Строка задания, если lease всё ещё наш (тот же жетон). Иначе None: результат не принимается."""
return conn.execute("""SELECT attempt, max_attempts FROM attachment_jobs
WHERE job_id = %s AND lease_token = %s AND status = 'processing'
FOR UPDATE""", (uuid.UUID(lease.job_id), uuid.UUID(lease.token))).fetchone()
def complete(self, lease: Lease, variants: list[dict]) -> float | None:
"""processing -> ready: варианты, статус вложения и задания — одной транзакцией.
Возвращает секунды от принятия загрузки до ready или None, если lease уже не наш.
"""
with self._tx() as conn:
if self._fenced(conn, lease) is None:
return None
attachment_id, job_id = uuid.UUID(lease.attachment_id), uuid.UUID(lease.job_id)
for v in variants:
# Первичный ключ (attachment_id, pipeline_version, name) — ключ эффекта: второй набор невозможен.
conn.execute("""INSERT INTO attachment_variants (attachment_id, pipeline_version, name, storage_key,
content_type, size_bytes, width, height, sha256, job_id)
VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
ON CONFLICT (attachment_id, pipeline_version, name) DO UPDATE SET
storage_key = EXCLUDED.storage_key, content_type = EXCLUDED.content_type,
size_bytes = EXCLUDED.size_bytes, width = EXCLUDED.width,
height = EXCLUDED.height, sha256 = EXCLUDED.sha256, job_id = EXCLUDED.job_id""",
(attachment_id, lease.pipeline_version, v["name"], v["storage_key"], v["content_type"],
v["size_bytes"], v["width"], v["height"], v["sha256"], job_id))
row = conn.execute("""UPDATE attachments SET status = 'ready', error_code = NULL, updated_at = now()
WHERE id = %s AND status IN ('queued', 'processing')
RETURNING EXTRACT(EPOCH FROM clock_timestamp() - created_at)""",
(attachment_id,)).fetchone()
conn.execute(f"""UPDATE attachment_jobs SET status = 'ready', {_CLEAR_LEASE},
finished_at = now(), updated_at = now()
WHERE job_id = %s""", (job_id,))
event(conn, job_id, attachment_id, lease.attempt, "ready", self.actor,
"оригинал опубликован, варианты: " + ", ".join(v["name"] for v in variants))
return float(row[0]) if row is not None else 0.0
def fail(self, lease: Lease, code: str, message: str) -> bool:
"""Постоянная ошибка: processing -> failed сразу, без повторов."""
with self._tx() as conn:
row = self._fenced(conn, lease)
if row is None:
return False
self._attempt_over(conn, uuid.UUID(lease.job_id), uuid.UUID(lease.attachment_id), lease.pipeline_version,
row[0], row[1], code, message, permanent=True)
return True
def retry(self, lease: Lease, code: str, message: str) -> str:
"""Временная ошибка: следующая попытка с backoff или failed. Возвращает retry | failed | lost."""
with self._tx() as conn:
row = self._fenced(conn, lease)
if row is None:
return "lost"
return self._attempt_over(conn, uuid.UUID(lease.job_id), uuid.UUID(lease.attachment_id),
lease.pipeline_version, row[0], row[1], code, message, permanent=False)
def reap(self, limit: int = 50) -> list[tuple[str, str]]:
"""Задания с истёкшим lease (worker умер или завис и не продлевал аренду) -> следующая попытка."""
done = []
with self._tx() as conn:
rows = conn.execute("""SELECT job_id, attachment_id, pipeline_version, attempt, max_attempts, lease_owner
FROM attachment_jobs
WHERE status = 'processing' AND lease_until < now()
ORDER BY lease_until LIMIT %s
FOR UPDATE SKIP LOCKED""", (limit,)).fetchall()
for job_id, attachment_id, version, attempt, max_attempts, owner in rows:
event(conn, job_id, attachment_id, attempt, "lease_expired", self.actor,
f"lease {owner} истёк: worker не продлил аренду (упал или завис)")
done.append((str(attachment_id), self._attempt_over(
conn, job_id, attachment_id, version, attempt, max_attempts,
"lease_expired", "worker не продлил lease", permanent=False)))
return done
def republish_stale(self, age_seconds: int, limit: int = 50) -> int:
"""Страховка: задание давно в queued, а свежей отправки нет — отправить сообщение ещё раз."""
with self._tx() as conn:
rows = conn.execute(
"""SELECT j.job_id, j.attachment_id, j.pipeline_version, j.attempt FROM attachment_jobs j
WHERE j.status = 'queued' AND j.next_attempt_at < now() - make_interval(secs => %s)
AND NOT EXISTS (SELECT 1 FROM outbox o WHERE o.job_id = j.job_id AND o.attempt = j.attempt
AND (o.published_at IS NULL
OR o.published_at > now() - make_interval(secs => %s)))
LIMIT %s FOR UPDATE OF j SKIP LOCKED""", (age_seconds, age_seconds, limit)).fetchall()
for job_id, attachment_id, version, attempt in rows:
enqueue(conn, job_id, attachment_id, version, attempt)
event(conn, job_id, attachment_id, attempt, "republished", self.actor,
f"нет обработки дольше {age_seconds} с: сообщение отправлено повторно")
return len(rows)
# ---------- оператор ----------
def replay(self, attachment_id: str, staging_exists) -> dict:
"""failed -> queued по команде оператора. Готовое или ещё идущее задание НЕ повторяется.
Всё в ОДНОЙ транзакции под блокировкой строк задания и вложения — тех же, что берёт уборщик
(store.cleanup_attachment), в том же порядке. Поэтому уборщик не удалит staging между
проверкой исходника и переводом в queued (замечание к MR):
- уборщик успел раньше: он уже пометил staging удалённым (staging_key = NULL) и удалил его,
replay ждал блокировку и теперь безопасно отказывает (source_missing), задание остаётся failed;
- replay успел раньше: уборщик ждёт блокировку, потом видит queued — исходник нужен текущей
работе, и он его не трогает.
Наличие объекта в S3 (staging_exists) проверяется тоже под блокировкой.
"""
aid = uuid.UUID(attachment_id)
try:
return self._replay(aid, staging_exists)
except LockBusy:
return {"result": "busy", "detail": "вложение сейчас обрабатывает уборщик или worker, повторите позже"}
def _replay(self, aid: uuid.UUID, staging_exists) -> dict:
with self._tx() as conn:
# Команда оператора может подождать блокировку дольше обычного запроса (5 с).
conn.execute("SET LOCAL lock_timeout = '20s'")
conn.execute("SET LOCAL statement_timeout = '25s'")
try:
row = conn.execute("""SELECT job_id, status, attempt, last_error_code FROM attachment_jobs
WHERE attachment_id = %s AND pipeline_version = %s FOR UPDATE""",
(aid, config.PIPELINE_VERSION)).fetchone()
if row is None:
return {"result": "not_found"}
staging_key, error_code = conn.execute(
"SELECT staging_key, error_code FROM attachments WHERE id = %s FOR UPDATE", (aid,)).fetchone()
except psycopg.errors.LockNotAvailable:
raise LockBusy() from None
job_id, status, attempt, last_code = row
if status != "failed":
event(conn, job_id, aid, attempt, "replay_refused", self.actor,
f"задание в состоянии {status}: повторять нечего")
return {"result": "noop", "reason": status}
if not staging_key or not staging_exists(staging_key):
detail = "оригинал в staging уже удалён (истёк STAGING_RETENTION_SECONDS)"
event(conn, job_id, aid, attempt, "replay_refused", self.actor, "source_missing: " + detail)
return {"result": "refused", "reason": "source_missing", "detail": detail}
new_attempt = attempt + 1
conn.execute(f"""UPDATE attachment_jobs SET status = 'queued', attempt = %s, max_attempts = %s,
{_CLEAR_LEASE}, next_attempt_at = now(), finished_at = NULL, updated_at = now()
WHERE job_id = %s""", (new_attempt, attempt + config.JOB_MAX_ATTEMPTS, job_id))
conn.execute("""UPDATE attachments SET status = 'queued', error_code = NULL, updated_at = now()
WHERE id = %s AND status = 'failed'""", (aid,))
enqueue(conn, job_id, aid, config.PIPELINE_VERSION, new_attempt)
event(conn, job_id, aid, new_attempt, "replay_requested", self.actor,
f"replay оператора: было {error_code} (последняя ошибка {last_code}); "
f"новая попытка {new_attempt}, ещё {config.JOB_MAX_ATTEMPTS} попыток")
return {"result": "queued", "attempt": new_attempt, "previous_error": error_code}
def failed(self, limit: int = 50) -> list[dict]:
"""Реестр failed для оператора: что упало, с каким кодом, сколько было попыток."""
with self._tx() as conn:
rows = conn.execute("""SELECT j.attachment_id, j.job_id, a.error_code, j.last_error_code, j.last_error,
j.attempt, j.finished_at
FROM attachment_jobs j JOIN attachments a ON a.id = j.attachment_id
WHERE j.status = 'failed' ORDER BY j.finished_at DESC LIMIT %s""",
(limit,)).fetchall()
return [{"attachment_id": str(r[0]), "job_id": str(r[1]), "error_code": r[2], "last_error_code": r[3],
"last_error": r[4], "attempts": r[5], "finished_at": r[6].isoformat() if r[6] else None}
for r in rows]
def show(self, attachment_id: str) -> dict:
"""Всё о задании вложения: состояние, журнал, строки outbox, варианты (без ключей доступа)."""
with self._tx() as conn:
job = conn.execute("""SELECT job_id, status, attempt, max_attempts, lease_owner, lease_until,
next_attempt_at, last_error_code, last_error, created_at, finished_at
FROM attachment_jobs WHERE attachment_id = %s""",
(uuid.UUID(attachment_id),)).fetchone()
if job is None:
return {"result": "not_found"}
events = conn.execute("""SELECT created_at, attempt, event, actor, detail FROM job_events
WHERE job_id = %s ORDER BY id""", (job[0],)).fetchall()
outbox = conn.execute("""SELECT id, attempt, available_at, published_at, published_by FROM outbox
WHERE job_id = %s ORDER BY id""", (job[0],)).fetchall()
variants = conn.execute("""SELECT name, storage_key, size_bytes, width, height, sha256
FROM attachment_variants WHERE attachment_id = %s
ORDER BY pipeline_version, name""", (uuid.UUID(attachment_id),)).fetchall()
status = conn.execute("SELECT status, error_code FROM attachments WHERE id = %s",
(uuid.UUID(attachment_id),)).fetchone()
def t(value):
return value.isoformat() if value else None
names = ("job_id", "status", "attempt", "max_attempts", "lease_owner", "lease_until", "next_attempt_at",
"last_error_code", "last_error", "created_at", "finished_at")
return {"attachment_status": status[0], "error_code": status[1],
"job": {k: (t(v) if hasattr(v, "isoformat") else (str(v) if isinstance(v, uuid.UUID) else v))
for k, v in zip(names, job)},
"events": [{"at": t(e[0]), "attempt": e[1], "event": e[2], "actor": e[3], "detail": e[4]}
for e in events],
"outbox": [{"id": o[0], "attempt": o[1], "available_at": t(o[2]), "published_at": t(o[3]),
"published_by": o[4]} for o in outbox],
"variants": [{"name": v[0], "storage_key": v[1], "size_bytes": v[2], "width": v[3], "height": v[4],
"sha256": v[5]} for v in variants]}
def stats(self) -> dict:
with self._tx() as conn:
by_status = dict(conn.execute("SELECT status, count(*) FROM attachment_jobs GROUP BY status").fetchall())
unpublished = conn.execute("SELECT count(*) FROM outbox WHERE published_at IS NULL").fetchone()[0]
processing = conn.execute("SELECT count(*) FROM attachment_jobs WHERE status = 'processing'").fetchone()[0]
return {"jobs": by_status, "outbox_unpublished": unpublished, "processing_now": processing}
def main(argv=None) -> int:
"""Команды оператора (внутри контейнера worker):
python -m messenger.jobs failed реестр failed
python -m messenger.jobs show <attachment_id> состояние, журнал, outbox, варианты
python -m messenger.jobs replay <attachment_id> [--actor имя] явный повтор failed
python -m messenger.jobs stats сколько заданий в каждом состоянии
"""
parser = argparse.ArgumentParser(description="Задания обработки вложений")
sub = parser.add_subparsers(dest="command", required=True)
sub.add_parser("failed")
sub.add_parser("stats")
show = sub.add_parser("show")
show.add_argument("attachment_id", type=uuid.UUID)
replay = sub.add_parser("replay")
replay.add_argument("attachment_id", type=uuid.UUID)
replay.add_argument("--actor", default="operator")
args = parser.parse_args(argv)
logging.basicConfig(level=logging.WARNING, format="%(levelname)s %(name)s: %(message)s")
from . import secretsource
secretsource.load() # с lab7: пароль роли БД и ключи S3 — из OpenBao (identity контейнера)
config.validate()
from . import db
pool = db.create_pool()
pool.open()
try:
if args.command == "replay":
config.validate_s3()
from . import objects
store = JobStore(pool, "operator:" + args.actor[:40])
result = store.replay(str(args.attachment_id), objects.exists)
else:
store = JobStore(pool, "operator")
result = {"failed": store.failed, "stats": store.stats}.get(args.command, None)
result = result() if result else store.show(str(args.attachment_id))
print(json.dumps(result, ensure_ascii=False, default=str))
except Unavailable as exc:
print(json.dumps({"error": exc.message}, ensure_ascii=False))
return 1
finally:
pool.close()
return 0
if __name__ == "__main__":
sys.exit(main())
+25
View File
@@ -0,0 +1,25 @@
"""Миграции схемы БД отдельным процессом: `python -m messenger.migrate`.
Это команда одноразового сервиса migrate в compose.yaml. Он стартует после того,
как PostgreSQL стал healthy, применяет новые migrations/*.sql и завершается с кодом 0.
Реплики API запускаются только после успешного завершения migrate
(depends_on: condition: service_completed_successfully) и сами схему не меняют.
Повторный запуск безопасен: применённые файлы отмечены в schema_migrations
и второй раз не выполняются, а pg_advisory_lock не даёт двум запускам идти одновременно.
"""
import logging
import sys
from . import config, db
def main() -> int:
logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s")
config.validate()
db.migrate_with_retry()
return 0
if __name__ == "__main__":
sys.exit(main())
+308
View File
@@ -0,0 +1,308 @@
"""Объектное хранилище S3 (SeaweedFS): байты вложений (с lab4).
Источник истины для СОДЕРЖИМОГО файла — приватный bucket, для МЕТАДАННЫХ — PostgreSQL.
Ни одна реплика API не хранит оригинал у себя: любая реплика скачивает его из общего S3,
поэтому файл доступен и после остановки реплики, которая его приняла.
Ключи объектов (с lab5) назначает сервер, имя файла от клиента в них не попадает:
- staging/<attachment_id> — принятый оригинал до обработки (его пишет API перед ответом 202);
- originals/<attachment_id> — опубликованный оригинал (его пишет worker перед статусом ready);
- variants/<attachment_id>/v<версия>/<вариант>.<расширение> — thumbnail, crop, optimized.
Ключ варианта однозначно задан ключом эффекта (attachment_id, pipeline_version, variant):
повторная обработка пишет в тот же ключ те же байты и не создаёт второй набор.
API ходит в S3 под отдельным пользователем с минимальными правами (secrets/s3_config.json):
читать, писать, удалять и перечислять объекты только своего bucket (действия Read/Write/List
с именем bucket). Создавать и удалять bucket, менять его политику он не может.
Ключ объекта назначает сервер (случайный UUID), имя файла от клиента в ключ не попадает.
Любая сетевая ошибка или таймаут S3 превращается в Unavailable (503), а не в 500.
"""
import concurrent.futures
import contextvars
import logging
import threading
import time
import uuid
from datetime import datetime
import boto3
from botocore.config import Config
from botocore.exceptions import BotoCoreError, ClientError
from . import config
from .errors import Unavailable
log = logging.getLogger("messenger.objects")
PREFIX = "originals/" # опубликованные оригиналы (и оригиналы lab4)
STAGING_PREFIX = "staging/" # принятые, но ещё не обработанные оригиналы (с lab5)
VARIANTS_PREFIX = "variants/" # варианты (с lab5)
CHUNK_BYTES = 64 * 1024 # скачивание отдаётся клиенту кусками, файл целиком в память не читается
# Передача файла до 10 MiB внутри Docker-сети занимает доли секунды; запас на медленный диск.
TRANSFER_TIMEOUT_SECONDS = 30
_client = None
_client_lock = threading.Lock()
# Каждая операция S3 выполняется в отдельном пуле потоков с общим пределом времени
# S3_OPERATION_TIMEOUT_SECONDS. Таймауты boto3 (connect/read) не покрывают поиск имени в DNS:
# когда контейнер s3 остановлен, разрешение имени "s3" внутри Docker может висеть 10+ с.
# Предел гарантирует быстрый 503, даже если зависший поток ещё ждёт ответа DNS.
_pool = concurrent.futures.ThreadPoolExecutor(max_workers=16, thread_name_prefix="s3")
def _bounded(action: str, fn, timeout: float | None = None):
# copy_context (с lab6): контекст трассы вызывающего потока переходит в поток S3, поэтому запрос
# к S3 (span botocore) становится дочерним span HTTP-запроса или обработки задания.
future = _pool.submit(contextvars.copy_context().run, fn)
try:
return future.result(timeout=timeout or config.S3_OPERATION_TIMEOUT_SECONDS)
except concurrent.futures.TimeoutError:
log.warning("S3 %s: нет ответа за %s с", action, timeout or config.S3_OPERATION_TIMEOUT_SECONDS)
raise Unavailable("Хранилище файлов временно недоступно") from None
class MissingObject(Exception):
"""Строка в БД есть, а объекта в S3 нет (нарушение согласованности, см. cleanup.py)."""
def new_key() -> str:
return PREFIX + uuid.uuid4().hex
def staging_key(attachment_id: str) -> str:
return STAGING_PREFIX + str(uuid.UUID(attachment_id))
def original_key(attachment_id: str) -> str:
return PREFIX + str(uuid.UUID(attachment_id))
def variant_key(attachment_id: str, pipeline_version: int, name: str, extension: str) -> str:
return f"{VARIANTS_PREFIX}{uuid.UUID(attachment_id)}/v{int(pipeline_version)}/{name}{extension}"
def attachment_of(key: str) -> str | None:
"""ID вложения, которому принадлежит ключ: staging/<id>, originals/<id>, variants/<id>/...
Для ключа другого вида — None (уборщик решает по ключу, к какому вложению идти за блокировкой)."""
for prefix in (STAGING_PREFIX, PREFIX, VARIANTS_PREFIX):
if key.startswith(prefix):
try:
return str(uuid.UUID(key[len(prefix):].split("/", 1)[0]))
except ValueError:
return None
return None
def prefixes_of(attachment_id: str) -> list[str]:
"""Префиксы всех объектов одного вложения (для уборки одного вложения: cleanup --attachment)."""
return [staging_key(attachment_id), original_key(attachment_id), f"{VARIANTS_PREFIX}{uuid.UUID(attachment_id)}/"]
def client():
"""Один клиент на процесс (клиенты boto3 потокобезопасны), создаётся при первом обращении."""
global _client
with _client_lock:
if _client is None:
_client = boto3.session.Session().client(
"s3",
endpoint_url=config.S3_ENDPOINT,
region_name=config.S3_REGION,
# С lab7 S3 только по HTTPS: сертификат s3 проверяется нашим CA (и имя s3 в SAN).
verify=config.TLS_CA_FILE,
aws_access_key_id=config.S3_ACCESS_KEY_ID,
aws_secret_access_key=config.S3_SECRET_ACCESS_KEY,
config=Config(
signature_version="s3v4",
s3={"addressing_style": "path"}, # https://s3:9000/<bucket>/<key>
connect_timeout=config.S3_CONNECT_TIMEOUT_SECONDS,
read_timeout=config.S3_READ_TIMEOUT_SECONDS,
retries={"max_attempts": config.S3_MAX_ATTEMPTS, "mode": "standard"},
max_pool_connections=20,
# Без дополнительных CRC-заголовков новых версий boto3: целостность проверяем
# своим SHA-256 (он же в метаданных объекта), а сервер S3 не обязан их понимать.
request_checksum_calculation="when_required",
response_checksum_validation="when_required",
),
)
return _client
def _unavailable(action: str, exc: Exception) -> Unavailable:
# В лог — только тип ошибки и код S3: без ключей доступа и адресов с паролями.
code = exc.response.get("Error", {}).get("Code", "") if isinstance(exc, ClientError) else ""
log.warning("S3 %s не удалось: %s %s", action, type(exc).__name__, code)
return Unavailable("Хранилище файлов временно недоступно")
def _is_missing(exc: ClientError) -> bool:
return exc.response.get("Error", {}).get("Code") in ("NoSuchKey", "404", "NotFound")
# ---------- готовность S3 для /health/ready (с lab5) ----------
# Отдельный поток раз в S3_HEALTH_INTERVAL_SECONDS делает HEAD объекта (с lab7, см. ниже) отдельным клиентом с короткими
# таймаутами. Readiness только читает время последнего успеха, сам в S3 не ходит: healthcheck
# отвечает мгновенно, а зависший запрос в S3 (например, поиск DNS-имени остановленного контейнера)
# не копит потоки — проверка идёт строго одна за другой.
_last_ok = 0.0
def healthy() -> bool:
return time.monotonic() - _last_ok < config.S3_HEALTH_MAX_AGE_SECONDS
def start_monitor(stop: threading.Event) -> threading.Thread:
probe = boto3.session.Session().client(
"s3", endpoint_url=config.S3_ENDPOINT, region_name=config.S3_REGION, verify=config.TLS_CA_FILE,
aws_access_key_id=config.S3_ACCESS_KEY_ID, aws_secret_access_key=config.S3_SECRET_ACCESS_KEY,
config=Config(signature_version="s3v4", s3={"addressing_style": "path"}, connect_timeout=1,
read_timeout=2, retries={"max_attempts": 1, "mode": "standard"},
request_checksum_calculation="when_required",
response_checksum_validation="when_required"))
def loop():
global _last_ok
was_ok = None
while not stop.is_set():
try:
# С lab7 у ключей API права только на префиксы (staging/ запись, originals/ и variants/
# чтение), HeadBucket им запрещён. Проверка: HEAD несуществующего объекта под originals/.
# 404 = S3 отвечает и ключи действуют; 403 (ключи отозваны) или ошибка сети = не готов.
probe.head_object(Bucket=config.S3_BUCKET, Key=PREFIX + "readiness-probe")
ok = True
except ClientError as exc:
ok = _is_missing(exc)
except (BotoCoreError, OSError):
ok = False
if ok:
_last_ok = time.monotonic()
if ok != was_ok:
(log.info if ok else log.warning)("S3 %s", "доступен" if ok else "недоступен: /health/ready -> 503")
was_ok = ok
stop.wait(config.S3_HEALTH_INTERVAL_SECONDS)
thread = threading.Thread(target=loop, name="s3-monitor", daemon=True)
thread.start()
return thread
def put(key: str, fileobj, size: int, content_type: str, sha256: str, timeout: float | None = None) -> None:
"""Записать объект. Тело читается из файла кусками (boto3 не держит его целиком в памяти).
Возврат без ошибки = S3 ответил 200 на PUT: объект записан и виден всем репликам.
"""
fileobj.seek(0)
_bounded("PUT", lambda: _put(key, fileobj, size, content_type, sha256), timeout)
def put_file(key: str, path: str, content_type: str, sha256: str) -> None:
"""Записать файл с диска (worker: оригинал и варианты)."""
import os
with open(path, "rb") as f:
put(key, f, os.path.getsize(path), content_type, sha256, TRANSFER_TIMEOUT_SECONDS)
def _put(key, fileobj, size, content_type, sha256):
try:
client().put_object(Bucket=config.S3_BUCKET, Key=key, Body=fileobj, ContentLength=size,
ContentType=content_type, Metadata={"sha256": sha256})
except (BotoCoreError, ClientError) as exc:
raise _unavailable("PUT", exc) from None
def open_stream(key: str):
"""Открыть объект на чтение: StreamingBody, из которого читаем кусками по CHUNK_BYTES."""
return _bounded("GET", lambda: _open_stream(key))
def _open_stream(key: str):
try:
return client().get_object(Bucket=config.S3_BUCKET, Key=key)["Body"]
except ClientError as exc:
if _is_missing(exc):
raise MissingObject(key) from None
raise _unavailable("GET", exc) from None
except BotoCoreError as exc:
raise _unavailable("GET", exc) from None
def download(key: str, path: str, max_bytes: int) -> int:
"""Скачать объект в файл (worker). Больше max_bytes не читаем: это защита от подмены объекта."""
return _bounded("GET", lambda: _download(key, path, max_bytes), TRANSFER_TIMEOUT_SECONDS)
def _download(key: str, path: str, max_bytes: int) -> int:
body = _open_stream(key)
size = 0
try:
with open(path, "wb") as f:
while True:
chunk = body.read(CHUNK_BYTES)
if not chunk:
return size
size += len(chunk)
if size > max_bytes:
raise Unavailable("Объект больше допустимого размера")
f.write(chunk)
except (BotoCoreError, OSError) as exc:
raise _unavailable("GET", exc) from None
finally:
body.close()
def exists(key: str) -> bool:
"""Есть ли объект (HEAD). Нужно для replay: оригинал в staging ещё хранится?"""
return _bounded("HEAD", lambda: _exists(key))
def _exists(key: str) -> bool:
try:
client().head_object(Bucket=config.S3_BUCKET, Key=key)
return True
except ClientError as exc:
if _is_missing(exc):
return False
raise _unavailable("HEAD", exc) from None
except BotoCoreError as exc:
raise _unavailable("HEAD", exc) from None
def iter_chunks(body):
"""Генератор для StreamingResponse: отдаёт файл кусками и закрывает соединение с S3."""
try:
while True:
chunk = body.read(CHUNK_BYTES)
if not chunk:
return
yield chunk
finally:
body.close()
def delete(key: str) -> None:
"""Удалить объект. Идемпотентно: удаление уже удалённого ключа — не ошибка."""
_bounded("DELETE", lambda: _delete(key))
def _delete(key: str) -> None:
try:
client().delete_object(Bucket=config.S3_BUCKET, Key=key)
except (BotoCoreError, ClientError) as exc:
raise _unavailable("DELETE", exc) from None
def list_objects(prefix: str = ""):
"""Все объекты под префиксом: [(ключ, время изменения)]. Нужен уборщику для сверки с БД."""
return _bounded("LIST", lambda: _list_objects(prefix), timeout=config.S3_OPERATION_TIMEOUT_SECONDS * 10)
def _list_objects(prefix: str):
result: list[tuple[str, datetime]] = []
try:
for page in client().get_paginator("list_objects_v2").paginate(Bucket=config.S3_BUCKET, Prefix=prefix):
result += [(item["Key"], item["LastModified"]) for item in page.get("Contents", [])]
except (BotoCoreError, ClientError) as exc:
raise _unavailable("LIST", exc) from None
return result
+101
View File
@@ -0,0 +1,101 @@
"""Метрики очереди заданий (с lab6): глубина и возраст старейшего задания, outbox.
Считаются в каждой реплике API (а не в worker): во время инцидента «worker остановлен» именно
эти графики должны расти, а остановленный worker ничего бы не отправил. Обе реплики отдают одно и
то же значение, в запросах dashboard берётся max по репликам.
Источник — PostgreSQL (источник истины о заданиях), а не счётчик брокера: брокер хранит только
«напоминания», а задание может ждать и в outbox (брокер недоступен), и в паузе backoff.
messenger.queue.depth{queue, state} state = ready (ждёт worker), delayed (пауза перед повтором),
processing (под lease) [{job}]
messenger.queue.oldest_age{queue} сколько ждёт самое старое задание в состоянии ready, с момента,
когда его можно брать (next_attempt_at) [s]
messenger.outbox.pending строки outbox, которые пора отправить, но брокер их ещё
не подтвердил [{message}]
messenger.outbox.oldest_age возраст самой старой такой строки [s]
Backlog (depth) и lag (oldest_age) — не то же самое, что время обработки задания: это время
ожидания до начала обработки. Время обработки — гистограмма messenger.job.duration (worker),
полный путь до ready — messenger.attachment.time_to_ready.
"""
import logging
import threading
import psycopg
from opentelemetry import metrics
from . import config, db, telemetry
log = logging.getLogger("messenger.queuestats")
INTERVAL_SECONDS = 5.0
_SQL_JOBS = """
SELECT count(*) FILTER (WHERE status = 'queued' AND next_attempt_at <= now()),
count(*) FILTER (WHERE status = 'queued' AND next_attempt_at > now()),
count(*) FILTER (WHERE status = 'processing'),
COALESCE(EXTRACT(EPOCH FROM now() - min(next_attempt_at)
FILTER (WHERE status = 'queued' AND next_attempt_at <= now())), 0)
FROM attachment_jobs WHERE status IN ('queued', 'processing')"""
_SQL_OUTBOX = """
SELECT count(*), COALESCE(EXTRACT(EPOCH FROM now() - min(available_at)), 0)
FROM outbox WHERE published_at IS NULL AND available_at <= now()"""
class QueueStats:
def __init__(self):
self._values = telemetry.Sampled(max_age=3 * INTERVAL_SECONDS)
self._stop = threading.Event()
self._conn = None
def start(self) -> None:
if not telemetry.enabled():
return
m = metrics.get_meter("messenger")
q = {"queue": telemetry.QUEUE_NAME}
m.create_observable_gauge("messenger.queue.depth", [self._depth], unit="{job}",
description="Задания в очереди по состоянию")
m.create_observable_gauge("messenger.queue.oldest_age", [self._field(3, q)], unit="s",
description="Ожидание самого старого задания, готового к обработке")
m.create_observable_gauge("messenger.outbox.pending", [self._field(4, q)], unit="{message}",
description="Неотправленные строки outbox, которые пора отправить")
m.create_observable_gauge("messenger.outbox.oldest_age", [self._field(5, q)], unit="s",
description="Возраст самой старой неотправленной строки outbox")
threading.Thread(target=self._loop, name="queue-stats", daemon=True).start()
def stop(self) -> None:
self._stop.set()
def _depth(self, _options):
values = self._values.get()
if values is None:
return []
return [metrics.Observation(values[i], {"queue": telemetry.QUEUE_NAME, "state": state})
for i, state in enumerate(("ready", "delayed", "processing"))]
def _field(self, index: int, attrs: dict):
def callback(_options):
values = self._values.get()
return [] if values is None else [metrics.Observation(values[index], attrs)]
return callback
def _loop(self) -> None:
while not self._stop.wait(INTERVAL_SECONDS):
try:
if self._conn is None or self._conn.closed:
kwargs = db.connection_kwargs("messenger-queue-stats")
self._conn = psycopg.connect(config.DATABASE_URL, autocommit=True, **kwargs)
jobs = self._conn.execute(_SQL_JOBS).fetchone()
outbox = self._conn.execute(_SQL_OUTBOX).fetchone()
self._values.put((int(jobs[0]), int(jobs[1]), int(jobs[2]), float(jobs[3]),
int(outbox[0]), float(outbox[1])))
except psycopg.Error:
# БД недоступна: значения устареют и перестанут отдаваться (пропуск на графике).
try:
if self._conn is not None:
self._conn.close()
except psycopg.Error:
pass
self._conn = None
+79
View File
@@ -0,0 +1,79 @@
"""Ограничение частоты входа и регистрации (с lab7): 429 rate_limited + Retry-After.
Счётчики общие для всех реплик: фиксированное окно в Valkey (ключи rl:*, SessionCache.hit),
поэтому балансировщик, раскидывающий попытки по репликам, лимит не обходит.
Если Valkey недоступен, каждая реплика считает у себя (лимит действует, но на реплику).
Правила (значения в .env, по умолчанию в config.py):
- вход: не больше LOGIN_RATE_PER_IP попыток с одного адреса за LOGIN_RATE_WINDOW_SECONDS;
- вход: после LOGIN_FAILURES_PER_USER неудач по одному username за LOGIN_FAILURE_WINDOW_SECONDS
этот username получает 429 даже с верным паролем (перебор пароля одного аккаунта),
успешный вход сбрасывает счётчик;
- регистрация: не больше REGISTER_RATE_PER_IP с одного адреса за окно (каждая стоит Argon2id).
Проверка лимита — до Argon2id: отказ 429 почти ничего не стоит серверу.
Адрес клиента — из X-Forwarded-For, который ставит (перезаписывает) HAProxy; подделать его
нельзя: к реплике подключается только балансировщик (mTLS, tlsserver.py).
"""
import hashlib
import threading
import time
from . import config
from .errors import RateLimited
class RateLimiter:
def __init__(self, cache):
self.cache = cache
self._local: dict[str, tuple[int, float]] = {}
self._lock = threading.Lock()
def _local_hit(self, key: str, window: int, add: int = 1) -> tuple[int, int]:
now = time.monotonic()
with self._lock:
if len(self._local) > 100_000: # ограниченная память: старые окна выбрасываем
self._local = {k: v for k, v in self._local.items() if v[1] > now}
count, until = self._local.get(key, (0, 0.0))
if until <= now:
count, until = 0, now + window
count += add
self._local[key] = (count, until)
return count, max(1, int(until - now + 0.999))
def _hit(self, key: str, window: int) -> tuple[int, int]:
return self.cache.hit(key, window) or self._local_hit(key, window)
def _peek(self, key: str, window: int) -> tuple[int, int]:
found = self.cache.peek(key)
return found if found is not None else self._local_hit(key, window, add=0)
def limit(self, key: str, limit: int, window: int, message: str) -> None:
count, ttl = self._hit(key, window)
if count > limit:
raise RateLimited(message, ttl)
@staticmethod
def _user_key(username: str) -> str:
return "login:user:" + hashlib.sha256(username.encode()).hexdigest()[:24] # username в Valkey не храним
def check_login(self, client: str, username: str | None) -> None:
self.limit(f"login:ip:{client}", config.LOGIN_RATE_PER_IP, config.LOGIN_RATE_WINDOW_SECONDS,
"Слишком много попыток входа, повторите позже")
if username:
failures, ttl = self._peek(self._user_key(username), config.LOGIN_FAILURE_WINDOW_SECONDS)
if failures >= config.LOGIN_FAILURES_PER_USER:
raise RateLimited("Слишком много неудачных попыток входа, повторите позже", ttl)
def login_failed(self, username: str | None) -> None:
if username:
self._hit(self._user_key(username), config.LOGIN_FAILURE_WINDOW_SECONDS)
def login_succeeded(self, username: str) -> None:
key = self._user_key(username)
self.cache.reset(key)
with self._lock:
self._local.pop(key, None)
def check_register(self, client: str) -> None:
self.limit(f"register:ip:{client}", config.REGISTER_RATE_PER_IP, config.REGISTER_RATE_WINDOW_SECONDS,
"Слишком много регистраций, повторите позже")
+169
View File
@@ -0,0 +1,169 @@
"""Relay transactional outbox (с lab5): фоновый поток в каждой реплике API.
Задача — доставить в брокер каждую строку outbox хотя бы один раз:
1. взять неотправленные строки, у которых подошло время (available_at), с блокировкой
FOR UPDATE SKIP LOCKED — две реплики API не отправляют одну строку одновременно;
2. отправить каждую в брокер и дождаться publisher confirm;
3. отметить отправленные (published_at) и COMMIT.
Окна отказа и что происходит:
- API упал после COMMIT загрузки, до отправки: строка осталась в outbox -> её отправит relay
другой реплики (или этой после перезапуска). Новое задание вручную создавать не нужно;
- relay упал после выборки, до отправки: транзакция откатывается вместе с соединением,
блокировки снимаются, строки остаются неотправленными -> их отправят позже;
- relay упал после подтверждения брокера, до отметки: строка отправится ещё раз (дубль).
Это нормально для at-least-once: worker распознаёт дубль по состоянию задания;
- брокер недоступен: строки копятся в outbox (в PostgreSQL), загрузки продолжают получать 202.
Relay пробует снова с паузой 1, 2, 4… до 10 с.
Relay будится сразу после загрузки в этом же процессе (nudge) и сам раз в RELAY_POLL_SECONDS:
так он подхватывает строки других процессов — повторы с паузой и replay из worker.
С lab6 каждая отправка — PRODUCER span «send attachments» (semconv messaging). Его родитель —
traceparent из строки outbox (span загрузки или обработки, создавшей задание), а в сообщение
брокера уходит traceparent уже этого span: consumer span worker станет его дочерним.
Так одна трасса показывает upload -> publish -> consume, даже если relay отправил строку позже
или другой репликой. Опрос outbox (SQL раз в секунду) трасс не создаёт: CLIENT-спаны без родителя
отбрасываются выборкой (telemetry._sampler).
"""
import logging
import threading
import psycopg
from opentelemetry.trace import SpanKind
from . import broker, config, db, faults, telemetry
log = logging.getLogger("messenger.relay")
class OutboxRelay:
def __init__(self):
self._wake = threading.Event()
self._stop = threading.Event()
self._thread = None
self._conn = None
self._publisher = broker.Publisher("relay")
self._healthy = None # для логов: пишем только смену состояния
self.published_total = 0
def start(self) -> None:
self._thread = threading.Thread(target=self._loop, name="outbox-relay", daemon=True)
self._thread.start()
def nudge(self) -> None:
"""Есть новая строка outbox: отправить сейчас, не дожидаясь очередного опроса."""
self._wake.set()
def stop(self) -> None:
self._stop.set()
self._wake.set()
if self._thread is not None:
self._thread.join(timeout=5)
self._publisher.close()
self._close_db()
def _db(self):
if self._conn is None or self._conn.closed:
kwargs = db.connection_kwargs()
kwargs["application_name"] = "messenger-relay"
self._conn = psycopg.connect(config.DATABASE_URL, autocommit=True, **kwargs)
return self._conn
def _close_db(self) -> None:
try:
if self._conn is not None:
self._conn.close()
except psycopg.Error:
pass
self._conn = None
def _state(self, ok: bool, reason: str = "") -> None:
if ok != self._healthy:
if ok:
log.info("relay: связь с брокером и PostgreSQL есть, outbox отправляется",
extra={"event": "relay.healthy"})
else:
log.warning("relay: не могу отправить outbox (%s), строки ждут в PostgreSQL", reason,
extra={"event": "relay.unavailable"})
self._healthy = ok
def _loop(self) -> None:
pause = 1.0
while not self._stop.is_set():
self._wake.wait(config.RELAY_POLL_SECONDS)
self._wake.clear()
if self._stop.is_set():
break
try:
while self.publish_batch() == config.RELAY_BATCH_SIZE: # пока есть полные пачки
pass
self._publisher.service()
self._state(True)
pause = 1.0
except broker.BrokerError as exc:
self._state(False, "брокер: " + type(exc).__name__)
self._publisher.close()
self._stop.wait(pause)
pause = min(pause * 2, 10.0)
except psycopg.Error as exc:
self._state(False, "PostgreSQL: " + type(exc).__name__)
self._close_db()
self._stop.wait(pause)
pause = min(pause * 2, 10.0)
except Exception:
log.exception("relay: неожиданная ошибка", extra={"event": "relay.error"})
self._publisher.close()
self._close_db()
self._stop.wait(pause)
pause = min(pause * 2, 10.0)
def publish_batch(self) -> int:
"""Одна пачка: выбрать -> отправить с подтверждением -> отметить. Возвращает число строк в пачке."""
conn = self._db()
error = None
sent = []
with conn.transaction():
rows = conn.execute("""SELECT id, payload FROM outbox
WHERE published_at IS NULL AND available_at <= now()
ORDER BY available_at, id LIMIT %s
FOR UPDATE SKIP LOCKED""", (config.RELAY_BATCH_SIZE,)).fetchall()
if not rows:
return 0
faults.hit("relay_before_publish")
for row_id, payload in rows:
try:
self._send(payload)
except broker.BrokerError as exc:
error = exc # отправленное до ошибки всё равно отметим
break
sent.append(row_id)
if sent:
faults.hit("relay_after_publish")
conn.execute("""UPDATE outbox SET published_at = now(), published_by = %s
WHERE id = ANY(%s)""", ("relay-" + config.INSTANCE_ID, sent))
if sent:
self.published_total += len(sent)
telemetry.instruments.create().outbox_published.add(len(sent))
log.info("relay: отправлено в брокер %d (подтверждено), всего %d", len(sent), self.published_total,
extra={"event": "relay.published", "count": len(sent)})
if error is not None:
raise error
return len(rows)
def _send(self, payload: dict) -> None:
"""Одна публикация с publisher confirm внутри PRODUCER span (родитель — traceparent строки)."""
message = {k: v for k, v in payload.items() if k not in ("traceparent", "tracestate")}
attributes = {"messaging.system": "rabbitmq", "messaging.operation.type": "send",
"messaging.operation.name": "publish", "messaging.destination.name": broker.EXCHANGE,
"messaging.rabbitmq.destination.routing_key": broker.ROUTING_KEY,
"messaging.message.id": f"{payload['job_id']}:{payload['attempt']}",
"messenger.job.type": telemetry.JOB_TYPE, "messenger.job.id": payload["job_id"],
"messenger.job.attempt": payload["attempt"],
"messenger.attachment.id": payload["attachment_id"]}
with telemetry.span(f"send {broker.EXCHANGE}", SpanKind.PRODUCER, telemetry.extract(payload), attributes):
telemetry.inject(message) # traceparent этого span -> consumer span worker
if "traceparent" not in message and "traceparent" in payload:
message["traceparent"] = payload["traceparent"] # телеметрия выключена: передаём как было
self._publisher.publish(message)
+77
View File
@@ -0,0 +1,77 @@
"""Настройка S3 для стенда: сервис s3-init в compose.yaml (`python -m messenger.s3bootstrap`).
Идемпотентно, как migrate для БД: запускается при каждом `docker compose up`, повтор безопасен.
1. ждёт, пока SeaweedFS начнёт отвечать (до 60 с);
2. создаёт bucket, только если его ещё нет (HeadBucket -> CreateBucket); данные не трогает;
3. проверяет, что bucket приватный: запрос списка объектов БЕЗ подписи должен получить 403.
Пользователи и права задаются не здесь, а файлом-секретом s3_config.json (scripts/init-secrets.sh):
у API действия Read/Write/List только для этого bucket, анонимного пользователя нет.
Ключи администратора S3 есть только у этого сервиса (и в конфиге SeaweedFS), у API — свои.
Модуль намеренно не импортирует messenger.config: секретов БД у этого сервиса нет.
Секреты в вывод не попадают.
"""
import os
import ssl
import sys
import time
import urllib.error
import urllib.request
from pathlib import Path
import boto3
from botocore.config import Config
from botocore.exceptions import BotoCoreError, ClientError
def secret(name: str) -> str:
return Path(os.environ[name]).read_text(encoding="utf-8").strip()
def main() -> int:
endpoint = os.environ.get("S3_ENDPOINT", "https://s3:9000")
bucket = os.environ.get("S3_BUCKET", "messenger-attachments")
ca_file = os.environ.get("TLS_CA_FILE", "/run/ca/ca.crt") # с lab7: HTTPS с проверкой сертификата s3
s3 = boto3.session.Session().client(
"s3", endpoint_url=endpoint, region_name=os.environ.get("S3_REGION", "us-east-1"), verify=ca_file,
aws_access_key_id=secret("S3_ADMIN_ACCESS_KEY_ID_FILE"),
aws_secret_access_key=secret("S3_ADMIN_SECRET_ACCESS_KEY_FILE"),
config=Config(signature_version="s3v4", s3={"addressing_style": "path"}, connect_timeout=2,
read_timeout=10, retries={"max_attempts": 2, "mode": "standard"},
request_checksum_calculation="when_required", response_checksum_validation="when_required"))
deadline = time.monotonic() + 60
while True:
try:
s3.head_bucket(Bucket=bucket)
created = False
break
except ClientError as exc:
if exc.response.get("Error", {}).get("Code") in ("404", "NoSuchBucket", "NotFound"):
s3.create_bucket(Bucket=bucket)
created = True
break
reason = exc.response.get("Error", {}).get("Code")
except BotoCoreError as exc:
reason = type(exc).__name__
if time.monotonic() > deadline:
print(f"s3-init: S3 is not ready ({reason})", file=sys.stderr)
return 1
time.sleep(1)
try:
urllib.request.urlopen(f"{endpoint}/{bucket}?list-type=2", timeout=5,
context=ssl.create_default_context(cafile=ca_file))
print("s3-init: bucket answers WITHOUT a signature — it is public, stop", file=sys.stderr)
return 1
except urllib.error.HTTPError as error:
if error.code != 403:
print(f"s3-init: unexpected anonymous status {error.code}", file=sys.stderr)
return 1
print(f"s3-init: bucket {bucket} {'created' if created else 'already exists'}; "
f"anonymous access: 403 (private)")
return 0
if __name__ == "__main__":
sys.exit(main())
+104
View File
@@ -0,0 +1,104 @@
"""Запуск обработки картинки в дочернем процессе с лимитами памяти и времени (с lab5).
Зачем отдельный процесс. Декодирование и resize идут в C-коде Pillow: поток Python нельзя
прервать посередине, а MemoryError в одном потоке может задеть весь процесс. Дочерний процесс
можно просто убить, и у него свой лимит памяти:
- время: если результата нет за JOB_TIMEOUT_SECONDS, процесс получает SIGKILL -> ProcessingTimeout;
- память: RLIMIT_AS (адресное пространство) = WORKER_MEMORY_LIMIT_MB. Нехватка -> MemoryError
внутри Pillow -> ImageTooLarge; если процесс всё же умер (например, OOM killer) -> ChildCrashed;
- пиксели и байты проверяются ещё до декодирования (imaging.py и worker.py).
Процессы создаются через forkserver: сервер-родитель запускается один раз и заранее загружает
Pillow и libjpeg-turbo (preload), а каждый дочерний процесс — быстрая копия этого сервера.
fork прямо из worker был бы опасен: у worker есть потоки (брокер, продление lease),
а копия процесса с чужими захваченными блокировками может зависнуть.
"""
import multiprocessing
import os
import resource
import signal
from . import imaging
_ctx = multiprocessing.get_context("forkserver")
_ctx.set_forkserver_preload(["messenger.imaging"])
class ProcessingTimeout(Exception):
"""Не уложились в лимит времени: процесс убит. Временная ошибка (может помочь повтор)."""
code = "processing_timeout"
class ChildCrashed(Exception):
"""Дочерний процесс завершился, не прислав результата (убит сигналом). Временная ошибка."""
code = "worker_crashed"
def _child(conn, src_path, out_dir, content_type, params, memory_limit_bytes, slow_seconds):
try:
signal.signal(signal.SIGTERM, signal.SIG_DFL)
if memory_limit_bytes:
resource.setrlimit(resource.RLIMIT_AS, (memory_limit_bytes, memory_limit_bytes))
resource.setrlimit(resource.RLIMIT_CORE, (0, 0)) # без core dump на диск контейнера
if slow_seconds: # только для тестов «долгой задачи» (faults.py: worker_slow)
import time
time.sleep(slow_seconds)
conn.send(("ok", imaging.process(src_path, out_dir, content_type, params)))
except imaging.ImageError as exc:
conn.send(("error", exc.code, str(exc)))
except MemoryError:
conn.send(("error", "image_too_large", "Не хватило лимита памяти на обработку картинки"))
except Exception as exc: # неожиданная ошибка: тип без подробностей (там могут быть пути)
conn.send(("unexpected", type(exc).__name__))
finally:
conn.close()
def run(src_path: str, out_dir: str, content_type: str, params: imaging.Params,
timeout: float, memory_limit_mb: int, slow_seconds: float = 0, abort=None) -> dict:
"""Результат imaging.process из дочернего процесса.
abort — threading.Event: если lease потерян (задачу забрал другой worker), процесс убивается
сразу, не дожидаясь конца обработки.
Исключения: imaging.InvalidImage / ImageTooLarge (постоянные), ProcessingTimeout,
ChildCrashed, RuntimeError (временные).
"""
receiver, sender = _ctx.Pipe(duplex=False)
proc = _ctx.Process(target=_child, daemon=True,
args=(sender, src_path, out_dir, content_type, params,
memory_limit_mb * 1024 * 1024, slow_seconds))
proc.start()
sender.close()
try:
waited, step = 0.0, 0.2
while not receiver.poll(step):
waited += step
if abort is not None and abort.is_set():
raise ChildCrashed("lease потерян, обработка прервана")
if waited >= timeout:
raise ProcessingTimeout(f"обработка дольше {timeout:g} с")
if not proc.is_alive() and not receiver.poll(0):
raise ChildCrashed(f"код завершения {proc.exitcode}")
try:
message = receiver.recv()
except EOFError:
proc.join(2)
raise ChildCrashed(f"код завершения {proc.exitcode}") from None
finally:
receiver.close()
if proc.is_alive():
proc.kill()
proc.join(5)
if message[0] == "ok":
return message[1]
if message[0] == "error":
error = imaging.ImageTooLarge if message[1] == "image_too_large" else imaging.InvalidImage
raise error(message[2])
raise RuntimeError("неожиданная ошибка обработки: " + message[1])
def warm_up() -> None:
"""Запустить forkserver заранее, при старте worker (первая задача не ждёт импорта Pillow)."""
proc = _ctx.Process(target=os.getpid)
proc.start()
proc.join(30)
+195
View File
@@ -0,0 +1,195 @@
"""Секреты процесса из OpenBao (с lab7): пароль роли БД, ключи S3, пароль Valkey.
Как процесс получает секреты (первый секрет — это его TLS-ключ, а не токен):
1. У контейнера есть только сертификат и ключ своей identity (/run/tls, CN=api или CN=worker),
выданные локальным CA оператора (scripts/pki.py). Постоянного токена или SecretID в образе,
в .env и в compose нет.
2. Вход: POST /v1/auth/cert/login {"name": BAO_ROLE} по mTLS. OpenBao проверяет, что сертификат
выпущен нашим CA И что CN разрешён этой роли (allowed_common_names). Сертификат worker
не войдёт в роль messenger-api, сертификат lb — ни в одну.
3. Токен живёт token_ttl (15 мин), продлевается renew-self до token_max_ttl (1 ч), потом —
новый вход тем же сертификатом. Политика роли: read только secret/data/messenger/<роль>.
4. Секрет перечитывается раз в BAO_REFRESH_SECONDS. Изменился пароль БД (ротация оператором,
make rotate-db) -> пул соединений пересоздаётся: каждое новое соединение входит с новым паролем.
Ограниченное поведение при сбоях (REPORT.md, «Эксперименты и отказы»):
- OpenBao недоступен или запечатан (sealed): работающий процесс продолжает работать на секретах
в памяти (их нет ни на диске, ни в логах); ротации не подхватываются, пока OpenBao не вернётся.
Новый процесс без OpenBao не стартует (fail closed): ждёт BAO_STARTUP_WAIT_SECONDS и завершается.
- токен отозван/истёк (403): сразу новый вход сертификатом.
- сертификат отозван в OpenBao или роль удалена: вход не проходит, процесс живёт на кэше до рестарта.
Без BAO_ADDR секреты читаются из файлов *_FILE (одноразовые инструменты и локальная отладка).
"""
import json
import logging
import ssl
import threading
import time
import urllib.error
import urllib.request
from . import config
log = logging.getLogger("messenger.secrets")
# Какое поле секрета в OpenBao -> какой атрибут config.
FIELDS = {"db_password": "DB_PASSWORD", "s3_access_key_id": "S3_ACCESS_KEY_ID",
"s3_secret_access_key": "S3_SECRET_ACCESS_KEY", "cache_password": "CACHE_PASSWORD"}
class BaoUnavailable(Exception):
"""Нет связи, OpenBao запечатан или отказал во входе: кэш в памяти остаётся в силе."""
class Denied(Exception):
def __init__(self, status: int):
super().__init__(f"HTTP {status}")
self.status = status
class SecretSource:
def __init__(self):
self.token = None
self.token_expires = 0.0
self.renewable = False
self.values: dict[str, str] = {}
self.listeners = [] # callback(changed_fields) — например, пересоздать пул БД
self.last_ok = 0.0 # время последнего успешного чтения (monotonic)
self.state = "init"
self._lock = threading.Lock()
self._thread = None
# ---------- HTTP к OpenBao ----------
def _context(self) -> ssl.SSLContext:
# Контекст создаётся заново на каждый вход: после ротации своего сертификата (файлы
# перезаписаны на месте) следующий вход уже идёт с новым сертификатом.
context = ssl.create_default_context(cafile=config.BAO_CACERT)
context.minimum_version = ssl.TLSVersion.TLSv1_2
context.load_cert_chain(config.TLS_CERT_FILE, config.TLS_KEY_FILE)
return context
def _call(self, method: str, path: str, body: dict | None = None, token: str | None = None) -> dict:
request = urllib.request.Request(f"{config.BAO_ADDR}/v1/{path}", method=method,
data=None if body is None else json.dumps(body).encode())
request.add_header("Content-Type", "application/json")
if token:
request.add_header("X-Vault-Token", token)
try:
with urllib.request.urlopen(request, context=self._context(), timeout=5) as response:
return json.loads(response.read() or b"{}")
except urllib.error.HTTPError as exc:
exc.read() # тело ошибки OpenBao не логируем целиком
if exc.code in (400, 403):
raise Denied(exc.code) from None
raise BaoUnavailable(f"HTTP {exc.code}") from None # 503 = sealed, 5xx
except (urllib.error.URLError, OSError, ValueError) as exc:
raise BaoUnavailable(type(getattr(exc, "reason", exc)).__name__) from None
def _login(self) -> None:
auth = self._call("POST", f"auth/{config.BAO_AUTH_PATH}/login", {"name": config.BAO_ROLE})["auth"]
self.token = auth["client_token"]
ttl = int(auth.get("lease_duration") or 0)
self.token_expires = time.monotonic() + ttl
self.renewable = bool(auth.get("renewable"))
log.info("OpenBao: вход по сертификату, роль %s, политики %s, токен на %d с",
config.BAO_ROLE, ",".join(auth.get("token_policies") or []), ttl,
extra={"event": "secrets.login"})
def _ensure_token(self) -> None:
left = self.token_expires - time.monotonic()
if self.token and left > 60:
return
if self.token and self.renewable and left > 5:
try:
auth = self._call("POST", "auth/token/renew-self", {}, self.token)["auth"]
ttl = int(auth.get("lease_duration") or 0)
if ttl > 60: # упёрлись в token_max_ttl — renew даёт всё меньше, лучше войти заново
self.token_expires = time.monotonic() + ttl
log.info("OpenBao: токен продлён на %d с", ttl, extra={"event": "secrets.renew"})
return
except Denied:
pass
self._login()
def _read(self) -> dict:
for attempt in (1, 2):
self._ensure_token()
try:
return self._call("GET", config.BAO_SECRET_PATH, token=self.token)["data"]["data"]
except Denied:
if attempt == 2:
raise
# Токен отозван оператором или истёк раньше срока: войти заново тем же сертификатом.
log.warning("OpenBao: токен больше не действует, новый вход", extra={"event": "secrets.relogin"})
self.token = None
# ---------- жизненный цикл ----------
def refresh(self) -> bool:
"""Перечитать секрет. True — успешно (изменения применены). Ошибки не бросает."""
try:
fresh = self._read()
except (BaoUnavailable, Denied) as exc:
state = "denied" if isinstance(exc, Denied) else "unavailable"
if state != self.state:
log.warning("OpenBao %s (%s): работаю на секретах в памяти, полученных %.0f с назад",
"отказал" if state == "denied" else "недоступен", exc,
time.monotonic() - self.last_ok if self.last_ok else -1,
extra={"event": "secrets.refresh_failed", "secrets.state": state})
self.state = state
return False
changed = self.apply(fresh)
self.last_ok = time.monotonic()
if self.state not in ("ok", "init"):
log.info("OpenBao снова доступен", extra={"event": "secrets.recovered"})
self.state = "ok"
if changed and self.listeners:
log.warning("OpenBao: новая версия секрета, изменились поля %s", ",".join(sorted(changed)),
extra={"event": "secrets.rotated"})
for callback in self.listeners:
try:
callback(changed)
except Exception: # noqa: BLE001 — сбой одного слушателя не останавливает остальные
log.exception("Ошибка применения нового секрета")
return True
def apply(self, values: dict) -> set:
changed = set()
with self._lock:
for field, attr in FIELDS.items():
if field in values and values[field] != self.values.get(field):
changed.add(field)
setattr(config, attr, values[field])
self.values = {k: v for k, v in values.items() if k in FIELDS}
return changed
def start(self) -> None:
deadline = time.monotonic() + config.BAO_STARTUP_WAIT_SECONDS
while not self.refresh():
if time.monotonic() > deadline:
raise RuntimeError("OpenBao недоступен или отказал во входе: без секретов процесс не стартует")
time.sleep(2)
self._thread = threading.Thread(target=self._loop, name="secrets-refresh", daemon=True)
self._thread.start()
def _loop(self) -> None:
while True:
time.sleep(config.BAO_REFRESH_SECONDS)
self.refresh()
source = SecretSource()
def load() -> SecretSource:
"""Получить секреты до создания пулов и клиентов (вызывается в начале каждого main)."""
if config.BAO_ADDR:
if source._thread is None:
source.start()
return source
def on_change(callback) -> None:
source.listeners.append(callback)
+121
View File
@@ -0,0 +1,121 @@
"""Пароли, токены и разбор заголовка Authorization.
Две разные задачи хеширования:
- пароль хешируется МЕДЛЕННОЙ функцией Argon2id с солью: перебор паролей по украденной
базе стоит дорого (каждая попытка — десятки миллисекунд и 19 МиБ памяти);
- токен сессии хешируется БЫСТРЫМ SHA-256: токен — 256 случайных бит, перебирать
его бессмысленно, а проверять его нужно на каждом запросе.
С lab7:
- параметры Argon2id из окружения (ARGON2_*), не ниже m=19 МиБ, t=2, p=1; в строке hash
хранятся алгоритм, версия, параметры и соль: $argon2id$v=19$m=19456,t=2,p=1$<соль>$<hash>;
- needs_rehash(): hash старыми (слабее текущих) параметрами пересчитывается при успешном входе;
- бюджет дорогих операций: одновременно не больше ARGON2_MAX_CONCURRENCY хеширований на реплику
(каждое — ARGON2_MEMORY_KIB памяти и одно ядро). Остальные ждут не дольше ARGON2_QUEUE_SECONDS,
потом 503 + Retry-After. Так поток входов (в том числе с неверными паролями) не съедает всю
память и CPU реплики, а чтение и отправка сообщений продолжают работать (REPORT.md, замер).
"""
import base64
import binascii
import hashlib
import re
import secrets
import threading
from argon2 import PasswordHasher
from argon2.exceptions import InvalidHashError, VerificationError
from . import config
from .errors import Unavailable
_hasher = PasswordHasher(time_cost=config.ARGON2_ITERATIONS, memory_cost=config.ARGON2_MEMORY_KIB,
parallelism=config.ARGON2_PARALLELISM)
_slots = threading.BoundedSemaphore(config.ARGON2_MAX_CONCURRENCY)
# Hash заведомо неверного пароля. Если пользователя нет, всё равно выполняем проверку:
# ответ занимает столько же времени, и по задержке нельзя узнать, существует ли username.
_DUMMY_HASH = _hasher.hash("timing-equalizer-not-a-password")
TOKEN_BYTES = 32 # 32 байта = 256 бит энтропии (требование контракта)
PASSWORD_MIN, PASSWORD_MAX = 12, 128
USERNAME_RE = re.compile(r"[a-z0-9_]{3,32}") # то же правило, что при регистрации
MAX_BASIC_HEADER = 1024 # длинный заголовок не проверяем: не тратим CPU на заведомый мусор
class _Budget:
"""Место в очереди дорогих операций Argon2id: with _budget(): ..."""
def __enter__(self):
if not _slots.acquire(timeout=config.ARGON2_QUEUE_SECONDS):
raise Unavailable("Сервер занят проверкой паролей, повторите позже", {"Retry-After": "1"})
def __exit__(self, *exc):
_slots.release()
_budget = _Budget()
def hash_password(password: str) -> str:
with _budget:
return _hasher.hash(password)
def verify_password(password_hash: str | None, password: str) -> bool:
with _budget:
try:
return _hasher.verify(password_hash or _DUMMY_HASH, password) and password_hash is not None
except (VerificationError, InvalidHashError):
return False
def needs_rehash(password_hash: str) -> bool:
"""True, если hash создан с другими параметрами (например, до lab7 или слабее текущих)."""
try:
return _hasher.check_needs_rehash(password_hash)
except InvalidHashError:
return True
def parameters() -> str:
return f"m={config.ARGON2_MEMORY_KIB},t={config.ARGON2_ITERATIONS},p={config.ARGON2_PARALLELISM}"
def new_token() -> str:
"""Непрозрачный случайный токен: не username, не UUID и не JWT."""
return secrets.token_urlsafe(TOKEN_BYTES)
def token_hash(token: str) -> bytes:
"""В БД и в кэше хранится только SHA-256 токена — сам токен знает лишь клиент."""
return hashlib.sha256(token.encode("utf-8")).digest()
def _split_scheme(header: str | None) -> tuple[str, str]:
scheme, _, value = (header or "").strip().partition(" ")
return scheme.lower(), value.strip()
def parse_basic(header: str | None) -> tuple[str, str] | None:
"""Authorization: Basic base64(username:password) -> (username, password) или None.
Пароль в UTF-8 и может содержать двоеточие: делим по ПЕРВОМУ двоеточию (RFC 7617).
"""
scheme, value = _split_scheme(header)
if scheme != "basic" or not value or len(value) > MAX_BASIC_HEADER:
return None
try:
decoded = base64.b64decode(value, validate=True).decode("utf-8")
except (binascii.Error, ValueError):
return None
username, sep, password = decoded.partition(":")
if not sep or not username.isascii():
return None
return username, password
def parse_bearer(header: str | None) -> str | None:
scheme, value = _split_scheme(header)
if scheme != "bearer" or not value or len(value) > 512 or " " in value:
return None
return value
+282
View File
@@ -0,0 +1,282 @@
"""Сессии: вход (Basic -> токен), проверка Bearer-токена, выход.
Где что хранится:
- ИСТОЧНИК ИСТИНЫ — таблица sessions в PostgreSQL. Она переживает рестарт и решает,
действует ли сессия (не отозвана и не истекла).
- Valkey — КЭШ «hash токена -> пользователь», ОДИН НА ВСЕ РЕПЛИКИ API. Он избавляет от
SQL-запроса на каждом обращении с токеном. Запись, положенную одной репликой, используют
все остальные. Кэш можно в любой момент очистить или потерять: при промахе данные
берутся из PostgreSQL и снова кладутся в кэш.
Политика кэша:
- запись живёт min(SESSION_CACHE_TTL_SECONDS, остаток жизни сессии): кэш никогда
не продлевает сессию, а истёкшая запись к тому же отбрасывается по expires_at;
- logout: сначала отметка revoked_at в PostgreSQL, затем в кэш вместо записи о сессии
кладётся отметка «отозвано» (tombstone). Новая запись о сессии кладётся только если ключа
нет (SET NX), поэтому запрос, который прочитал сессию из базы до logout, не сможет
«воскресить» её в кэше после logout;
- ОБЩЕЕ поколение кэша (с lab3): в Valkey лежит ключ sess:gen, каждая запись о сессии помечена
поколением, в котором её положили. Запись читается одним запросом MGET вместе с текущим
поколением и считается доверенной, только если поколения совпадают. Каждая реплика раз
в CACHE_CHECK_INTERVAL_SECONDS проверяет Valkey (фоновый поток). Реплика, заметившая сбой, перестаёт
пользоваться кэшем, а когда Valkey вернулся, СНАЧАЛА записывает новое случайное поколение
и только потом снова включает кэш. Зачем: пока Valkey был недоступен, logout не мог положить
отметку «отозвано», и в кэше могла остаться старая запись «токен -> пользователь». После смены
поколения её не доверяет ни одна реплика: проверка идёт в PostgreSQL, где сессия отозвана -> 401.
Отметки «отозвано» действуют в любом поколении: они только запрещают, а не разрешают;
- если Valkey недоступен, его обходят: всё работает напрямую через PostgreSQL.
Ожидание подключения (в Docker это ещё и поиск DNS-имени остановленного контейнера,
до нескольких секунд) достаётся фоновому потоку, а не запросам пользователей.
"""
import json
import logging
import secrets
import threading
import time
from dataclasses import asdict, dataclass
from datetime import datetime, timedelta, timezone
import valkey
from . import config, security
from .store import PostgresStore, User, ts
log = logging.getLogger("messenger.sessions")
@dataclass(frozen=True)
class AuthContext:
"""Результат успешной проверки токена: кто пришёл и какой сессией (нужно для logout)."""
user: User
token_hash: bytes
class SessionCache:
PREFIX = "sess:" # пользователю Valkey разрешены только ключи sess:* (ACL: secrets/valkey_users.acl)
GENERATION_KEY = PREFIX + "gen" # общее для всех реплик поколение кэша
NO_GENERATION = "-" # sess:gen ещё не создан (свежий Valkey)
def __init__(self, url: str):
self._client = None
self._down = False # True = кэш считается недоступным, запросы его не трогают
self._lock = threading.Lock()
self._monitor = None
if url:
timeout = config.CACHE_TIMEOUT_MS / 1000
# С lab7: valkeys:// — TLS с проверкой сертификата valkey нашим CA и имени сервера;
# пароль пользователя messenger (ACL) — из OpenBao, в адресе его нет.
tls = {"ssl_ca_certs": config.TLS_CA_FILE, "ssl_cert_reqs": "required",
"ssl_check_hostname": True} if url.startswith(("valkeys://", "rediss://")) else {}
pool = valkey.BlockingConnectionPool.from_url(
url,
password=config.CACHE_PASSWORD or None,
**tls,
max_connections=config.CACHE_POOL_MAX_SIZE, # ограниченный пул соединений
timeout=timeout, # сколько ждать свободное соединение
socket_timeout=timeout, # сколько ждать ответ
socket_connect_timeout=timeout, # сколько ждать подключение
lib_name=None, lib_version=None,
)
self._client = valkey.Valkey(connection_pool=pool)
@property
def enabled(self) -> bool:
return self._client is not None
def _available(self) -> bool:
return self._client is not None and not self._down
def _failed(self, operation: str, exc: Exception) -> None:
with self._lock:
if self._down: # уже знаем о сбое
return
self._down = True
log.warning("Valkey недоступен (%s при %s): работаем напрямую с PostgreSQL",
type(exc).__name__, operation)
# --- фоновая проверка Valkey (один поток на процесс) ---
def start_monitor(self) -> None:
if self._client is None or self._monitor is not None:
return
self._monitor = threading.Thread(target=self._watch, name="valkey-monitor", daemon=True)
self._monitor.start()
def _watch(self) -> None:
while True:
if not self._down:
try:
# Проверка связи и заодно «создать поколение, если его ещё нет» (свежий Valkey).
# NX: существующее поколение не трогаем.
self._client.set(self.GENERATION_KEY, secrets.token_hex(8), nx=True)
except valkey.ValkeyError as exc:
self._failed("heartbeat", exc)
else:
try:
# Valkey вернулся. Сначала НОВОЕ общее поколение: всё, что лежало в кэше до сбоя,
# перестаёт быть доверенным для ВСЕХ реплик. Только потом снова пользуемся кэшем.
self._client.set(self.GENERATION_KEY, secrets.token_hex(8))
with self._lock:
self._down = False
log.info("Valkey снова доступен: новое поколение кэша, записи до сбоя не используются")
except valkey.ValkeyError:
pass
time.sleep(config.CACHE_CHECK_INTERVAL_SECONDS)
# --- операции с кэшем; любая ошибка -> кэш выключается до возвращения Valkey ---
def lookup(self, key: bytes) -> tuple[dict | None, str] | None:
"""(запись или None, текущее поколение) одним запросом MGET. None — кэш недоступен."""
if not self._available():
return None
try:
raw, generation = self._client.mget(self.PREFIX + key.hex(), self.GENERATION_KEY)
except valkey.ValkeyError as exc:
self._failed("mget", exc)
return None
entry = None if raw is None else json.loads(raw)
return entry, (generation.decode() if generation else self.NO_GENERATION)
def generation(self) -> str | None:
"""Текущее поколение (перед созданием сессии). None — кэш недоступен."""
if not self._available():
return None
try:
value = self._client.get(self.GENERATION_KEY)
except valkey.ValkeyError as exc:
self._failed("get", exc)
return None
return value.decode() if value else self.NO_GENERATION
def add(self, key: bytes, value: dict, ttl_ms: int) -> None:
"""Положить запись, только если ключа ещё нет (SET NX): отметку «отозвано» не затираем."""
if not self._available() or ttl_ms < 100:
return
try:
self._client.set(self.PREFIX + key.hex(), json.dumps(value), px=ttl_ms, nx=True)
except valkey.ValkeyError as exc:
self._failed("set", exc)
def mark_revoked(self, key: bytes) -> None:
"""Заменить запись о сессии отметкой «отозвано» на SESSION_CACHE_TTL_SECONDS."""
if not self._available():
return # запись в кэше осталась, но после возвращения Valkey сменится поколение
try:
self._client.set(self.PREFIX + key.hex(), json.dumps({"revoked": True}),
px=config.SESSION_CACHE_TTL_SECONDS * 1000)
except valkey.ValkeyError as exc:
self._failed("set", exc)
def ping(self) -> bool:
try:
return bool(self._client and self._client.ping())
except valkey.ValkeyError:
return False
def hit(self, key: str, window_seconds: int) -> tuple[int, int] | None:
"""Счётчик окна для лимита частоты (с lab7): +1 и (значение, секунд до сброса).
Общий для всех реплик (ключи rl:*, ACL пользователя messenger). None — Valkey недоступен,
тогда ratelimit.py считает локально в реплике.
"""
if not self._available():
return None
name = "rl:" + key
try:
pipe = self._client.pipeline(transaction=True) # MULTI/EXEC: три команды атомарно
pipe.set(name, 0, ex=window_seconds, nx=True)
pipe.incr(name)
pipe.ttl(name)
_, count, ttl = pipe.execute()
except valkey.ValkeyError as exc:
self._failed("rate-limit", exc)
return None
return int(count), max(int(ttl), 1)
def peek(self, key: str) -> tuple[int, int] | None:
"""Текущее значение счётчика без увеличения: (значение, секунд до сброса)."""
if not self._available():
return None
try:
pipe = self._client.pipeline(transaction=False)
pipe.get("rl:" + key)
pipe.ttl("rl:" + key)
raw, ttl = pipe.execute()
except valkey.ValkeyError as exc:
self._failed("rate-limit", exc)
return None
return int(raw or 0), max(int(ttl), 1)
def reset(self, key: str) -> None:
if not self._available():
return
try:
self._client.delete("rl:" + key)
except valkey.ValkeyError as exc:
self._failed("rate-limit", exc)
class Sessions:
def __init__(self, store: PostgresStore, cache: SessionCache, ttl_seconds: int):
self.store = store
self.cache = cache
self.ttl_seconds = ttl_seconds
def login(self, username: str, password: str) -> tuple[str, str, User] | None:
"""Проверяет пароль и создаёт сессию. None — неверные credentials (без уточнений)."""
if not security.PASSWORD_MIN <= len(password) <= security.PASSWORD_MAX:
return None
if not security.USERNAME_RE.fullmatch(username):
return None # такого username не может существовать — в базу даже не ходим
found = self.store.get_credentials(username)
user, password_hash = found if found else (None, None)
# Проверка выполняется и для несуществующего пользователя (с фиктивным hash):
# одинаковое время ответа и одинаковый 401 не раскрывают, есть ли такой username.
if not security.verify_password(password_hash, password) or user is None:
return None
if security.needs_rehash(password_hash):
# С lab7: hash старыми параметрами (слабее текущих ARGON2_*) пересчитывается сейчас,
# пока у нас есть открытый пароль, — пользователю ничего делать не нужно.
if self.store.update_password_hash(user.id, password_hash, security.hash_password(password)):
log.info("Hash пароля пересчитан с параметрами %s", security.parameters(),
extra={"event": "auth.password_rehashed"})
token = security.new_token()
key = security.token_hash(token)
generation = self.cache.generation()
expires_at = self.store.create_session(key, user.id, self.ttl_seconds)
self._remember(key, user, expires_at, generation) # следующий запрос сразу попадёт в кэш
return token, ts(expires_at), user
def authenticate(self, token: str) -> AuthContext | None:
key = security.token_hash(token)
# Поколение читаем ДО обращения к базе (вместе с записью, одним MGET): если во время
# запроса случится сбой Valkey и поколение сменится, наша запись окажется недоверенной.
looked = self.cache.lookup(key)
generation = None
if looked is not None:
cached, generation = looked
if cached is not None:
if cached.get("revoked"):
return None # logout уже был
expires_at = datetime.fromisoformat(cached["expires_at"])
if cached.get("gen") == generation and expires_at > datetime.now(timezone.utc):
return AuthContext(User(**cached["user"]), key)
# запись другого поколения или истёкшая -> проверяем по источнику истины
found = self.store.get_session(key) # промах кэша, недоверенная запись или кэш недоступен
if found is None:
return None
user, expires_at = found
self._remember(key, user, expires_at, generation)
return AuthContext(user, key)
def logout(self, auth: AuthContext) -> None:
self.store.revoke_session(auth.token_hash) # сначала источник истины
self.cache.mark_revoked(auth.token_hash) # затем инвалидация кэша
def _remember(self, key: bytes, user: User, expires_at: datetime, generation: str | None) -> None:
if generation is None:
return # кэш был недоступен, когда мы начинали: ничего не кладём
left = expires_at - datetime.now(timezone.utc)
ttl = min(timedelta(seconds=config.SESSION_CACHE_TTL_SECONDS), left)
self.cache.add(key, {"user": asdict(user), "expires_at": expires_at.isoformat(), "gen": generation},
int(ttl.total_seconds() * 1000))
+620
View File
@@ -0,0 +1,620 @@
"""Хранилище на PostgreSQL.
С lab2 источник истины — база данных, а не память процесса. Методы и их смысл
те же, что у InMemoryStore из lab1, поэтому api.py почти не изменился.
Модуль по-прежнему ничего не знает про HTTP: он хранит данные и соблюдает правила.
С lab4 здесь же метаданные вложений (таблицы attachments и message_attachments):
сами байты файлов лежат в S3 (objects.py), в базе только описание и ключ объекта.
С lab5 загрузка в одной транзакции создаёт вложение (queued), задание и строку outbox
(jobs.py), а варианты и состояния обработки пишет worker.
Все SQL-запросы параметризованные: значения передаются отдельно от текста запроса
(%s), поэтому ввод пользователя никогда не становится частью SQL (нет SQL-инъекций).
"""
import logging
import uuid
from contextlib import contextmanager
from dataclasses import dataclass
from datetime import datetime, timezone
import psycopg
from psycopg import errors as pg_errors
from psycopg_pool import ConnectionPool, PoolTimeout
from . import config, faults, jobs
from .errors import Conflict, InvalidRequest, NotFound, Unavailable
log = logging.getLogger("messenger.store")
@dataclass(frozen=True)
class User:
id: str
username: str
display_name: str
created_at: str
@dataclass(frozen=True)
class Chat:
id: str
title: str
member_ids: tuple[str, ...]
created_at: str
@dataclass(frozen=True)
class Message:
id: str
chat_id: str
sender_id: str
text: str
created_at: str
attachment_ids: tuple[str, ...] = ()
@dataclass(frozen=True)
class Attachment:
"""Вложение в формате контракта. Ключи объектов в S3 сюда не входят: наружу они не отдаются.
size_bytes, sha256 и content_type всегда описывают ОРИГИНАЛ; у вариантов свои поля.
variants заполнен только у ready, error_code — только у failed.
"""
id: str
chat_id: str
owner_id: str
filename: str
content_type: str
size_bytes: int
sha256: str
status: str
variants: list
error_code: str | None
created_at: str = ""
updated_at: str = ""
VARIANT_ORDER = ("thumbnail", "crop", "optimized")
def sort_key(item) -> tuple[str, str]:
"""Порядок по контракту: (created_at, id) по возрастанию. Из этой пары строится курсор."""
return item.created_at, item.id
def ts(value: datetime) -> str:
"""Время из БД -> строка RFC 3339 в UTC с Z и микросекундами (как в lab1)."""
return value.astimezone(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ")
# Свободный текст (display_name, title, text) хранится в БД как байты UTF-8 (bytea), а не text:
# тип text в PostgreSQL не может содержать символ U+0000, а контракт его не запрещает.
# См. migrations/003_text_as_bytes.sql. Перед записью кодируем, после чтения декодируем.
def to_db(value: str) -> bytes:
return value.encode("utf-8")
def from_db(value) -> str:
return bytes(value).decode("utf-8")
def _user(row) -> User:
return User(str(row[0]), row[1], from_db(row[2]), ts(row[3]))
def _chat(row) -> Chat:
return Chat(str(row[0]), from_db(row[1]), tuple(str(m) for m in row[3]), ts(row[2]))
def _message(row, attachment_ids=None) -> Message:
ids = row[5] if attachment_ids is None and len(row) > 5 else (attachment_ids or ())
return Message(str(row[0]), str(row[1]), str(row[2]), from_db(row[3]), ts(row[4]),
tuple(str(a) for a in ids))
# Вложения сообщения в порядке из запроса: подзапрос по первичному ключу (message_id, position).
_MESSAGE_ATTACHMENTS = """ARRAY(SELECT ma.attachment_id FROM message_attachments ma
WHERE ma.message_id = m.id ORDER BY ma.position)"""
# Варианты текущей версии pipeline, в порядке контракта; у не-ready вложения список пуст.
# PIPELINE_VERSION — целая константа из кода (не ввод пользователя), поэтому подставлена в текст SQL.
_VARIANTS = f"""CASE WHEN a.status = 'ready' THEN COALESCE((
SELECT json_agg(json_build_object('name', v.name, 'content_type', v.content_type,
'size_bytes', v.size_bytes, 'width', v.width,
'height', v.height, 'sha256', v.sha256)
ORDER BY array_position(ARRAY['thumbnail', 'crop', 'optimized'], v.name))
FROM attachment_variants v
WHERE v.attachment_id = a.id AND v.pipeline_version = {int(config.PIPELINE_VERSION)}), '[]'::json)
ELSE '[]'::json END"""
_ATTACHMENT_COLUMNS = ("a.id, a.chat_id, a.owner_id, a.filename, a.content_type, a.size_bytes, a.sha256, "
"a.status, a.created_at, a.updated_at, a.storage_key, a.error_code, " + _VARIANTS)
# Advisory-блокировки PostgreSQL по ID вложения (замечание к MR про уборщика): пространство «l5»,
# чтобы не пересечься с другими advisory-блокировками. Ключ — первые 32 бита UUID: совпадение у двух
# вложений возможно, но безвредно (уборщик пропустит одно из них до следующего прохода).
_LOCK_NAMESPACE = 0x6C35
def attachment_lock(attachment_id: str) -> tuple[int, int]:
return _LOCK_NAMESPACE, int.from_bytes(uuid.UUID(attachment_id).bytes[:4], "big", signed=True)
def _cleanup_decision(row, variant_keys: set, key: str) -> tuple[str, str]:
"""Можно ли удалить объект key вложения, если row — его ТЕКУЩЕЕ состояние (прочитано под блокировкой).
row = (status, staging_key, storage_key, failed и retention истёк) или None (строки нет).
Возвращает ("delete" | "keep", причина). «delete» дан только там, где удаление безопасно
навсегда: объект удаляется уже после COMMIT, без блокировок, и состояние к тому времени может
поменяться только так, что этот объект всё равно никому не понадобится.
"""
if row is None:
# Строки нет, а блокировку ID никто не держит: загрузка с этим ID закончилась без COMMIT
# (новая загрузка всегда получает новый UUID), строка не появится уже никогда.
return "delete", "orphan"
status, staging_key, storage_key, expired = row
if status in ("queued", "processing"):
return "keep", "current_work" # worker может прямо сейчас читать staging и писать результат
if status == "ready": # ready не меняется (replay готового — no-op)
if key == storage_key or key in variant_keys:
return "keep", "published"
return ("delete", "staging_after_ready") if key == staging_key else ("delete", "orphan")
# failed: пока не истёк retention и исходник на месте, возможен replay — он заново запишет оригинал
# и варианты в те же ключи, поэтому ничего не трогаем. После retention staging помечается удалённым
# (staging_key = NULL): replay уже невозможен, и все объекты вложения можно удалить.
if not expired and staging_key is not None:
return "keep", "staging_kept_for_replay" if key == staging_key else "failed_kept_for_replay"
return "delete", "staging_failed_expired" if key.startswith("staging/") else "orphan"
def _attachment(row) -> tuple[Attachment, str]:
"""(вложение для ответа, ключ оригинала в S3 — только для сервера)."""
return (Attachment(str(row[0]), str(row[1]), str(row[2]), row[3], row[4], int(row[5]), row[6], row[7],
list(row[12] or []), row[11], ts(row[8]), ts(row[9])), row[10])
# Участники чата всегда в одном порядке (по UUID), чтобы POST и GET отвечали одинаково.
_CHAT_COLUMNS = """c.id, c.title, c.created_at,
ARRAY(SELECT cm.user_id FROM chat_members cm WHERE cm.chat_id = c.id ORDER BY cm.user_id)"""
class PostgresStore:
def __init__(self, pool: ConnectionPool):
self.pool = pool
@contextmanager
def _conn(self, timeout: float | None = None):
"""Соединение из пула. В конце блока — COMMIT, при исключении — ROLLBACK.
Если база недоступна (нет соединения, истёк таймаут пула или запроса),
клиент получает 503 без подробностей, а не 500 со stack trace.
"""
try:
with self.pool.connection(timeout=timeout) as conn:
yield conn
except (psycopg.OperationalError, PoolTimeout) as exc:
log.warning("PostgreSQL недоступен: %s", type(exc).__name__)
raise Unavailable("Хранилище временно недоступно") from None
except psycopg.DataError as exc:
# База отвергла само значение (например, недопустимый символ): это ошибка входа -> 400,
# а не внутренняя ошибка сервера (500).
log.warning("PostgreSQL отверг значение: %s", type(exc).__name__)
raise InvalidRequest("Недопустимое значение в запросе") from None
def ping(self, timeout: float = 1.0) -> None:
"""Проверка готовности: короткий таймаут, чтобы healthcheck (3 с) успел получить 503."""
with self._conn(timeout) as conn:
conn.execute("SELECT 1")
# --- пользователи ---
def create_user(self, username: str, display_name: str, password_hash: str) -> User:
try:
with self._conn() as conn:
row = conn.execute(
"""INSERT INTO users (id, username, display_name, password_hash)
VALUES (%s, %s, %s, %s)
RETURNING id, username, display_name, created_at""",
(uuid.uuid4(), username, to_db(display_name), password_hash)).fetchone()
except pg_errors.UniqueViolation:
# Не «проверить, потом вставить» (между этими шагами успеет вклиниться другой запрос),
# а сразу вставить: уникальный индекс в БД пропустит ровно одну регистрацию.
raise Conflict("Имя пользователя уже занято") from None
return _user(row)
def get_credentials(self, username: str) -> tuple[User, str] | None:
"""Пользователь и hash его пароля — только для проверки при входе."""
with self._conn() as conn:
row = conn.execute(
"""SELECT id, username, display_name, created_at, password_hash
FROM users WHERE username = %s""", (username,)).fetchone()
return None if row is None else (_user(row), row[4])
def update_password_hash(self, user_id: str, old_hash: str, new_hash: str) -> bool:
"""Rehash при входе (с lab7): заменить hash, только если он не поменялся параллельно."""
with self._conn() as conn:
cur = conn.execute("UPDATE users SET password_hash = %s WHERE id = %s AND password_hash = %s",
(new_hash, user_id, old_hash))
return cur.rowcount == 1
# --- чаты ---
def create_chat(self, creator_id: str, title: str, member_ids: list[str]) -> Chat:
if len(set(member_ids)) != len(member_ids):
raise InvalidRequest("Участники чата повторяются")
if creator_id not in member_ids:
raise InvalidRequest("Создатель чата должен входить в member_ids")
members = sorted(uuid.UUID(m) for m in member_ids)
chat_id = uuid.uuid4()
try:
with self._conn() as conn:
# Одна транзакция: чат и все участники записываются вместе или не записываются вовсе.
with conn.transaction():
self._check_members_exist(conn, members)
created_at = conn.execute(
"INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at",
(chat_id, to_db(title))).fetchone()[0]
with conn.cursor() as cur:
cur.executemany("INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)",
[(chat_id, m) for m in members])
except pg_errors.ForeignKeyViolation:
# Сюда попадаем, только если проверка выше пропустила несуществующего участника.
# Транзакция уже откатилась: строки чата в базе не осталось.
raise InvalidRequest("Среди участников есть несуществующий пользователь") from None
return Chat(str(chat_id), title, tuple(str(m) for m in members), ts(created_at))
@staticmethod
def _check_members_exist(conn, members: list[uuid.UUID]) -> None:
found = conn.execute("SELECT count(*) FROM users WHERE id = ANY(%s)", (members,)).fetchone()[0]
if found != len(members):
raise InvalidRequest("Среди участников есть несуществующий пользователь")
def get_chat(self, user_id: str, chat_id: str) -> Chat:
with self._conn() as conn:
row = conn.execute(
f"""SELECT {_CHAT_COLUMNS} FROM chats c
WHERE c.id = %s AND EXISTS (
SELECT 1 FROM chat_members cm WHERE cm.chat_id = c.id AND cm.user_id = %s)""",
(uuid.UUID(chat_id), uuid.UUID(user_id))).fetchone()
if row is None:
# Один и тот же ответ для «чата нет» и «чат чужой»:
# посторонний не должен узнать, что такой чат существует.
raise NotFound("Чат не найден")
return _chat(row)
def list_chats(self, user_id: str, after: tuple[datetime, uuid.UUID] | None, limit: int):
query = f"""SELECT {_CHAT_COLUMNS}
FROM chat_members me JOIN chats c ON c.id = me.chat_id
WHERE me.user_id = %s {{after}}
ORDER BY c.created_at, c.id
LIMIT %s"""
params: list = [uuid.UUID(user_id)]
if after is None:
query = query.format(after="")
else:
query = query.format(after="AND (c.created_at, c.id) > (%s, %s)")
params += [after[0], after[1]]
with self._conn() as conn:
rows = conn.execute(query, (*params, limit + 1)).fetchall()
return [_chat(r) for r in rows[:limit]], len(rows) > limit
# --- сообщения ---
def add_message(self, user_id: str, chat_id: str, text: str,
idempotency_key: str, request_hash: bytes,
attachment_ids: tuple[str, ...] = ()) -> tuple[Message, bool]:
"""Сохраняет сообщение ровно один раз на ключ. Возвращает (сообщение, это_повтор).
Ключ и SHA-256 тела запроса лежат прямо в строке сообщения, а уникальное ограничение
(chat_id, sender_id, idempotency_key) не даёт записать второе сообщение с тем же ключом.
Поэтому само сообщение и «запомненный результат» — одна строка и один INSERT:
они сохраняются атомарно, по отдельности их записать нельзя.
Два одновременных запроса с одним ключом (даже через разные реплики): PostgreSQL
заставляет второй INSERT ждать, пока завершится транзакция первого. Первый закоммитил —
у второго ON CONFLICT DO NOTHING ничего не вставляет, и он читает готовую строку.
Первый откатился (ошибка, 5xx) — второй просто вставляет: неудача ключ не «занимает».
С lab4 в той же транзакции записываются ссылки на вложения. Каждое должно быть вложением
ЭТОГО чата, иначе 404 и откат: сообщение без своих вложений не сохранится.
С lab5 можно ссылаться на вложение, которое ещё обрабатывается (queued, processing);
на failed — нельзя (409).
"""
chat, user = uuid.UUID(chat_id), uuid.UUID(user_id)
with self._conn() as conn:
# Один SQL-оператор: вставка произойдёт, только если отправитель — участник чата.
# Отправитель берётся из сессии, а не из тела запроса.
row = conn.execute(
"""INSERT INTO messages (id, chat_id, sender_id, text, idempotency_key, request_hash)
SELECT %s, cm.chat_id, cm.user_id, %s, %s, %s
FROM chat_members cm WHERE cm.chat_id = %s AND cm.user_id = %s
ON CONFLICT (chat_id, sender_id, idempotency_key) DO NOTHING
RETURNING id, chat_id, sender_id, text, created_at""",
(uuid.uuid4(), to_db(text), idempotency_key, request_hash, chat, user)).fetchone()
if row is not None:
if attachment_ids:
self._link_attachments(conn, row[0], chat, attachment_ids)
return _message(row, attachment_ids), False # новое сообщение
# Ничего не вставилось: либо пользователь не участник чата, либо ключ уже использован.
# Повтор тоже заново проверяет доступ (сессию уже проверил middleware).
member = conn.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat, user)).fetchone()
if member is None:
raise NotFound("Чат не найден")
saved = conn.execute(
f"""SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, m.request_hash,
{_MESSAGE_ATTACHMENTS}
FROM messages m
WHERE m.chat_id = %s AND m.sender_id = %s AND m.idempotency_key = %s""",
(chat, user, idempotency_key)).fetchone()
if saved is None:
# Не должно случаться (строка с ключом есть, раз INSERT ничего не вставил).
# Ответ 503 ничего не фиксирует: клиент повторит запрос с тем же ключом.
raise Unavailable("Повторите запрос")
if bytes(saved[5]) != request_hash:
raise Conflict("Idempotency-Key уже использован с другим телом запроса")
return _message(saved[:5], saved[6]), True # тот же ответ, что и в первый раз
@staticmethod
def _link_attachments(conn, message_id, chat: uuid.UUID, attachment_ids) -> None:
ids = [uuid.UUID(a) for a in attachment_ids]
# FOR SHARE: пока транзакция не завершена, статус этих вложений не изменится
# (worker, переводящий вложение в failed, подождёт COMMIT сообщения).
statuses = [r[0] for r in conn.execute(
"SELECT status FROM attachments WHERE id = ANY(%s) AND chat_id = %s FOR SHARE", (ids, chat))]
if len(statuses) != len(ids):
# Чужое или неизвестное вложение — один ответ, без подробностей.
raise NotFound("Вложение не найдено в этом чате")
if "failed" in statuses:
raise Conflict("Вложение не удалось обработать (failed), его нельзя прикрепить")
with conn.cursor() as cur:
cur.executemany("""INSERT INTO message_attachments (message_id, attachment_id, position)
VALUES (%s, %s, %s)""",
[(message_id, a, i) for i, a in enumerate(ids)])
def list_messages(self, user_id: str, chat_id: str,
after: tuple[datetime, uuid.UUID] | None, limit: int):
chat, user = uuid.UUID(chat_id), uuid.UUID(user_id)
# Keyset-пагинация: «следующие limit записей после ключа», а не OFFSET.
# С индексом (chat_id, created_at, id) база сразу встаёт на нужное место индекса
# и читает только limit+1 строк, сколько бы сообщений ни было в чате.
if after is None:
query = f"""SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, {_MESSAGE_ATTACHMENTS}
FROM messages m WHERE m.chat_id = %s
ORDER BY m.created_at, m.id LIMIT %s"""
params = (chat, limit + 1)
else:
query = f"""SELECT m.id, m.chat_id, m.sender_id, m.text, m.created_at, {_MESSAGE_ATTACHMENTS}
FROM messages m WHERE m.chat_id = %s AND (m.created_at, m.id) > (%s, %s)
ORDER BY m.created_at, m.id LIMIT %s"""
params = (chat, after[0], after[1], limit + 1)
with self._conn() as conn:
member = conn.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s",
(chat, user)).fetchone()
if member is None:
raise NotFound("Чат не найден")
rows = conn.execute(query, params).fetchall()
return [_message(r) for r in rows[:limit]], len(rows) > limit
# --- вложения: метаданные здесь, байты в S3 ---
@contextmanager
def receiving(self, attachment_id: str):
"""Транзакция приёма файла (замечание к MR про уборщика).
Блокировка ID вложения (advisory, attachment_lock) берётся ДО записи в staging и держится
до COMMIT строки вложения. Уборщик (cleanup_attachment) берёт ту же блокировку без ожидания:
пока загрузка идёт, её staging для него «занят», даже если строки в БД ещё нет. Упал API —
PostgreSQL сам снимает блокировку вместе с сессией, и объект без строки уберётся как «сирота».
Если процесс API завис посреди загрузки, сессию закроет idle_in_transaction_session_timeout
(30 с: запись в staging ограничена 6 с, остальное — запас для медленного диска и точки-паузы теста).
"""
with self._conn() as conn, conn.transaction():
conn.execute("SET LOCAL idle_in_transaction_session_timeout = '30s'")
conn.execute("SELECT pg_advisory_xact_lock(%s, %s)", attachment_lock(attachment_id))
yield conn
def create_queued_attachment(self, attachment_id: str, user_id: str, chat_id: str, filename: str,
content_type: str, size_bytes: int, sha256: str, width: int, height: int,
staging_key: str, storage_key: str, actor: str, conn=None) -> Attachment:
"""Устойчивый приём (с lab5): оригинал уже в staging S3; теперь одной транзакцией —
вложение (queued), задание и строка outbox для брокера. После COMMIT можно отвечать 202.
conn — транзакция receiving(), в которой оригинал записывался в staging (attachments.py).
Вставка вложения идёт, только если пользователь — участник чата (иначе 404).
"""
if conn is None:
with self.receiving(attachment_id) as conn:
return self.create_queued_attachment(attachment_id, user_id, chat_id, filename, content_type,
size_bytes, sha256, width, height, staging_key, storage_key,
actor, conn)
row = conn.execute(
f"""INSERT INTO attachments AS a (id, chat_id, owner_id, filename, content_type, size_bytes,
sha256, width, height, storage_key, staging_key, status)
SELECT %s, cm.chat_id, cm.user_id, %s, %s, %s, %s, %s, %s, %s, %s, 'queued'
FROM chat_members cm WHERE cm.chat_id = %s AND cm.user_id = %s
RETURNING {_ATTACHMENT_COLUMNS}""",
(uuid.UUID(attachment_id), filename, content_type, size_bytes, sha256, width, height,
storage_key, staging_key, uuid.UUID(chat_id), uuid.UUID(user_id))).fetchone()
if row is None:
raise NotFound("Чат не найден")
jobs.create(conn, row[0], actor)
return _attachment(row)[0]
def get_attachment(self, user_id: str, attachment_id: str) -> tuple[Attachment, str]:
"""Вложение в любом состоянии — только для участника чата. Иначе 404 без подробностей."""
with self._conn() as conn:
row = conn.execute(
f"""SELECT {_ATTACHMENT_COLUMNS} FROM attachments a
WHERE a.id = %s AND EXISTS (
SELECT 1 FROM chat_members cm WHERE cm.chat_id = a.chat_id AND cm.user_id = %s)""",
(uuid.UUID(attachment_id), uuid.UUID(user_id))).fetchone()
if row is None:
raise NotFound("Вложение не найдено")
return _attachment(row)
def get_content(self, user_id: str, attachment_id: str, variant: str) -> tuple[str, str, int]:
"""Что отдать на /content: (ключ объекта, Content-Type, размер).
Порядок проверок: участник чата (иначе 404) -> готово ли (queued/processing/failed -> 409)
-> есть ли такой вариант у готового вложения (нет -> 404).
"""
attachment, key = self.get_attachment(user_id, attachment_id)
if attachment.status != "ready":
raise Conflict(f"Вложение ещё не готово (status={attachment.status})")
if variant == "original":
return key, attachment.content_type, attachment.size_bytes
with self._conn() as conn:
row = conn.execute("""SELECT storage_key, content_type, size_bytes FROM attachment_variants
WHERE attachment_id = %s AND pipeline_version = %s AND name = %s""",
(uuid.UUID(attachment_id), config.PIPELINE_VERSION, variant)).fetchone()
if row is None:
raise NotFound("Такого варианта у вложения нет")
return row[0], row[1], int(row[2])
# --- для уборщика (cleanup.py) ---
def storage_references(self, retention_seconds: int) -> dict:
"""Снимок ссылок для ПРЕДВАРИТЕЛЬНОГО отбора: ключ -> причина, почему объект нужен.
Нужны: оригиналы ready-вложений, их варианты, staging-оригиналы заданий в работе
(queued, processing) и staging failed-вложений моложе retention (для replay).
Снимок только отсекает заведомо нужное. Удалять по нему нельзя: пока уборщик идёт по
списку, состояние меняется (замечание к MR). Окончательно решает cleanup_attachment
под блокировками по текущему состоянию.
"""
with self._conn() as conn:
rows = conn.execute(
"""SELECT a.status, a.storage_key, a.staging_key,
a.status = 'failed' AND a.updated_at < now() - make_interval(secs => %s)
FROM attachments a""", (retention_seconds,)).fetchall()
variant_keys = [r[0] for r in conn.execute("SELECT storage_key FROM attachment_variants")]
needed, done = {}, {}
for status, storage_key, staging_key, expired in rows:
if status == "ready":
needed[storage_key] = "original"
if staging_key:
done[staging_key] = "staging_after_ready"
elif status in ("queued", "processing"):
if staging_key:
needed[staging_key] = "staging_in_work"
elif staging_key: # failed
if expired:
done[staging_key] = "staging_failed_expired"
else:
needed[staging_key] = "staging_failed_kept"
for key in variant_keys:
needed[key] = "variant"
ready_originals = {key for key, why in needed.items() if why == "original"}
return {"needed": needed, "done": done, "ready_originals": ready_originals}
def cleanup_attachment(self, attachment_id: str, keys: list[str], retention_seconds: int,
delete=None, actor: str = "cleanup") -> dict | None:
"""Уборка объектов ОДНОГО вложения: решение принимается заново, под блокировками (замечание к MR).
Снимок ссылок (storage_references) мог устареть, пока уборщик шёл по списку: оператор сделал
replay, загрузка закоммитила строку, worker записал объекты. Поэтому две фазы.
Фаза 1 — короткая транзакция:
1. advisory-блокировка ID вложения без ожидания — её держит идущая загрузка (receiving):
занято -> None, объекты остаются до следующего прохода;
2. блокировка строк задания и вложения (FOR NO KEY UPDATE; порядок тот же, что у claim,
complete и replay: сначала задание, потом вложение) — переходы состояния ждут, а уборщик
читает ТЕКУЩЕЕ состояние;
3. решение (_cleanup_decision). Если удаляется staging истёкшего failed-вложения, он сначала
помечается в БД удалённым (staging_key = NULL, запись staging_expired в журнале) — COMMIT.
Replay, который ждал блокировку или придёт позже, видит, что исходника нет, и отказывает.
Фаза 2 — удаление из S3 уже без блокировок. Удаляется только то, что после фазы 1 не может
понадобиться никогда (см. _cleanup_decision), поэтому медленный S3 не держит блокировки,
а оборванная сессия БД не открывает окно для гонки.
delete=None — пробный прогон: решения те же, но ничего не меняется.
Возвращает {"delete": [(ключ, причина)], "keep": [(ключ, почему)]} или None (занято).
"""
aid = uuid.UUID(attachment_id)
with self._conn() as conn:
try:
with conn.transaction():
if not conn.execute("SELECT pg_try_advisory_xact_lock(%s, %s)",
attachment_lock(attachment_id)).fetchone()[0]:
return None
conn.execute("SET LOCAL lock_timeout = '3s'")
# Транзакция короткая; запас — для медленной базы и точки-паузы теста (faults.py).
conn.execute("SET LOCAL idle_in_transaction_session_timeout = '30s'")
job_rows = conn.execute("""SELECT job_id, attempt FROM attachment_jobs WHERE attachment_id = %s
FOR NO KEY UPDATE""", (aid,)).fetchall()
row = conn.execute(
"""SELECT status, staging_key, storage_key,
status = 'failed' AND updated_at < now() - make_interval(secs => %s)
FROM attachments WHERE id = %s FOR NO KEY UPDATE""", (retention_seconds, aid)).fetchone()
variant_keys = {r[0] for r in conn.execute(
"SELECT storage_key FROM attachment_variants WHERE attachment_id = %s", (aid,))}
decisions = [(key, *_cleanup_decision(row, variant_keys, key)) for key in keys]
orphans = [key for key, action, why in decisions if why == "orphan"]
if orphans:
# Страховка: ключ «чужого» вида (например, оригинал lab4 со случайным ключом)
# может принадлежать другому вложению. На такой ключ ссылаются — не трогаем.
referenced = {r[0] for r in conn.execute(
"""SELECT t.k FROM unnest(%s::text[]) AS t(k)
WHERE EXISTS (SELECT 1 FROM attachments a
WHERE a.id <> %s AND (a.storage_key = t.k OR a.staging_key = t.k))
OR EXISTS (SELECT 1 FROM attachment_variants v
WHERE v.attachment_id <> %s AND v.storage_key = t.k)""",
(orphans, aid, aid))}
decisions = [(k, "keep", "referenced") if k in referenced else (k, a, w)
for k, a, w in decisions]
result = {"delete": [(k, w) for k, a, w in decisions if a == "delete"],
"keep": [(k, w) for k, a, w in decisions if a == "keep"]}
if delete is not None and result["delete"] and row is not None and row[0] == "failed" \
and row[1] is not None:
# У failed что-то удаляется, только когда retention истёк. Сначала — отметка
# «исходника нет» (даже если сам staging попадёт в уборку в следующий раз):
# после COMMIT replay невозможен, и объекты вложения больше никому не нужны.
conn.execute("UPDATE attachments SET staging_key = NULL WHERE id = %s", (aid,))
for job_id, attempt in job_rows:
jobs.event(conn, job_id, aid, attempt, "staging_expired", actor,
"retention истёк: исходник в staging удаляется уборщиком, replay невозможен")
faults.pause("cleanup_pause_locked") # проверка: replay ждёт эту транзакцию
except pg_errors.LockNotAvailable:
return None # строку держит переход состояния: попробуем в следующий раз
if delete is not None:
for key, _why in result["delete"]:
delete(key) # фаза 2: после COMMIT, без блокировок
return result
def delete_old_outbox(self, retention_seconds: int) -> int:
"""Отправленные строки outbox старше retention больше не нужны (журнал заданий остаётся)."""
with self._conn() as conn:
cur = conn.execute("""DELETE FROM outbox WHERE published_at IS NOT NULL
AND published_at < now() - make_interval(secs => %s)""", (retention_seconds,))
return cur.rowcount
# --- сессии (источник истины; Valkey — только кэш, см. sessions.py) ---
def create_session(self, token_hash: bytes, user_id: str, ttl_seconds: int) -> datetime:
with self._conn() as conn, conn.transaction():
# Заодно убираем у этого пользователя истёкшие и отозванные сессии: они уже не нужны.
conn.execute("""DELETE FROM sessions
WHERE user_id = %s AND (expires_at <= now() OR revoked_at IS NOT NULL)""",
(uuid.UUID(user_id),))
# Срок жизни считает часами PostgreSQL — теми же, по которым он потом проверяется.
return conn.execute(
"""INSERT INTO sessions (token_hash, user_id, expires_at)
VALUES (%s, %s, now() + make_interval(secs => %s))
RETURNING expires_at""",
(token_hash, uuid.UUID(user_id), ttl_seconds)).fetchone()[0]
def get_session(self, token_hash: bytes) -> tuple[User, datetime] | None:
"""Пользователь действующей сессии: не отозвана и не истекла. Иначе None."""
with self._conn() as conn:
row = conn.execute(
"""SELECT u.id, u.username, u.display_name, u.created_at, s.expires_at
FROM sessions s JOIN users u ON u.id = s.user_id
WHERE s.token_hash = %s AND s.revoked_at IS NULL AND s.expires_at > now()""",
(token_hash,)).fetchone()
return None if row is None else (_user(row), row[4])
def revoke_session(self, token_hash: bytes) -> bool:
with self._conn() as conn:
cur = conn.execute("UPDATE sessions SET revoked_at = now() "
"WHERE token_hash = %s AND revoked_at IS NULL", (token_hash,))
return cur.rowcount == 1
+383
View File
@@ -0,0 +1,383 @@
"""Телеметрия (с lab6): трассы, метрики и логи через OpenTelemetry SDK -> OTLP -> OTel Collector.
Процессы приложения ничего не хранят и не знают о Prometheus/Loki/Tempo: они отправляют три сигнала
по OTLP/HTTP в Collector (OTEL_EXPORTER_OTLP_ENDPOINT), а он раскладывает их по хранилищам.
Вызывается один раз при старте процесса: API (`python -m messenger`) и worker. Одноразовые
процессы (migrate, s3-init, CLI оператора) телеметрию не включают.
Ресурс (атрибуты, общие для всех сигналов процесса), contracts/observability.md:
service.name messenger-api | messenger-worker (OTEL_SERVICE_NAME)
service.version APP_VERSION (build arg)
service.instance.id INSTANCE_ID = hostname контейнера (как X-Instance-Id)
deployment.environment.name = lab (OTEL_RESOURCE_ATTRIBUTES)
Что НЕ попадает в телеметрию: тела запросов и сообщений, картинки, пароли, Authorization,
токены сессий, query-строки (filename, cursor). В логах и трассах — только ограниченные технические
ID (request_id, attachment_id, job_id) синтетических учебных данных: по ним upload связывается с
обработкой. В labels метрик ID нет вовсе: только маршрут-шаблон, метод, код, тип задания, исход.
Ограниченное поведение при недоступном Collector (третий сценарий контракта):
- трассы и логи копятся в очереди процесса (BatchProcessor) не больше чем MAX_QUEUE записей;
что не влезло — отбрасывается, а не копится в памяти;
- каждая отправка ограничена OTEL_EXPORTER_OTLP_TIMEOUT (5 с в .env; Python SDK читает его в секундах);
- метрики — накопительные (cumulative): пропущенная отправка не теряет счётчики, следующая
отправка несёт полные значения.
Отправка идёт в фоновых потоках SDK, поэтому обработка запросов не ждёт Collector.
"""
import json
import logging
import os
import sys
import threading
import time
from contextlib import contextmanager
from datetime import datetime, timezone
from opentelemetry import metrics, trace
from opentelemetry.trace import SpanKind, Status, StatusCode
from opentelemetry.trace.propagation.tracecontext import TraceContextTextMapPropagator
from . import config
log = logging.getLogger("messenger.telemetry")
# Только W3C Trace Context (traceparent/tracestate): поле baggage в сообщении брокера запрещено
# contracts/jobs.schema.json (additionalProperties: false), поэтому глобальный пропагатор не используем.
_PROPAGATOR = TraceContextTextMapPropagator()
MAX_QUEUE = 2048 # записей в очереди процесса на сигнал (трассы, логи)
EXPORT_BATCH = 512
METRIC_INTERVAL_MS = int(os.environ.get("OTEL_METRIC_EXPORT_INTERVAL", "10000"))
# Границы buckets гистограмм (секунды) — под ожидаемые задержки, а не значения по умолчанию.
# HTTP: границы задаёт сама инструментация FastAPI (semconv: 5 мс … 10 с).
JOB_DURATION_BUCKETS = (0.1, 0.25, 0.5, 1, 2, 3, 5, 10, 20, 30, 60, 120)
TIME_TO_READY_BUCKETS = (0.5, 1, 2, 3, 5, 10, 20, 30, 60, 120, 300, 600, 1800)
QUEUE_NAME = "attachments.process"
JOB_TYPE = "attachment.process"
_enabled = False
_providers = []
tracer = trace.get_tracer("messenger")
meter = metrics.get_meter("messenger")
def enabled() -> bool:
return _enabled
# ---------- выборка трасс ----------
def _sampler():
"""ParentBased(корень = всё, КРОМЕ «сиротских» CLIENT-спанов).
Фоновые циклы (relay опрашивает outbox раз в секунду, продление lease, проверка S3 для
readiness, сбор метрик очереди) делают SQL и S3-запросы без входящего запроса. Без фильтра
каждый такой запрос стал бы отдельной трассой из одного спана и забил бы Tempo шумом.
Запросы к БД и S3 внутри HTTP-запроса или обработки задания имеют родителя и сохраняются все.
"""
from opentelemetry.sdk.trace.sampling import ALWAYS_ON, Decision, ParentBased, Sampler, SamplingResult
class DropOrphanClientSpans(Sampler):
def should_sample(self, parent_context, trace_id, name, kind=None, attributes=None, links=None,
trace_state=None):
if kind == SpanKind.CLIENT:
return SamplingResult(Decision.DROP)
return ALWAYS_ON.should_sample(parent_context, trace_id, name, kind, attributes, links, trace_state)
def get_description(self):
return "DropOrphanClientSpans"
return ParentBased(root=DropOrphanClientSpans())
# ---------- логи ----------
class _EventFilter(logging.Filter):
"""У каждой записи есть поле event (имя события): задаётся через extra={"event": ...}.
Записи без явного события получают имя логгера (messenger.worker и т.п.).
"""
def filter(self, record):
if not getattr(record, "event", None):
record.event = record.name
return True
class _NotTelemetryItself(logging.Filter):
"""Логи самого SDK и HTTP-клиента экспортёра не отправляются по OTLP: иначе при недоступном
Collector каждая ошибка отправки порождала бы новую запись для отправки."""
def filter(self, record):
return not record.name.startswith(("opentelemetry", "urllib3", "requests"))
_STD = set(vars(logging.LogRecord("", 0, "", 0, "", None, None))) | {"message", "asctime", "taskName"}
class JsonFormatter(logging.Formatter):
"""Структурный лог в stdout (docker compose logs): одна строка JSON на запись.
Поля: timestamp, severity, service.name, event, logger, message, trace_id/span_id (если есть
активный span) и дополнительные поля из extra (request_id, route, status…).
"""
def __init__(self, service: str):
super().__init__()
self.service = service
def format(self, record):
entry = {
"timestamp": datetime.fromtimestamp(record.created, timezone.utc).isoformat(timespec="milliseconds"),
"severity": record.levelname,
"service.name": self.service,
"event": getattr(record, "event", record.name),
"logger": record.name,
"message": record.getMessage(),
}
ctx = trace.get_current_span().get_span_context()
if ctx.is_valid:
entry["trace_id"] = format(ctx.trace_id, "032x")
entry["span_id"] = format(ctx.span_id, "016x")
for key, value in vars(record).items():
if key not in _STD and key not in entry and key != "event":
entry[key] = value if isinstance(value, (str, int, float, bool)) or value is None else str(value)
if record.exc_info:
entry["exception"] = self.formatException(record.exc_info)
return json.dumps(entry, ensure_ascii=False)
def setup_logging(service: str) -> None:
root = logging.getLogger()
root.handlers.clear()
root.setLevel(logging.INFO)
stdout = logging.StreamHandler(sys.stdout)
stdout.addFilter(_EventFilter())
stdout.setFormatter(JsonFormatter(service))
root.addHandler(stdout)
for noisy in ("pika", "botocore", "boto3", "urllib3", "s3transfer"):
logging.getLogger(noisy).setLevel(logging.WARNING)
# ---------- инициализация ----------
def setup(service_name: str) -> None:
"""Включить телеметрию процесса. Без OTEL_EXPORTER_OTLP_ENDPOINT (или OTEL_SDK_DISABLED=true) —
только структурные логи в stdout, SDK не создаётся (так работают тесты внутри образа)."""
global _enabled
os.environ.setdefault("OTEL_SERVICE_NAME", service_name)
service = os.environ["OTEL_SERVICE_NAME"]
setup_logging(service)
if os.environ.get("OTEL_SDK_DISABLED", "").lower() == "true" or not os.environ.get("OTEL_EXPORTER_OTLP_ENDPOINT"):
log.info("Телеметрия выключена: OTLP endpoint не задан", extra={"event": "telemetry.disabled"})
return
from opentelemetry._logs import set_logger_provider
from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
from opentelemetry.exporter.otlp.proto.http.metric_exporter import OTLPMetricExporter
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.instrumentation.logging.handler import LoggingHandler
from opentelemetry.sdk._logs import LoggerProvider
from opentelemetry.sdk._logs.export import BatchLogRecordProcessor
from opentelemetry.sdk.metrics import MeterProvider
from opentelemetry.sdk.metrics.export import PeriodicExportingMetricReader
from opentelemetry.sdk.metrics.view import ExplicitBucketHistogramAggregation, View
from opentelemetry.sdk.resources import Resource
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor
# Resource.create сам читает OTEL_SERVICE_NAME и OTEL_RESOURCE_ATTRIBUTES (deployment.environment.name).
resource = Resource.create({"service.version": config.APP_VERSION,
"service.instance.id": config.INSTANCE_ID})
tracer_provider = TracerProvider(resource=resource, sampler=_sampler())
tracer_provider.add_span_processor(BatchSpanProcessor(
OTLPSpanExporter(), max_queue_size=MAX_QUEUE, max_export_batch_size=EXPORT_BATCH, schedule_delay_millis=2000))
trace.set_tracer_provider(tracer_provider)
views = [
View(instrument_name="messenger.job.duration",
aggregation=ExplicitBucketHistogramAggregation(JOB_DURATION_BUCKETS)),
View(instrument_name="messenger.attachment.time_to_ready",
aggregation=ExplicitBucketHistogramAggregation(TIME_TO_READY_BUCKETS)),
]
meter_provider = MeterProvider(resource=resource, views=views, metric_readers=[
PeriodicExportingMetricReader(OTLPMetricExporter(), export_interval_millis=METRIC_INTERVAL_MS)])
metrics.set_meter_provider(meter_provider)
logger_provider = LoggerProvider(resource=resource)
logger_provider.add_log_record_processor(BatchLogRecordProcessor(
OTLPLogExporter(), max_queue_size=MAX_QUEUE, max_export_batch_size=EXPORT_BATCH, schedule_delay_millis=2000))
set_logger_provider(logger_provider)
otlp_handler = LoggingHandler(level=logging.INFO, logger_provider=logger_provider)
otlp_handler.addFilter(_EventFilter())
otlp_handler.addFilter(_NotTelemetryItself())
logging.getLogger().addHandler(otlp_handler)
_providers[:] = [tracer_provider, meter_provider, logger_provider]
# Автоинструментация: SQL-запросы psycopg и запросы к S3 (botocore) как дочерние CLIENT-спаны.
# Параметры SQL не записываются (только текст запроса с плейсхолдерами %s).
from opentelemetry.instrumentation.botocore import BotocoreInstrumentor
from opentelemetry.instrumentation.psycopg import PsycopgInstrumentor
PsycopgInstrumentor().instrument(enable_commenter=False, skip_dep_check=True)
BotocoreInstrumentor().instrument()
# CPU и память процесса (process.cpu.time, process.memory.usage): нагрузка на контейнер.
from opentelemetry.instrumentation.system_metrics import SystemMetricsInstrumentor
SystemMetricsInstrumentor(config={
"process.cpu.time": ["user", "system"],
"process.cpu.utilization": None,
"process.memory.usage": None,
"process.thread.count": None,
}).instrument()
_enabled = True
log.info("Телеметрия включена: OTLP -> %s", os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"],
extra={"event": "telemetry.enabled"})
def instrument_fastapi(app) -> None:
if not _enabled:
return
from opentelemetry.instrumentation.fastapi import FastAPIInstrumentor
# /health/* не трассируется и не попадает в HTTP-метрики: это служебные запросы балансировщика,
# а не бизнес-запросы (знаменатель доли ошибок, см. REPORT.md).
# exclude_spans: без внутренних спанов «http receive/send» на каждый кусок тела.
FastAPIInstrumentor.instrument_app(app, excluded_urls="/health/", exclude_spans=["receive", "send"])
def shutdown() -> None:
"""Отправить накопленное при остановке (не дольше нескольких секунд на сигнал)."""
for provider in _providers:
try:
if hasattr(provider, "force_flush"):
provider.force_flush(3000)
provider.shutdown()
except Exception: # остановку процесса телеметрия не задерживает
pass
_providers.clear()
# ---------- контекст трассы через брокер ----------
def inject(message: dict) -> None:
"""Записать traceparent/tracestate активного span в сообщение (если span есть)."""
_PROPAGATOR.inject(message)
def extract(message: dict):
"""Контекст родителя из сообщения брокера (или пустой, если traceparent нет)."""
return _PROPAGATOR.extract({k: message[k] for k in ("traceparent", "tracestate") if k in message})
def current_trace_id() -> str | None:
ctx = trace.get_current_span().get_span_context()
return format(ctx.trace_id, "032x") if ctx.is_valid else None
@contextmanager
def span(name: str, kind: SpanKind = SpanKind.INTERNAL, context=None, attributes: dict | None = None):
"""Span с записью исключения и статусом ERROR при ошибке."""
with tracer.start_as_current_span(name, context=context, kind=kind, attributes=attributes,
record_exception=True, set_status_on_exception=True) as current:
yield current
def set_error(current, description: str) -> None:
current.set_status(Status(StatusCode.ERROR, description))
# ---------- метрики приложения ----------
# Инструменты создаются один раз. Без setup() глобальный провайдер — no-op: вызовы ничего не делают.
class _Instruments:
def __init__(self):
self.ready = False
def create(self):
if self.ready:
return self
m = metrics.get_meter("messenger")
# Worker: задания. Labels только job type и outcome (не attachment_id!).
self.jobs_processed = m.create_counter(
"messenger.jobs.processed", unit="{job}",
description="Доставки заданий, обработанные worker, по исходу")
self.job_duration = m.create_histogram(
"messenger.job.duration", unit="s",
description="Длительность одной попытки обработки задания worker")
self.time_to_ready = m.create_histogram(
"messenger.attachment.time_to_ready", unit="s",
description="От durable acceptance (COMMIT загрузки) до COMMIT ready")
# Relay outbox (API).
self.outbox_published = m.create_counter(
"messenger.outbox.published", unit="{message}",
description="Сообщения outbox, подтверждённые брокером (publisher confirm)")
self.ready = True
return self
instruments = _Instruments()
class Sampled:
"""Значения для observable-gauge, которые считает отдельный поток (например, SQL к БД).
Callback сбора метрик только читает готовое значение: если БД зависла, зависнет фоновый поток
сбора, но не экспорт ВСЕХ метрик процесса. Значение старше max_age не отдаётся (пропуск в графике
честнее, чем застывшая цифра).
"""
def __init__(self, max_age: float = 30.0):
self._values = None
self._at = 0.0
self._max_age = max_age
self._lock = threading.Lock()
def put(self, values) -> None:
with self._lock:
self._values, self._at = values, time.monotonic()
def get(self):
with self._lock:
if self._values is None or time.monotonic() - self._at > self._max_age:
return None
return self._values
def observe_pool(pool, pool_name: str) -> None:
"""DB pool: соединения used/idle, максимум и ожидающие запросы (semconv db.client.connection.*)."""
m = metrics.get_meter("messenger")
def stats():
try:
return pool.get_stats()
except Exception:
return None
def count(_options):
s = stats()
if s is None:
return []
size, available = s.get("pool_size", 0), s.get("pool_available", 0)
attrs = {"db.client.connection.pool.name": pool_name}
return [metrics.Observation(size - available, attrs | {"db.client.connection.state": "used"}),
metrics.Observation(available, attrs | {"db.client.connection.state": "idle"})]
def maximum(_options):
s = stats()
return [] if s is None else [metrics.Observation(s.get("pool_max", 0),
{"db.client.connection.pool.name": pool_name})]
def pending(_options):
s = stats()
return [] if s is None else [metrics.Observation(s.get("requests_waiting", 0),
{"db.client.connection.pool.name": pool_name})]
m.create_observable_up_down_counter("db.client.connection.count", [count], unit="{connection}",
description="Соединения пула по состоянию")
m.create_observable_up_down_counter("db.client.connection.max", [maximum], unit="{connection}",
description="Максимальный размер пула")
m.create_observable_up_down_counter("db.client.connection.pending_requests", [pending], unit="{request}",
description="Запросы, ждущие свободное соединение пула")
+121
View File
@@ -0,0 +1,121 @@
"""mTLS сервера API (с lab7): кто может подключаться к реплике и как это проверяется.
Три слоя, и каждый проверяет своё:
1. TLS (шифрование + сервер): реплика предъявляет сертификат identity api, балансировщик
проверяет его нашим CA и имя api (verifyhost в haproxy.cfg).
2. Цепочка клиента (OpenSSL, verify_mode=CERT_REQUIRED): без клиентского сертификата, с
сертификатом чужого CA или с истёкшим сертификатом рукопожатие не завершается.
3. Identity клиента (здесь, connection_made): сертификат нашего CA ещё не значит «это балансировщик».
Разрешены только SAN DNS из TLS_ALLOWED_CLIENTS (по умолчанию lb), а серийный номер не должен
быть в CRL (отозванный старый сертификат lb после ротации). Иначе соединение закрывается
до чтения первого байта HTTP — бизнес-API без правильной identity недоступен.
Разрешение на действие (какой пользователь что может) — уже не TLS, а Bearer-сессия в api.py.
CRL перечитывается раз в TLS_CRL_CHECK_SECONDS: отзыв действует для НОВЫХ соединений без рестарта.
Уже открытые keep-alive соединения живут до закрытия (HAProxy держит простаивающее соединение
не дольше 5 с — timeout http-keep-alive), поэтому эффект отзыва наступает через секунды.
"""
import logging
import ssl
import threading
import time
from pathlib import Path
from uvicorn.protocols.http.h11_impl import H11Protocol
from . import config
log = logging.getLogger("messenger.tls")
class Revocations:
"""Отозванные серийные номера из CRL, подписанного нашим CA (подпись проверяется)."""
def __init__(self, path: str, ca_path: str):
self.path, self.ca_path = Path(path), Path(ca_path)
self.serials: frozenset[int] = frozenset()
self._seen = None
self.load()
def load(self) -> None:
try:
stat = self.path.stat()
marker = (stat.st_mtime_ns, stat.st_size)
if marker == self._seen:
return
from cryptography import x509 # в образе есть (scripts/pki.py)
crl = x509.load_pem_x509_crl(self.path.read_bytes())
ca = x509.load_pem_x509_certificate(self.ca_path.read_bytes())
if not crl.is_signature_valid(ca.public_key()):
log.error("CRL %s подписан не нашим CA: игнорирую", self.path, extra={"event": "tls.crl_invalid"})
self._seen = marker
return
serials = frozenset(item.serial_number for item in crl)
if serials != self.serials:
log.warning("CRL обновлён: отозвано %d сертификатов", len(serials), extra={"event": "tls.crl_loaded"})
self.serials, self._seen = serials, marker
except FileNotFoundError:
return
except Exception: # noqa: BLE001 — битый CRL не должен ронять приём соединений
log.exception("Не удалось прочитать CRL %s: остаётся прежний список", self.path)
def watch(self) -> None:
def loop():
while True:
time.sleep(config.TLS_CRL_CHECK_SECONDS)
self.load()
threading.Thread(target=loop, name="crl-watch", daemon=True).start()
revocations: Revocations | None = None
def server_context() -> ssl.SSLContext:
"""Контекст TLS-сервера реплики: свой сертификат, ТОЛЬКО наш CA для клиентов, клиент обязателен."""
context = ssl.SSLContext(ssl.PROTOCOL_TLS_SERVER)
context.minimum_version = ssl.TLSVersion.TLSv1_2
context.load_cert_chain(config.TLS_CERT_FILE, config.TLS_KEY_FILE)
context.load_verify_locations(cafile=config.TLS_CA_FILE) # не системные CA: только CA стенда
context.verify_mode = ssl.CERT_REQUIRED
context.set_alpn_protocols(["http/1.1"])
return context
def client_identity(peercert: dict) -> tuple[list[str], str]:
"""SAN DNS и CN клиентского сертификата (из уже проверенной OpenSSL цепочки)."""
names = [value for kind, value in peercert.get("subjectAltName", ()) if kind == "DNS"]
common = next((value for rdn in peercert.get("subject", ()) for key, value in rdn if key == "commonName"), "")
return names, common
def allowed(peercert: dict | None) -> tuple[bool, str]:
if not peercert:
return False, "no client certificate"
names, common = client_identity(peercert)
if not any(name in config.TLS_ALLOWED_CLIENTS for name in names):
return False, f"identity {common or '?'} is not allowed"
serial = int(peercert.get("serialNumber", "0"), 16)
if revocations is not None and serial in revocations.serials:
return False, f"certificate of {common} is revoked"
return True, common
class IdentityCheckedH11Protocol(H11Protocol):
"""HTTP/1.1 uvicorn + проверка identity клиента сразу после TLS-рукопожатия."""
def connection_made(self, transport) -> None:
super().connection_made(transport)
ok, detail = allowed(transport.get_extra_info("peercert"))
if not ok:
peer = transport.get_extra_info("peername")
log.warning("mTLS: соединение отклонено (%s)", detail,
extra={"event": "tls.client_rejected", "tls.reason": detail,
"client.address": peer[0] if peer else ""})
transport.abort()
def setup() -> ssl.SSLContext:
global revocations
revocations = Revocations(config.TLS_CRL_FILE, config.TLS_CA_FILE)
revocations.watch()
return server_context()
+497
View File
@@ -0,0 +1,497 @@
"""Worker (с lab5): отдельный процесс, который обрабатывает вложения из очереди брокера.
Запуск: `python -m messenger.worker` (сервис worker в compose.yaml). HTTP-порта нет: worker
общается только с брокером (задания), PostgreSQL (состояние) и S3 (байты).
Обработка одного сообщения:
1. проверить формат по contracts/jobs.schema.json; неверное сообщение -> reject -> DLQ;
2. claim (jobs.py): по строке задания решить — обработать или это дубль/устаревшее
сообщение (тогда ack без работы);
3. скачать оригинал из staging и сверить размер и SHA-256 с метаданными в БД: доверяем
только БД, а не сообщению;
4. обработать в дочернем процессе с лимитами времени и памяти (sandbox.py, imaging.py);
5. записать оригинал в originals/<id> и варианты в variants/<id>/v1/... Ключи однозначно
заданы ключом эффекта, поэтому повтор пишет те же байты в те же ключи;
6. COMMIT результата с проверкой жетона lease (jobs.complete) — и только потом ack;
7. удалить staging: результат уже зафиксирован (не вышло — удалит уборщик).
Ошибки:
- постоянная (картинка не декодируется, слишком большая, исходник пропал) -> failed сразу,
reject -> сообщение в DLQ;
- временная (S3 недоступен, не уложились во время, дочерний процесс упал) -> следующая попытка
через backoff с jitter (новое сообщение из outbox), текущее — ack; попытки кончились -> failed;
- PostgreSQL недоступен -> результат не записать: сообщение возвращается в очередь после паузы.
Параллельность ограничена: WORKER_CONCURRENCY заданий одновременно, и prefetch брокера такой
же. Неподтверждённых сообщений у worker не больше, чем он может обрабатывать; остальные ждут
в очереди и достанутся другому worker, если его запустить.
Lease: пока задание обрабатывается, отдельный поток каждые JOB_HEARTBEAT_SECONDS продлевает
аренду. Если продлить не удалось (аренду уже забрали), обработка прерывается и результат
не записывается. Другой поток ищет задания, чью аренду никто не продлевает (worker упал или
завис), и возвращает их в очередь.
Наблюдаемость (с lab6, telemetry.py):
- каждая доставка — CONSUMER span «process attachments.process», родитель — traceparent из сообщения
(PRODUCER span relay). Внутри — jobs.claim, скачивание из S3, image.process (дочерний процесс),
запись в S3, jobs.complete / jobs.retry / jobs.fail; SQL и S3 — автоматические дочерние спаны.
Повтор пишет в outbox traceparent этого span, поэтому следующая попытка — в той же трассе;
- метрики: messenger.jobs.processed{messenger.job.type, outcome} (каждая доставка),
messenger.job.duration{messenger.job.type, outcome} (попытки, взятые в работу),
messenger.attachment.time_to_ready, messenger.worker.busy / capacity, пул соединений с БД;
- структурные логи с event (job.ready, job.retry, job.failed…), trace_id и span_id.
"""
import concurrent.futures
import hashlib
import logging
import os
import signal
import sys
import tempfile
import threading
import time
import uuid
from dataclasses import dataclass
from functools import partial
from opentelemetry import metrics
from opentelemetry.trace import SpanKind
from . import secretsource, broker, cleanup, config, db, faults, imaging, jobs, objects, sandbox, telemetry
from .errors import AppError, Unavailable
from .store import PostgresStore
log = logging.getLogger("messenger.worker")
ALIVE_FILE = "/tmp/worker.alive" # healthcheck контейнера: файл обновляется, пока жив главный цикл
SHUTDOWN_SECONDS = 20 # по SIGTERM столько ждём начатые задания (stop_grace_period 30 с)
DB_WAIT_SECONDS = 20 # столько ждём PostgreSQL перед возвратом сообщения в очередь
class Permanent(Exception):
"""Повтор не поможет: задание сразу получает failed."""
def __init__(self, code: str, message: str):
super().__init__(message)
self.code = code
class Transient(Exception):
"""Может пройти при повторе: следующая попытка через backoff."""
def __init__(self, code: str, message: str):
super().__init__(message)
self.code = code
class LeaseLost(Exception):
"""Аренду забрал другой worker: работу бросаем, результат не записываем."""
@dataclass
class InFlight:
lease: jobs.Lease
abort: threading.Event
started: float
def _sha256(path: str) -> str:
digest = hashlib.sha256()
with open(path, "rb") as f:
for block in iter(lambda: f.read(1024 * 1024), b""):
digest.update(block)
return digest.hexdigest()
class Worker:
def __init__(self):
# Уникален для каждого запуска процесса: hostname контейнера + случайный суффикс.
self.id = f"{config.INSTANCE_ID}/{uuid.uuid4().hex[:8]}"
self.pool = db.create_pool(application_name="messenger-worker",
max_size=config.WORKER_CONCURRENCY + 3)
self.jobs = jobs.JobStore(self.pool, "worker-" + self.id)
self.store = PostgresStore(self.pool)
self.stop = threading.Event() # SIGTERM: больше не берём новые сообщения
self.threads_stop = threading.Event() # после завершения начатых заданий: стоп фоновых потоков
self.executor = concurrent.futures.ThreadPoolExecutor(config.WORKER_CONCURRENCY, thread_name_prefix="job")
self.inflight: dict[str, InFlight] = {}
self.lock = threading.Lock()
self.busy = 0 # сколько доставок ещё не подтверждено (ack/nack)
self.params = imaging.Params(max_pixels=config.MAX_IMAGE_PIXELS, jpeg_quality=config.JPEG_QUALITY,
webp_quality=config.WEBP_QUALITY, webp_method=config.WEBP_METHOD)
# ---------- запуск и остановка ----------
def run(self) -> None:
signal.signal(signal.SIGTERM, self._on_signal)
signal.signal(signal.SIGINT, self._on_signal)
config.validate()
config.validate_s3()
config.validate_broker()
db.wait_for_schema()
self.pool.open()
self._observe()
sandbox.warm_up()
for target, name in ((self._keeper, "lease-keeper"), (self._reaper, "lease-reaper")):
threading.Thread(target=target, name=name, daemon=True).start()
log.info("Worker %s запущен: версия %s, параллельно %d, попыток %d, lease %d с (продление каждые %g с), "
"лимит попытки %d с и %d МиБ", self.id, config.APP_VERSION, config.WORKER_CONCURRENCY,
config.JOB_MAX_ATTEMPTS, config.JOB_LEASE_SECONDS, config.JOB_HEARTBEAT_SECONDS,
config.JOB_TIMEOUT_SECONDS, config.WORKER_MEMORY_LIMIT_MB, extra={"event": "worker.started"})
try:
self._consume_loop()
finally:
self.threads_stop.set()
self.executor.shutdown(wait=False, cancel_futures=True)
self.pool.close()
log.info("Worker %s остановлен", self.id, extra={"event": "worker.stopped"})
def _on_signal(self, signum, _frame):
if self.stop.is_set():
os._exit(1) # второй сигнал: выйти сразу
log.info("Сигнал %s: новые задания не беру, дожидаюсь начатых (до %d с)", signum, SHUTDOWN_SECONDS)
self.stop.set()
def _observe(self) -> None:
"""Метрики насыщения worker: занято / всего слотов, и пул соединений с БД."""
telemetry.observe_pool(self.pool, "messenger-worker")
m = metrics.get_meter("messenger")
m.create_observable_gauge("messenger.worker.busy", [lambda _o: [metrics.Observation(self._busy())]],
unit="{job}", description="Доставки в работе (ещё без ack/nack)")
m.create_observable_gauge("messenger.worker.capacity",
[lambda _o: [metrics.Observation(config.WORKER_CONCURRENCY)]],
unit="{job}", description="Сколько заданий worker обрабатывает одновременно")
def _touch(self) -> None:
try:
with open(ALIVE_FILE, "a", encoding="ascii"):
pass
os.utime(ALIVE_FILE, None)
except OSError:
pass
def _busy(self) -> int:
with self.lock:
return self.busy
def _consume_loop(self) -> None:
pause = 1.0
while not self.stop.is_set():
self._touch()
connection = None
try:
connection = broker.connect("worker")
channel = connection.channel()
broker.declare(channel, "worker")
# prefetch = сколько неподтверждённых сообщений брокер выдаёт этому worker.
channel.basic_qos(prefetch_count=config.WORKER_CONCURRENCY)
tag = channel.basic_consume(broker.QUEUE, partial(self._on_message, connection), auto_ack=False)
log.info("Подписан на очередь %s, prefetch=%d", broker.QUEUE, config.WORKER_CONCURRENCY)
pause = 1.0
while not self.stop.is_set():
connection.process_data_events(time_limit=1)
self._touch()
channel.basic_cancel(tag) # новые доставки прекращаются
deadline = time.monotonic() + SHUTDOWN_SECONDS
while self._busy() and time.monotonic() < deadline:
connection.process_data_events(time_limit=0.5) # тут уходят ack начатых заданий
connection.process_data_events(time_limit=0) # ack, поставленные последними
connection.close()
except broker.BrokerError as exc:
log.warning("Брокер недоступен (%s), повтор через %g с", type(exc).__name__, pause,
extra={"event": "worker.broker_unavailable"})
try:
if connection is not None and connection.is_open:
connection.close()
except broker.BrokerError:
pass
self._touch()
self.stop.wait(pause)
pause = min(pause * 2, 10.0)
# ---------- доставка сообщения ----------
def _on_message(self, connection, channel, method, _properties, body) -> None:
with self.lock:
self.busy += 1
self.executor.submit(self._handle, connection, channel, method.delivery_tag, body)
def _settle(self, connection, channel, tag, action: str) -> None:
"""ack / reject / requeue выполняются в потоке соединения (так требует pika)."""
def callback():
if not channel.is_open: # канал закрылся: брокер сам вернёт сообщение в очередь
return
if action == "ack":
channel.basic_ack(tag)
elif action == "reject":
channel.basic_reject(tag, requeue=False) # -> DLQ
else:
channel.basic_nack(tag, requeue=True)
try:
connection.add_callback_threadsafe(callback)
except Exception: # соединение уже закрыто — та же логика, что выше
pass
finally:
with self.lock:
self.busy -= 1
def _handle(self, connection, channel, tag, body) -> None:
action = "requeue"
try:
action = self._process(body)
except Exception:
log.exception("Неожиданная ошибка обработки сообщения: вернётся в очередь",
extra={"event": "job.unexpected_error"})
time.sleep(2)
finally:
self._settle(connection, channel, tag, action)
def _claim(self, message: dict):
deadline = time.monotonic() + DB_WAIT_SECONDS
while True:
try:
return self.jobs.claim(message, self.id)
except Unavailable:
if time.monotonic() > deadline or self.stop.is_set():
return None
time.sleep(2)
def _count(self, outcome: str, started: float | None = None) -> None:
tools = telemetry.instruments.create()
attrs = {"messenger.job.type": telemetry.JOB_TYPE, "outcome": outcome}
tools.jobs_processed.add(1, attrs)
if started is not None:
tools.job_duration.record(time.monotonic() - started, attrs)
def _process(self, body: bytes) -> str:
base = {"messaging.system": "rabbitmq", "messaging.operation.type": "process",
"messaging.destination.name": broker.QUEUE, "messenger.job.type": telemetry.JOB_TYPE}
try:
message = broker.parse(body)
except broker.InvalidMessage as exc:
with telemetry.span(f"process {broker.QUEUE}", SpanKind.CONSUMER, attributes=base) as span:
telemetry.set_error(span, "invalid_message")
span.set_attribute("messenger.job.outcome", "invalid")
log.error("Сообщение не по схеме jobs.schema.json (%s): reject -> DLQ", exc,
extra={"event": "job.invalid_message"})
self._count("invalid")
return "reject"
attrs = base | {"messaging.message.id": f"{message['job_id']}:{message['attempt']}",
"messenger.job.id": message["job_id"], "messenger.job.attempt": message["attempt"],
"messenger.attachment.id": message["attachment_id"]}
with telemetry.span(f"process {broker.QUEUE}", SpanKind.CONSUMER, telemetry.extract(message), attrs) as span:
action, outcome, started = self._process_message(message)
span.set_attribute("messenger.job.outcome", outcome)
if outcome in ("failed", "retry", "db_unavailable"):
telemetry.set_error(span, outcome)
self._count(outcome, started)
return action
def _process_message(self, message: dict) -> tuple[str, str, float | None]:
"""Возвращает (действие с сообщением, исход для метрик, начало работы или None)."""
with telemetry.span("jobs.claim"):
decision = self._claim(message)
if decision is None:
log.warning("PostgreSQL недоступен: задание %s вернётся в очередь", message["job_id"],
extra={"event": "job.requeue", "job_id": message["job_id"]})
return "requeue", "db_unavailable", None
if decision.kind != "claimed":
log.info("Задание %s попытка %d: %s %s — ack без обработки", message["job_id"], message["attempt"],
decision.kind, decision.detail,
extra={"event": "job.skipped", "job_id": message["job_id"], "decision": decision.kind})
return "ack", "skipped", None
lease = decision.lease
item = InFlight(lease, threading.Event(), time.monotonic())
with self.lock:
self.inflight[lease.token] = item
try:
action, outcome = self._run_job(item)
return action, outcome, item.started
finally:
with self.lock:
self.inflight.pop(lease.token, None)
def _run_job(self, item: InFlight) -> tuple[str, str]:
lease = item.lease
ids = {"job_id": lease.job_id, "attachment_id": lease.attachment_id, "attempt": lease.attempt}
try:
try:
variants = self._produce(lease, item.abort)
faults.pause("worker_pause_after_objects") # проверка уборщика: объекты есть, COMMIT ещё нет
faults.hit("worker_after_objects") # объекты в S3 есть, COMMIT и ack — нет
with telemetry.span("jobs.complete"):
waited = self.jobs.complete(lease, variants)
if waited is None:
log.warning("Задание %s: lease потерян до COMMIT — результат не записан", lease.job_id,
extra={"event": "job.lease_lost"} | ids)
return "ack", "lost"
telemetry.instruments.create().time_to_ready.record(waited, {"messenger.job.type": telemetry.JOB_TYPE})
faults.hit("worker_after_commit") # результат закоммичен, ack — нет
self._drop_staging(lease)
log.info("Вложение %s готово: попытка %d за %.2f с", lease.attachment_id, lease.attempt,
time.monotonic() - item.started,
extra={"event": "job.ready", "time_to_ready_s": round(waited, 3)} | ids)
return "ack", "ready"
except Permanent as exc:
log.warning("Вложение %s: постоянная ошибка %s (%s) -> failed", lease.attachment_id, exc.code, exc,
extra={"event": "job.failed", "error_code": exc.code} | ids)
with telemetry.span("jobs.fail", attributes={"messenger.job.error_code": exc.code}):
recorded = self.jobs.fail(lease, exc.code, str(exc))
return ("reject", "failed") if recorded else ("ack", "lost")
except Transient as exc:
with telemetry.span("jobs.retry", attributes={"messenger.job.error_code": exc.code}):
outcome = self.jobs.retry(lease, exc.code, str(exc))
log.warning("Вложение %s: временная ошибка %s (%s), попытка %d -> %s", lease.attachment_id,
exc.code, exc, lease.attempt, outcome,
extra={"event": "job.failed" if outcome == "failed" else "job.retry",
"error_code": exc.code} | ids)
if outcome == "failed":
return "reject", "failed"
return "ack", "retry" if outcome == "retry" else "lost"
except LeaseLost:
log.warning("Задание %s: lease забрал другой worker — работа брошена", lease.job_id,
extra={"event": "job.lease_lost"} | ids)
return "ack", "lost"
except Unavailable:
# PostgreSQL недоступен: исход не записан. Сообщение вернётся; lease истечёт сам.
log.warning("Задание %s: PostgreSQL недоступен, исход не записан — сообщение вернётся в очередь",
lease.job_id, extra={"event": "job.requeue"} | ids)
time.sleep(2)
return "requeue", "db_unavailable"
# ---------- сама работа ----------
def _fetch_source(self, lease: jobs.Lease, path: str) -> None:
for key in (lease.staging_key, lease.storage_key):
if not key:
continue
try:
objects.download(key, path, config.MAX_UPLOAD_BYTES)
return
except objects.MissingObject:
continue
except Unavailable:
raise Transient("storage_unavailable", "S3 недоступен при чтении оригинала") from None
raise Permanent("source_missing", "оригинала нет ни в staging, ни в originals")
def _produce(self, lease: jobs.Lease, abort: threading.Event) -> list[dict]:
with tempfile.TemporaryDirectory(prefix="job-") as tmp:
source = os.path.join(tmp, "source")
self._fetch_source(lease, source)
# Метаданные в БД — доверенный источник: объект должен совпасть с ними байт в байт.
if os.path.getsize(source) != lease.size_bytes or _sha256(source) != lease.sha256:
raise Permanent("source_corrupted", "оригинал в S3 не совпадает с размером или SHA-256 из БД")
if lease.width * lease.height > config.MAX_IMAGE_PIXELS:
raise Permanent("image_too_large", "больше лимита пикселей")
with open(source, "rb") as f:
if imaging.sniff_bytes(f.read(16)) != lease.content_type:
raise Permanent("invalid_image", "тип содержимого не совпадает с метаданными")
if faults.consume("worker_transient"):
raise Transient("storage_unavailable", "внедрённый временный сбой (faults: worker_transient)")
try:
with telemetry.span("image.process", attributes={"messenger.image.content_type": lease.content_type,
"messenger.image.pixels": lease.width * lease.height}):
result = sandbox.run(source, os.path.join(tmp, "out"), lease.content_type, self.params,
timeout=config.JOB_TIMEOUT_SECONDS,
memory_limit_mb=config.WORKER_MEMORY_LIMIT_MB,
slow_seconds=faults.number("worker_slow"), abort=abort)
except imaging.ImageError as exc:
raise Permanent(exc.code, str(exc)) from None
except (sandbox.ProcessingTimeout, sandbox.ChildCrashed) as exc:
if abort.is_set():
raise LeaseLost() from None
raise Transient(exc.code, str(exc)) from None
except RuntimeError as exc:
raise Transient("processing_failed", str(exc)) from None
if abort.is_set():
raise LeaseLost()
try:
objects.put_file(lease.storage_key, source, lease.content_type, lease.sha256)
variants = []
for v in result["variants"]:
extension = ".jpg" if v["content_type"] == "image/jpeg" else ".webp"
key = objects.variant_key(lease.attachment_id, lease.pipeline_version, v["name"], extension)
objects.put_file(key, v["path"], v["content_type"], v["sha256"])
variants.append({k: v[k] for k in ("name", "content_type", "size_bytes", "width", "height",
"sha256")} | {"storage_key": key})
except Unavailable:
raise Transient("storage_unavailable", "S3 недоступен при записи результата") from None
return variants
def _drop_staging(self, lease: jobs.Lease) -> None:
if not lease.staging_key:
return
try:
objects.delete(lease.staging_key)
except Unavailable:
log.warning("Staging %s не удалён сейчас — его удалит уборщик", lease.attachment_id,
extra={"event": "staging.delete_deferred"})
# ---------- фоновые потоки ----------
def _keeper(self) -> None:
"""Продление lease начатых заданий. Не продлили — задание у нас забрали: прерываем работу."""
while not self.threads_stop.wait(config.JOB_HEARTBEAT_SECONDS):
with self.lock:
items = list(self.inflight.values())
if not items:
continue
# Задание дольше лимита попытки уже не продлеваем: его дочерний процесс должен был быть убит.
alive = [it for it in items if time.monotonic() - it.started < config.JOB_TIMEOUT_SECONDS + 30]
try:
renewed = self.jobs.renew([it.lease.token for it in alive])
except Unavailable:
continue
for it in items:
if it.lease.token not in renewed and not it.abort.is_set():
log.warning("Lease задания %s не продлён (его забрали): прерываю обработку", it.lease.job_id,
extra={"event": "job.lease_not_renewed"})
it.abort.set()
def _reaper(self) -> None:
"""Истёкшие lease -> следующая попытка; страховка от потерянных сообщений; уборка S3."""
last_cleanup = time.monotonic()
problem = None
while not self.threads_stop.wait(config.REAPER_INTERVAL_SECONDS):
try:
for attachment_id, outcome in self.jobs.reap():
log.warning("Вложение %s: lease истёк -> %s", attachment_id, outcome,
extra={"event": "job.lease_expired", "attachment_id": attachment_id})
republished = self.jobs.republish_stale(config.QUEUED_REPUBLISH_SECONDS)
if republished:
log.warning("Повторно отправлено заданий без движения: %d", republished)
problem = None
except AppError as exc:
if problem != exc.message:
log.warning("Проверка lease пропущена: %s", exc.message)
problem = exc.message
except Exception:
log.exception("Проверка lease: неожиданная ошибка")
if time.monotonic() - last_cleanup >= config.CLEANUP_INTERVAL_SECONDS:
last_cleanup = time.monotonic()
try:
summary = cleanup.run_once(self.store, config.ATTACHMENT_GRACE_SECONDS,
config.STAGING_RETENTION_SECONDS)
if summary["deleted"]:
log.info("Уборка S3: %s", summary)
except AppError as exc:
log.warning("Уборка S3 пропущена: %s", exc.message)
except Exception:
log.exception("Уборка S3: неожиданная ошибка")
def main() -> int:
telemetry.setup("messenger-worker")
# С lab7: секреты worker (своя роль БД, свои ключи S3 с правами на свои префиксы) — из OpenBao
# по сертификату identity worker; ротация пароля БД -> пул пересоздаётся.
secretsource.load()
secretsource.on_change(db.drain_pools)
try:
Worker().run()
finally:
telemetry.shutdown()
return 0
if __name__ == "__main__":
sys.exit(main())
+394
View File
@@ -0,0 +1,394 @@
"""lab7: права каждой identity — «что тебе можно» (contracts/trust-matrix.md, пункты 4–5).
make acl-matrix (контейнер sectest в сетях стенда: docker compose --profile tools run --rm sectest ...)
tls_matrix.py проверяет «кто ты» (транспорт). Здесь identity уже прошла TLS, и проверяется принцип
наименьших привилегий: каждое разрешённое действие работает, а соседнее запрещённое — нет.
1. OpenBao (infra/openbao/policies/*.hcl, роли cert auth из scripts/bao.py):
api/worker читают ТОЛЬКО свой путь KV; чужой путь, запись, list, политики, mounts, auth — 403;
сертификат worker не входит в роль messenger-api (и наоборот), lb/intruder — ни в одну;
в секрете worker нет пароля Valkey и ключей API — admin-credentials worker не получает.
2. PostgreSQL (migrations/007_roles.sql): messenger_api — бизнес-таблицы без DELETE/DDL/TRUNCATE;
messenger_worker не видит users (hash паролей), sessions, chats, messages; DDL/TRUNCATE запрещены;
пароль одной роли не подходит к другой роли и к владельцу схемы.
3. S3 (scripts/init-secrets.sh, s3_config.json): права по префиксам staging/ originals/ variants/;
управление bucket'ами запрещено обоим.
4. RabbitMQ (infra/rabbitmq/definitions.json): api только публикует в exchange attachments,
worker только читает очередь attachments.process; объявлять очереди/exchange не может никто.
5. Valkey (ACL в scripts/init-secrets.sh): пользователь messenger — только ключи sess:* rl:* и
нужные команды; default выключен; health — только ping/info/dbsize.
Каждое действие выполняется по-настоящему, но без вреда: SQL — в транзакции с ROLLBACK, тестовые
объекты S3 и ключи Valkey удаляются, сообщения в брокер уходят с routing key без привязки (теряются).
Секреты для входа берутся из OpenBao так же, как их берёт сервис: сертификатом своей identity.
"""
import socket
import ssl
import sys
import uuid
import boto3
import pika
import psycopg
import valkey
from botocore.config import Config
from botocore.exceptions import BotoCoreError, ClientError
from matrix import CA, Matrix, bao_call, bao_login, bao_secret, cert, client_context, short
BUCKET = "messenger-attachments"
RUN = uuid.uuid4().hex[:12] # уникальные имена тестовых объектов и ключей этого запуска
# ---------- 1. OpenBao ----------
def bao_part(m: Matrix):
m.section("OpenBao: cert auth roles and KV policies")
tokens = {}
for identity in ("api", "worker"):
status, payload = bao_login(identity, f"messenger-{identity}")
policies = sorted(payload.get("auth", {}).get("token_policies", [])) if status == 200 else []
m.allow(identity, f"login role messenger-{identity}", (status == 200, f"HTTP {status} policies={policies}"))
m.row(identity, "token has no root/admin policy", "own", ",".join(policies) or "-",
status == 200 and "root" not in policies and f"messenger-{identity}" in policies)
if status == 200:
tokens[identity] = payload["auth"]["client_token"]
# Чужая роль и посторонние identity нашего CA: вход отклоняется (CN не в allowed_common_names).
for identity, role in (("worker", "messenger-api"), ("api", "messenger-worker"), ("lb", "messenger-api"),
("intruder", "messenger-api"), ("intruder", "messenger-worker")):
status, _ = bao_login(identity, role)
m.deny(identity, f"login role {role}", (status == 200, f"HTTP {status}"))
for identity, token in tokens.items():
other = "worker" if identity == "api" else "api"
checks = [
("allow", "GET", f"secret/data/messenger/{identity}", None, "read own KV path"),
("deny", "GET", f"secret/data/messenger/{other}", None, f"read {other} KV path"),
("deny", "POST", f"secret/data/messenger/{identity}", {"data": {"x": "y"}}, "write own KV path"),
("deny", "LIST", "secret/metadata/messenger", None, "list KV paths"),
("deny", "GET", f"secret/metadata/messenger/{identity}", None, "read KV metadata/versions"),
("deny", "PUT", f"sys/policies/acl/messenger-{identity}", {"policy": 'path "*" {capabilities=["sudo"]}'},
"rewrite own policy"),
("deny", "GET", "sys/policies/acl/messenger-api", None, "read policies"),
("deny", "GET", "sys/mounts", None, "list secret engines"),
("deny", "LIST", "auth/cert/certs", None, "list cert auth roles"),
("deny", "POST", "auth/token/create", {"policies": ["messenger-api", "messenger-worker"]},
"create token with more policies"),
]
for expect, method, path, body, what in checks:
status, _ = bao_call(method, path, token=token, body=body)
outcome = (status in (200, 204), f"HTTP {status}")
(m.allow if expect == "allow" else m.deny)(identity, what, outcome)
# Содержимое секрета worker: только его собственные учётные данные (ключи — без значений).
if "worker" in tokens:
status, payload = bao_call("GET", "secret/data/messenger/worker", token=tokens["worker"])
keys = sorted(payload.get("data", {}).get("data", {})) if status == 200 else []
m.row("worker", "secret has no Valkey/admin credentials", "none", ",".join(keys) or "-",
status == 200 and "cache_password" not in keys and not any("admin" in k or "root" in k for k in keys))
# ---------- 2. PostgreSQL ----------
def pg_connect(user: str, password: str):
return psycopg.connect(host="postgres", port=5432, dbname="messenger", user=user, password=password,
sslmode="verify-full", sslrootcert=CA, connect_timeout=5,
application_name="acl-matrix")
def sql_outcome(conn, statement: str) -> tuple[bool, str]:
"""Выполнить и откатить. (True, ...) — сервер позволил; (False, причина) — отказал."""
try:
conn.execute(statement)
return True, "executed (rolled back)"
except psycopg.errors.InsufficientPrivilege:
return False, "permission denied"
except psycopg.Error as exc:
return False, short(exc)
finally:
conn.rollback()
def pg_part(m: Matrix, secrets: dict):
m.section("PostgreSQL: roles messenger_api / messenger_worker")
api_sql = [
("allow", "SELECT id, password_hash FROM users LIMIT 1", "SELECT users"),
("allow", "SELECT * FROM messages LIMIT 1", "SELECT messages"),
("allow", "SELECT * FROM sessions LIMIT 1", "SELECT sessions"),
("allow", "UPDATE chats SET title = title WHERE false", "UPDATE chats"),
("allow", "DELETE FROM outbox WHERE false", "DELETE outbox"),
("deny", "DELETE FROM users WHERE false", "DELETE users"),
("deny", "DELETE FROM messages WHERE false", "DELETE messages"),
("deny", "DELETE FROM schema_migrations WHERE false", "DELETE schema_migrations"),
("deny", "TRUNCATE outbox", "TRUNCATE outbox"),
("deny", f"CREATE TABLE acl_{RUN} (id int)", "CREATE TABLE"),
("deny", "ALTER TABLE users ADD COLUMN acl_test int", "ALTER TABLE users"),
("deny", "DROP TABLE job_events", "DROP TABLE"),
("deny", "CREATE ROLE acl_intruder", "CREATE ROLE"),
]
worker_sql = [
("allow", "SELECT * FROM attachments LIMIT 1", "SELECT attachments"),
("allow", "SELECT * FROM attachment_jobs LIMIT 1", "SELECT attachment_jobs"),
("allow", "UPDATE attachments SET status = status WHERE false", "UPDATE attachments"),
("allow", "DELETE FROM outbox WHERE false", "DELETE outbox"),
("deny", "SELECT id, password_hash FROM users LIMIT 1", "SELECT users (password hashes)"),
("deny", "SELECT * FROM sessions LIMIT 1", "SELECT sessions"),
("deny", "SELECT * FROM chats LIMIT 1", "SELECT chats"),
("deny", "SELECT * FROM chat_members LIMIT 1", "SELECT chat_members"),
("deny", "SELECT * FROM messages LIMIT 1", "SELECT messages"),
("deny", "SELECT * FROM message_attachments LIMIT 1", "SELECT message_attachments"),
("deny", "DELETE FROM attachments WHERE false", "DELETE attachments"),
("deny", "TRUNCATE attachment_jobs", "TRUNCATE attachment_jobs"),
("deny", f"CREATE TABLE acl_{RUN} (id int)", "CREATE TABLE"),
("deny", "ALTER TABLE attachments ADD COLUMN acl_test int", "ALTER TABLE attachments"),
]
for identity, role, statements in (("api", "messenger_api", api_sql), ("worker", "messenger_worker", worker_sql)):
password = secrets[identity]["db_password"]
try:
conn = pg_connect(role, password)
except psycopg.Error as exc:
m.allow(identity, f"connect as {role} (TLS verify-full)", (False, short(exc)))
continue
m.allow(identity, f"connect as {role} (TLS verify-full)", (True, "connected"))
with conn:
for expect, statement, what in statements:
(m.allow if expect == "allow" else m.deny)(identity, what, sql_outcome(conn, statement))
# Пароль одной роли не открывает другую роль и владельца схемы.
for identity, role in (("api", "messenger_worker"), ("worker", "messenger_api"),
("api", "messenger"), ("worker", "messenger"), ("worker", "postgres")):
try:
pg_connect(role, secrets[identity]["db_password"]).close()
outcome = (True, "connected")
except psycopg.OperationalError as exc:
text = str(exc)
outcome = (False, "authentication failed" if "authentication" in text
else "rejected by pg_hba.conf" if "pg_hba" in text else short(exc))
m.deny(identity, f"{identity} password as role {role}", outcome)
# ---------- 3. S3 ----------
def s3_client(secret: dict):
return boto3.session.Session().client(
"s3", endpoint_url="https://s3:9000", region_name="us-east-1", verify=CA,
aws_access_key_id=secret["s3_access_key_id"], aws_secret_access_key=secret["s3_secret_access_key"],
config=Config(s3={"addressing_style": "path"}, retries={"max_attempts": 1},
connect_timeout=5, read_timeout=10,
request_checksum_calculation="when_required", response_checksum_validation="when_required"))
def s3_outcome(call) -> tuple[bool, str]:
try:
call()
return True, "allowed"
except ClientError as exc:
return False, exc.response.get("Error", {}).get("Code", "ClientError")
except BotoCoreError as exc:
return False, short(exc)
def other_buckets(client) -> tuple[bool, str]:
"""SeaweedFS отдаёт в ListBuckets только bucket'ы, на которые есть права: чужих быть не должно."""
try:
names = sorted(b["Name"] for b in client.list_buckets().get("Buckets", []))
except ClientError as exc:
return False, exc.response.get("Error", {}).get("Code", "ClientError")
others = [name for name in names if name != BUCKET]
return bool(others), f"sees {names}"
def s3_part(m: Matrix, secrets: dict):
m.section(f"S3: prefixes in bucket {BUCKET}")
api, worker = s3_client(secrets["api"]), s3_client(secrets["worker"])
staging, original, variant = (f"staging/acl-{RUN}", f"originals/acl-{RUN}", f"variants/acl-{RUN}/v1/thumb")
body = b"acl-matrix test object"
def put(client, key):
return lambda: client.put_object(Bucket=BUCKET, Key=key, Body=body)
def get(client, key):
return lambda: client.get_object(Bucket=BUCKET, Key=key)["Body"].read()
try:
# api: пишет только staging/, читает только originals/ и variants/.
m.allow("api", "PUT staging/<id>", s3_outcome(put(api, staging)))
m.deny("api", "GET staging/<id> (unchecked upload)", s3_outcome(get(api, staging)))
m.deny("api", "PUT originals/<id> (forge original)", s3_outcome(put(api, original)))
m.deny("api", "PUT variants/<id>/... (forge variant)", s3_outcome(put(api, variant)))
m.deny("api", "LIST bucket", s3_outcome(lambda: api.list_objects_v2(Bucket=BUCKET, MaxKeys=1)))
# worker: читает staging/ и originals/, пишет в bucket, видит список.
m.allow("worker", "GET staging/<id>", s3_outcome(get(worker, staging)))
m.allow("worker", "PUT originals/<id>", s3_outcome(put(worker, original)))
m.allow("worker", "PUT variants/<id>/...", s3_outcome(put(worker, variant)))
m.allow("worker", "LIST bucket", s3_outcome(lambda: worker.list_objects_v2(Bucket=BUCKET, MaxKeys=1)))
m.deny("worker", "GET variants/<id>/... (not its job)", s3_outcome(get(worker, variant)))
# api отдаёт пользователю только проверенное.
m.allow("api", "GET originals/<id>", s3_outcome(get(api, original)))
m.allow("api", "GET variants/<id>/...", s3_outcome(get(api, variant)))
m.deny("api", "DELETE originals/<id>", s3_outcome(lambda: api.delete_object(Bucket=BUCKET, Key=original)))
# Управление bucket'ами — только у s3-init (admin), у приложений нет.
forbidden = f"acl-matrix-{RUN}"
for identity, client in (("api", api), ("worker", worker)):
m.deny(identity, "CREATE bucket", s3_outcome(lambda c=client: c.create_bucket(Bucket=forbidden)))
m.deny(identity, "DELETE other bucket", s3_outcome(lambda c=client: c.delete_bucket(Bucket=forbidden)))
for identity, client in (("api", api), ("worker", worker)):
m.deny(identity, "see other buckets (ListBuckets)", other_buckets(client))
finally:
for key in (staging, original, variant): # уборка тестовых объектов (worker может удалять)
try:
worker.delete_object(Bucket=BUCKET, Key=key)
except (ClientError, BotoCoreError):
pass
# ---------- 4. RabbitMQ ----------
def broker_connect(identity: str) -> pika.BlockingConnection:
context = client_context(identity)
return pika.BlockingConnection(pika.ConnectionParameters(
host="broker", port=5671, virtual_host="messenger", credentials=pika.credentials.ExternalCredentials(),
ssl_options=pika.SSLOptions(context, server_hostname="broker"),
connection_attempts=1, socket_timeout=5, blocked_connection_timeout=5))
def amqp_outcome(conn: pika.BlockingConnection, action) -> tuple[bool, str]:
"""Каждое действие — в своём канале: отказ брокера закрывает канал (403 ACCESS_REFUSED), не соединение."""
channel = conn.channel()
try:
detail = action(channel)
return True, detail if isinstance(detail, str) else "allowed"
except pika.exceptions.ChannelClosedByBroker as exc:
return False, f"{exc.reply_code} {exc.reply_text.split(' - ')[0]}"
except pika.exceptions.AMQPError as exc:
return False, short(exc)
finally:
if channel.is_open:
channel.close()
def publish(exchange: str):
def action(channel):
channel.confirm_delivery()
# routing key без привязки: сообщение принято брокером и отброшено, worker его не получит.
channel.basic_publish(exchange=exchange, routing_key=f"acl-matrix.noop.{RUN}", body=b"{}")
return "published (unroutable, dropped)"
return action
def read(queue: str):
def action(channel):
method, _, _ = channel.basic_get(queue=queue, auto_ack=False)
if method is not None: # настоящее задание — вернуть в очередь, не трогая
channel.basic_nack(method.delivery_tag, requeue=True)
return "read allowed (message requeued)"
return "read allowed (queue empty)"
return action
def broker_part(m: Matrix):
m.section("RabbitMQ: users = certificate CN (SASL EXTERNAL), vhost messenger")
rules = {
"api": [("allow", "publish to exchange attachments", publish("attachments")),
("deny", "publish to exchange attachments.dlx", publish("attachments.dlx")),
("deny", "publish to default exchange", publish("")),
("deny", "read queue attachments.process", read("attachments.process")),
("deny", "read queue attachments.dead", read("attachments.dead"))],
"worker": [("allow", "read queue attachments.process", read("attachments.process")),
("deny", "read queue attachments.dead", read("attachments.dead")),
("deny", "publish to exchange attachments", publish("attachments")),
("deny", "publish to exchange attachments.dlx", publish("attachments.dlx"))],
}
for identity, checks in rules.items():
try:
conn = broker_connect(identity)
except (pika.exceptions.AMQPError, OSError) as exc:
m.allow(identity, "connect amqps://broker:5671/messenger", (False, short(exc)))
continue
try:
for expect, what, action in checks:
(m.allow if expect == "allow" else m.deny)(identity, what, amqp_outcome(conn, action))
m.deny(identity, "declare own queue", amqp_outcome(
conn, lambda ch: ch.queue_declare(queue=f"acl-matrix-{RUN}", exclusive=True)))
m.deny(identity, "declare exchange", amqp_outcome(
conn, lambda ch: ch.exchange_declare(exchange=f"acl-matrix-{RUN}", exchange_type="fanout")))
m.deny(identity, "delete queue attachments.process", amqp_outcome(
conn, lambda ch: ch.queue_delete(queue="attachments.process")))
finally:
conn.close()
# ---------- 5. Valkey ----------
def valkey_client(username: str | None, password: str | None):
return valkey.Valkey(host="valkey", port=6379, username=username, password=password, ssl=True,
ssl_ca_certs=CA, ssl_cert_reqs="required", ssl_check_hostname=True,
socket_timeout=5, socket_connect_timeout=5)
def valkey_outcome(call) -> tuple[bool, str]:
try:
call()
return True, "allowed"
except valkey.exceptions.ValkeyError as exc:
text = str(exc)
for code in ("NOPERM", "NOAUTH", "WRONGPASS"):
if code in text or code.lower() in type(exc).__name__.lower():
return False, code
return False, type(exc).__name__
def valkey_part(m: Matrix, secrets: dict):
m.section("Valkey: ACL users messenger / health / default")
api = valkey_client("messenger", secrets["api"]["cache_password"])
key = f"sess:acl-matrix-{RUN}"
try:
m.allow("api", "SET/GET sess:* (session cache)",
valkey_outcome(lambda: api.set(key, "1", ex=30) and api.get(key)))
m.allow("api", "INCRBY rl:* (rate limit counter)",
valkey_outcome(lambda: api.incrby(f"rl:acl-matrix-{RUN}", 1)))
m.deny("api", "SET key outside sess:*/rl:*", valkey_outcome(lambda: api.set(f"other:acl-{RUN}", "1")))
m.deny("api", "KEYS * (enumerate sessions)", valkey_outcome(lambda: api.keys("*")))
m.deny("api", "SCAN", valkey_outcome(lambda: api.scan(0)))
m.deny("api", "FLUSHALL", valkey_outcome(lambda: api.flushall()))
m.deny("api", "CONFIG GET *", valkey_outcome(lambda: api.config_get("*")))
m.deny("api", "ACL LIST", valkey_outcome(lambda: api.acl_list()))
m.deny("api", "EVAL (Lua)", valkey_outcome(lambda: api.eval("return 1", 0)))
m.deny("api", "PUBLISH", valkey_outcome(lambda: api.publish("acl", "1")))
finally:
try:
api.delete(key, f"rl:acl-matrix-{RUN}")
except valkey.exceptions.ValkeyError:
pass
health = valkey_client("health", "any") # nopass: любой пароль, но только ping/info/dbsize
m.allow("health", "PING", valkey_outcome(lambda: health.ping()))
m.deny("health", "GET sess:*", valkey_outcome(lambda: health.get(key)))
anonymous = valkey_client(None, None)
m.deny("anonymous", "PING without AUTH (default user off)", valkey_outcome(lambda: anonymous.ping()))
m.deny("anonymous", "GET sess:* without AUTH", valkey_outcome(lambda: anonymous.get(key)))
guess = valkey_client("default", secrets["api"]["cache_password"])
m.deny("anonymous", "AUTH default <api password>", valkey_outcome(lambda: guess.ping()))
m.deny("worker", "worker has no Valkey credentials", (
"cache_password" in secrets["worker"], "absent" if "cache_password" not in secrets["worker"] else "present"))
def main() -> int:
socket.setdefaulttimeout(10)
m = Matrix("ACL matrix (lab7): what each identity may do")
bao_part(m)
secrets = {identity: bao_secret(identity) for identity in ("api", "worker")}
pg_part(m, secrets)
s3_part(m, secrets)
broker_part(m)
valkey_part(m, secrets)
return m.finish()
if __name__ == "__main__":
try:
sys.exit(main())
except ssl.SSLError as exc:
sys.exit(f"TLS failure: {exc.reason}: check make pki / CA in /pki/tls/ca")
+34
View File
@@ -0,0 +1,34 @@
"""lab7: замер стоимости Argon2id для выбора параметров (README, уровень 3).
make argon2-bench (выполняется внутри контейнера api: те же CPU-лимит и библиотека, что у реплики)
Для каждого набора параметров — медиана и p95 времени одного hash (= одной проверки пароля при входе)
по 15 повторам, и сколько входов в секунду выдержит одно ядро. Пароли синтетические, не печатаются.
"""
import statistics
import time
from argon2 import PasswordHasher
CANDIDATES = [(19456, 2, 1), (19456, 3, 1), (47104, 1, 1), (65536, 2, 1)] # m (КиБ), t, p
REPEATS = 15
def main():
print(f"{'m, MiB':>7} {'t':>2} {'p':>2} {'median ms':>10} {'p95 ms':>8} {'logins/s per core':>18}")
for memory, time_cost, parallelism in CANDIDATES:
hasher = PasswordHasher(time_cost=time_cost, memory_cost=memory, parallelism=parallelism)
hasher.hash("warm up the allocator")
samples = []
for i in range(REPEATS):
started = time.perf_counter()
hasher.hash(f"synthetic password {i:04d}")
samples.append((time.perf_counter() - started) * 1000)
samples.sort()
median = statistics.median(samples)
p95 = samples[int(len(samples) * 0.95) - 1]
print(f"{memory / 1024:>7.0f} {time_cost:>2} {parallelism:>2} {median:>10.1f} {p95:>8.1f} {1000 / median:>18.1f}")
if __name__ == "__main__":
main()
+53
View File
@@ -0,0 +1,53 @@
"""lab4–lab5, уровень 3: upload -> СРАЗУ остановка обслужившей реплики -> ready и download через другую.
make attachment-failover (= python student-tests/attachment_failover.py)
С lab5 реплика останавливается сразу после ответа 202, ещё до обработки. Это доказывает две вещи:
- остановка API после ответа не теряет работу: оригинал уже в staging S3, задание — в PostgreSQL,
worker доводит вложение до ready без этой реплики;
- оригинал не лежит на диске реплики: другая реплика отдаёт тот же файл байт в байт (SHA-256).
В конце остановленная реплика запускается обратно (`docker start`).
"""
import hashlib
from filegen import upload_when_ready, wait_status, wait_until
from helpers import Client, check, run
from stand import alias_of, docker, lb_summary, lb_up_count, ps_table, wait_balanced
def main():
api = Client()
replicas = wait_balanced(2)
alice, bob, _eve, chat = api.bootstrap()
reply = upload_when_ready(api, alice, chat, name="failover.png")
attachment, served = reply["json"], reply["headers"]["X-Instance-Id"]
target = [c for c in replicas if alias_of(c) == served]
check(len(target) == 1, f"X-Instance-Id {served} does not match a running api container")
print(f"uploaded {attachment['size_bytes']} bytes -> 202 {attachment['status']}, "
f"sha256 {attachment['sha256'][:16]}..., served by api replica {served}")
print(ps_table())
docker("stop", target[0])
try:
wait_until(lambda: lb_up_count() == len(replicas) - 1, 30, "HAProxy did not remove the stopped replica")
print(f"stopped {served} (docker stop) right after 202; HAProxy: {lb_summary()}")
ready = wait_status(api, bob, attachment["id"], seconds=90)
print(f"the worker finished the job without that replica: status {ready['status']}, "
f"variants {[v['name'] for v in ready['variants']]}")
seen = set()
for _ in range(4):
got = api.call("GET", f"/api/v1/attachments/{attachment['id']}/content", actor=bob)
check(hashlib.sha256(got["bytes"]).hexdigest() == attachment["sha256"], "downloaded file differs")
seen.add(got["headers"]["X-Instance-Id"])
check(served not in seen, "the stopped replica still answered")
print(f"downloaded 4 times through {sorted(seen)}: same SHA-256 as uploaded")
finally:
docker("start", target[0])
wait_balanced(len(replicas))
print(f"restored {served}; HAProxy: {lb_summary()}")
print(ps_table())
print("PASS: the replica that accepted the upload was stopped right after 202; the job still became ready and "
"another replica returned the same bytes (the original lives in S3, not on the replica)")
if __name__ == "__main__":
run(main)
+51
View File
@@ -0,0 +1,51 @@
"""Отозванный токен не «воскресает» из кэша после возвращения Valkey (замечание к MR).
Запуск: make failure-valkey-pause
Сценарий преподавателя: Valkey ставится на паузу (docker compose pause) — процесс жив,
данные в его памяти сохраняются, но он не отвечает. В это время делается logout: PostgreSQL
отзывает сессию, а убрать запись из кэша нельзя. После unpause в кэше всё ещё лежит старая
запись «токен -> пользователь». Она не должна снова пропускать этот токен.
"""
import time
from helpers import Client, compose, run, wait_ready
def main():
api = Client()
alice, bob, _eve, chat = api.bootstrap()
dave = api.user("dave")
for _ in range(2): # запись о сессии dave точно лежит в кэше
api.call("GET", "/api/v1/users/me", actor=dave, schema="User")
print("pausing valkey (docker compose pause valkey): данные в кэше сохраняются")
compose("pause", "valkey")
try:
api.call("GET", "/api/v1/users/me", actor=dave, schema="User") # этот запрос обнаруживает сбой кэша
api.call("DELETE", "/api/v1/auth/sessions/current", 204, actor=dave)
api.call("GET", "/api/v1/users/me", 401, actor=dave)
print("во время паузы: logout -> 204, тот же токен -> 401")
finally:
print("unpausing valkey")
compose("unpause", "valkey")
wait_ready(api)
# Фоновая проверка возвращает кэш в работу в течение 5 с. Смотрим 12 с — дольше, чем она.
deadline = time.monotonic() + 12
checks = 0
while time.monotonic() < deadline:
api.call("GET", "/api/v1/users/me", 401, actor=dave)
api.call("POST", "/api/v1/chats", 401, actor=dave, body={"title": "x", "member_ids": [dave["id"]]})
checks += 1
time.sleep(0.5)
print(f"после unpause: {checks} проверок за 12 с, отозванный токен всегда 401 (и GET, и POST)")
api.call("GET", "/api/v1/users/me", actor=alice, schema="User")
api.message(bob, chat, "после возвращения Valkey")
print("действующие токены других пользователей работают")
print("PASS: revoked session stays revoked after Valkey comes back with stale data")
if __name__ == "__main__":
run(main)
+98
View File
@@ -0,0 +1,98 @@
"""lab6, уровни 3–4: dashboard и источники данных импортируются из Git, а запросы панелей работают.
make dashboard-check (= python student-tests/check_dashboard.py)
1. Grafana (https://127.0.0.1:3000): здорова; источники prometheus, loki, tempo созданы provisioning
(а не руками) и проходят проверку подключения; dashboard messenger-lab6 импортирован из
infra/grafana/dashboards/messenger.json (тот же набор панелей), помечен как provisioned.
2. Каждый запрос каждой панели из JSON выполняется в своём хранилище без ошибок: PromQL — в
Prometheus, LogQL — в Loki, TraceQL — в Tempo. Пустой результат разрешён только у панелей,
которые показывают отказы (например, потери Collector при здоровом стенде), — они перечислены.
3. Alert rules загружены в Prometheus (HighErrorRate, QueueLagHigh, TelemetryExportFailing) и здоровы.
Выводится таблица «панель — единица — запрос» для REPORT.md.
GRAFANA_URL=none — пропустить шаг 1 (например, если проверяются только запросы).
"""
import json
import os
import obs
from helpers import ROOT, check, run
DASHBOARD = ROOT / "infra" / "grafana" / "dashboards" / "messenger.json"
# Эти запросы при здоровом стенде законно пусты: отказов нет.
MAY_BE_EMPTY = ("send_failed", "ALERTS", "outcome=\"ready\"", "time_to_ready", "4..", "5..")
def panels(dashboard):
for panel in dashboard["panels"]:
if panel.get("type") == "row":
continue
yield panel
def grafana_checks(dashboard):
health = obs.get_json(obs.GRAFANA_URL + "/api/health")
check(health.get("database") == "ok", f"grafana health: {health}")
sources = {ds["uid"]: ds for ds in obs.grafana("/api/datasources")}
for uid, kind in (("prometheus", "prometheus"), ("loki", "loki"), ("tempo", "tempo")):
check(uid in sources and sources[uid]["type"] == kind, f"datasource {uid} is not provisioned")
check(sources[uid].get("readOnly") is True, f"datasource {uid} must come from provisioning (readOnly)")
if uid == "tempo":
# Плагин Tempo в Grafana 12 не реализует /health через API (404 plugin.notImplemented):
# проверяем подключение настоящим запросом к Tempo через прокси Grafana.
check(isinstance(obs.grafana("/api/datasources/proxy/uid/tempo/api/search?limit=1"), dict),
"tempo datasource: search through Grafana failed")
continue
result = obs.grafana(f"/api/datasources/uid/{uid}/health")
check(result.get("status") == "OK", f"datasource {uid} health: {result}")
print("1. Grafana " + health.get("version", "?") + ": datasources prometheus, loki, tempo — provisioned "
"(readOnly); prometheus, loki health OK; tempo answers a search through Grafana")
imported = obs.grafana("/api/dashboards/uid/" + dashboard["uid"])
check(imported["meta"].get("provisioned") is True, "dashboard must be provisioned from a file")
got = sorted(p["title"] for p in imported["dashboard"]["panels"])
want = sorted(p["title"] for p in dashboard["panels"])
check(got == want, "imported dashboard differs from infra/grafana/dashboards/messenger.json")
print(f" dashboard '{imported['dashboard']['title']}' provisioned from {imported['meta'].get('provisionedExternalId')}, "
f"{len(got)} panels (same as the JSON in Git)")
def main():
dashboard = json.loads(DASHBOARD.read_text(encoding="utf-8"))
if os.environ.get("GRAFANA_URL", "") != "none":
grafana_checks(dashboard)
else:
print("1. Grafana checks skipped (GRAFANA_URL=none)")
print("2. every panel query against its store:")
print(f" {'panel':<46} {'unit':<11} {'series':>6} query")
empty = []
for panel in panels(dashboard):
unit = panel.get("fieldConfig", {}).get("defaults", {}).get("unit", "-")
for target in panel["targets"]:
kind = target["datasource"]["uid"]
if kind == "prometheus":
rows = obs.prom(target["expr"])
query = target["expr"]
elif kind == "loki":
rows = obs.loki(target["expr"], minutes=60, limit=20)
query = target["expr"]
else:
rows = obs.tempo_search(target["query"], limit=5)
query = target["query"]
if not rows:
empty.append((panel["title"], query))
print(f" {panel['title'][:46]:<46} {unit:<11} {len(rows):>6} {' '.join(query.split())[:150]}")
unexpected = [(title, q) for title, q in empty if not any(m in q for m in MAY_BE_EMPTY)]
check(not unexpected, f"queries without data: {unexpected}")
print(f" all queries succeeded; empty (allowed: failure-only panels): {len(empty)}")
names = {r["name"]: r for r in obs.rules()}
for alert in ("HighErrorRate", "QueueLagHigh", "TelemetryExportFailing"):
check(alert in names and names[alert]["health"] == "ok", f"alert rule {alert} missing or unhealthy")
print("3. alert rules loaded and healthy: " + ", ".join(f"{n} ({names[n]['state']}, for {names[n].get('duration', 0)} s)"
for n in ("HighErrorRate", "QueueLagHigh", "TelemetryExportFailing")))
print("PASS: provisioning from Git, every panel query returns data from Prometheus/Loki/Tempo, alert rules loaded")
if __name__ == "__main__":
run(main)

Some files were not shown because too many files have changed in this diff Show More