forked from mtusi2026/mtusi2026lab7
166 lines
10 KiB
Python
166 lines
10 KiB
Python
import os
|
||
import secrets
|
||
from pathlib import Path
|
||
|
||
|
||
def env_str(name: str, default: str) -> str:
|
||
return os.environ.get(name, default).strip()
|
||
|
||
|
||
def env_int(name: str, default: int) -> int:
|
||
value = int(env_str(name, str(default)))
|
||
if value < 1:
|
||
raise ValueError(f"{name} must be >= 1")
|
||
return value
|
||
|
||
|
||
def read_secret(file_variable: str, plain_variable: str) -> str:
|
||
path = env_str(file_variable, "")
|
||
if path:
|
||
return Path(path).read_text(encoding="utf-8").strip()
|
||
return env_str(plain_variable, "")
|
||
|
||
|
||
APP_HOST = env_str("APP_HOST", "0.0.0.0")
|
||
APP_PORT = env_int("APP_PORT", 8080)
|
||
APP_ENV = env_str("APP_ENV", "lab")
|
||
APP_VERSION = env_str("APP_VERSION", "dev")
|
||
|
||
# lab7: X-Instance-Id — случайный alias процесса (не hostname/IP контейнера), стабилен до его рестарта.
|
||
# scripts/stop_one.py находит контейнер по файлу INSTANCE_ID_FILE (tmpfs внутри контейнера).
|
||
INSTANCE_ID = env_str("INSTANCE_ID", "") or secrets.token_hex(6)
|
||
INSTANCE_ID_FILE = env_str("INSTANCE_ID_FILE", "/tmp/instance-id")
|
||
|
||
SESSION_TTL_SECONDS = env_int("SESSION_TTL_SECONDS", 3600)
|
||
SESSION_STORE = env_str("SESSION_STORE", "redis")
|
||
|
||
# lab7: PostgreSQL по TLS (verify-full: CA + имя сервера), у каждого сервиса своя роль; пароль роли —
|
||
# из OpenBao (secretstore, ключ db_password), а не из файла/переменной.
|
||
DB_HOST = env_str("DB_HOST", "postgres")
|
||
DB_PORT = env_int("DB_PORT", 5432)
|
||
DB_NAME = env_str("DB_NAME", "messenger")
|
||
DB_USER = env_str("DB_USER", "messenger_api")
|
||
DB_SSLMODE = env_str("DB_SSLMODE", "verify-full")
|
||
DB_PASSWORD_KEY = env_str("DB_PASSWORD_KEY", "db_password")
|
||
DB_POOL_MIN = env_int("DB_POOL_MIN", 1)
|
||
DB_POOL_MAX = env_int("DB_POOL_MAX", 10)
|
||
DB_POOL_WAIT_SECONDS = env_int("DB_POOL_WAIT_SECONDS", 3)
|
||
DB_CONNECT_TIMEOUT_SECONDS = env_int("DB_CONNECT_TIMEOUT_SECONDS", 3)
|
||
DB_STATEMENT_TIMEOUT_MS = env_int("DB_STATEMENT_TIMEOUT_MS", 5000)
|
||
|
||
# lab7: Redis по TLS (+ клиентский сертификат), ACL-пользователь с доступом только к session:* и ratelimit:*.
|
||
REDIS_HOST = env_str("REDIS_HOST", "redis")
|
||
REDIS_PORT = env_int("REDIS_PORT", 6379)
|
||
REDIS_USER = env_str("REDIS_USER", "api")
|
||
REDIS_POOL_MAX = env_int("REDIS_POOL_MAX", 20)
|
||
REDIS_TIMEOUT_MS = env_int("REDIS_TIMEOUT_MS", 500)
|
||
|
||
MIGRATIONS_DIR = Path(env_str("MIGRATIONS_DIR", str(Path(__file__).resolve().parent / "migrations")))
|
||
SCHEMA_WAIT_SECONDS = env_int("SCHEMA_WAIT_SECONDS", 60)
|
||
|
||
# S3 (SeaweedFS): адрес, bucket и отдельный ключ API с правами только на этот bucket.
|
||
# lab7: HTTPS с проверкой CA; ключ доступа у каждого сервиса свой (права по prefix), берётся из OpenBao.
|
||
S3_ENDPOINT = env_str("S3_ENDPOINT", "https://s3:8333")
|
||
S3_REGION = env_str("S3_REGION", "us-east-1")
|
||
S3_BUCKET = env_str("S3_BUCKET", "messenger-attachments")
|
||
S3_CONNECT_TIMEOUT_SECONDS = env_int("S3_CONNECT_TIMEOUT_SECONDS", 1)
|
||
S3_READ_TIMEOUT_SECONDS = env_int("S3_READ_TIMEOUT_SECONDS", 5)
|
||
S3_MAX_ATTEMPTS = env_int("S3_MAX_ATTEMPTS", 2)
|
||
S3_POOL_MAX = env_int("S3_POOL_MAX", 20)
|
||
|
||
# Вложения: лимиты из контракта и защита памяти/времени.
|
||
MAX_UPLOAD_BYTES = env_int("MAX_UPLOAD_BYTES", 10 * 1024 * 1024)
|
||
MAX_IMAGE_PIXELS = env_int("MAX_IMAGE_PIXELS", 40_000_000)
|
||
UPLOAD_TIMEOUT_SECONDS = env_int("UPLOAD_TIMEOUT_SECONDS", 60)
|
||
UPLOAD_IDLE_TIMEOUT_SECONDS = env_int("UPLOAD_IDLE_TIMEOUT_SECONDS", 10)
|
||
DECODE_CONCURRENCY = env_int("DECODE_CONCURRENCY", 2)
|
||
UPLOAD_TMP_DIR = env_str("UPLOAD_TMP_DIR", "/tmp/uploads")
|
||
|
||
# Очистка незавершённых загрузок (janitor.py).
|
||
ATTACHMENT_GRACE_SECONDS = env_int("ATTACHMENT_GRACE_SECONDS", 3600)
|
||
JANITOR_INTERVAL_SECONDS = env_int("JANITOR_INTERVAL_SECONDS", 300)
|
||
|
||
SHUTDOWN_DRAIN_SECONDS = env_int("SHUTDOWN_DRAIN_SECONDS", 3)
|
||
SHUTDOWN_TIMEOUT_SECONDS = env_int("SHUTDOWN_TIMEOUT_SECONDS", 10)
|
||
|
||
# lab5: брокер (RabbitMQ) и фоновая обработка вложений.
|
||
# У API адреса брокера нет вообще: API пишет задание в outbox (PostgreSQL), публикует dispatcher.
|
||
# lab7: AMQPS + mTLS, пользователь брокера = CN клиентского сертификата (EXTERNAL), пароля нет.
|
||
# Адрес не секрет: amqps://rabbitmq:5671/messenger. У API и janitor брокера нет (пусто).
|
||
BROKER_URL = env_str("BROKER_URL", "")
|
||
BROKER_HEARTBEAT_SECONDS = env_int("BROKER_HEARTBEAT_SECONDS", 30)
|
||
PIPELINE_VERSION = env_int("PIPELINE_VERSION", 1)
|
||
WORKER_CONCURRENCY = env_int("WORKER_CONCURRENCY", 2) # потоков-потребителей в одном worker
|
||
WORKER_PREFETCH = env_int("WORKER_PREFETCH", 1) # неподтверждённых сообщений на поток
|
||
JOB_MAX_ATTEMPTS = env_int("JOB_MAX_ATTEMPTS", 5)
|
||
JOB_TIMEOUT_SECONDS = env_int("JOB_TIMEOUT_SECONDS", 60) # жёсткий предел одной обработки изображения
|
||
JOB_LEASE_SECONDS = env_int("JOB_LEASE_SECONDS", 15) # аренда processing, продлевается каждые lease/3
|
||
JOB_BACKOFF_BASE_SECONDS = env_int("JOB_BACKOFF_BASE_SECONDS", 2)
|
||
JOB_BACKOFF_MAX_SECONDS = env_int("JOB_BACKOFF_MAX_SECONDS", 60)
|
||
JOB_RECONCILE_SECONDS = env_int("JOB_RECONCILE_SECONDS", 120) # queued без сообщения дольше -> опубликовать заново
|
||
WORKER_MEMORY_LIMIT_MB = env_int("WORKER_MEMORY_LIMIT_MB", 640) # RLIMIT_AS процесса обработки
|
||
WORKER_TMP_DIR = env_str("WORKER_TMP_DIR", "/tmp/work")
|
||
DISPATCHER_POLL_SECONDS = env_int("DISPATCHER_POLL_SECONDS", 1)
|
||
DISPATCHER_BATCH = env_int("DISPATCHER_BATCH", 100)
|
||
STAGING_RETENTION_SECONDS = env_int("STAGING_RETENTION_SECONDS", 86400) # исходник failed-вложения для replay
|
||
OUTBOX_RETENTION_SECONDS = env_int("OUTBOX_RETENTION_SECONDS", 7 * 86400)
|
||
ALIVE_FILE = env_str("ALIVE_FILE", "/tmp/alive") # healthcheck фоновых процессов
|
||
|
||
# Учебное внедрение сбоев (faults.py). На стенде включено, в эксплуатации FAULT_INJECTION=0.
|
||
FAULT_INJECTION = env_str("FAULT_INJECTION", "0") == "1"
|
||
FAULTS_DIR = env_str("FAULTS_DIR", "/faults")
|
||
|
||
|
||
# ---------- lab7: TLS, OpenBao, вход ----------
|
||
|
||
# Файлы сервиса: CA (публичный), свой leaf-сертификат и ключ (identity = CN), CRL учебного CA.
|
||
TLS_CA_FILE = env_str("TLS_CA_FILE", "/run/tls-ca/ca.crt")
|
||
TLS_CRL_FILE = env_str("TLS_CRL_FILE", "/run/tls-ca/crl.pem")
|
||
TLS_CERT_FILE = env_str("TLS_CERT_FILE", "/run/tls/tls.crt")
|
||
TLS_KEY_FILE = env_str("TLS_KEY_FILE", "/run/tls/tls.key")
|
||
|
||
# Listener API: только mTLS; разрешённые identity клиента (CN), по умолчанию только балансировщик.
|
||
API_TLS = env_str("API_TLS", "1") == "1"
|
||
API_ALLOWED_CLIENTS = frozenset(x.strip() for x in env_str("API_ALLOWED_CLIENTS", "lb").split(",") if x.strip())
|
||
CRL_RELOAD_SECONDS = env_int("CRL_RELOAD_SECONDS", 5)
|
||
# Отдельный listener только для проверок здоровья контейнера: 127.0.0.1, только /health/live и /health/ready.
|
||
HEALTH_HOST = env_str("HEALTH_HOST", "127.0.0.1")
|
||
HEALTH_PORT = env_int("HEALTH_PORT", 8081)
|
||
|
||
# OpenBao: адрес, роль cert auth (= CN сертификата сервиса), mount KV v2.
|
||
BAO_ADDR = env_str("BAO_ADDR", "https://openbao:8200")
|
||
BAO_ROLE = env_str("BAO_ROLE", "api")
|
||
BAO_KV_MOUNT = env_str("BAO_KV_MOUNT", "messenger")
|
||
SECRETS_REFRESH_SECONDS = env_int("SECRETS_REFRESH_SECONDS", 30)
|
||
SECRETS_STARTUP_TIMEOUT_SECONDS = env_int("SECRETS_STARTUP_TIMEOUT_SECONDS", 60)
|
||
|
||
# Argon2id (RFC 9106 / OWASP): не ниже m=19 MiB, t=2, p=1. Выбор по замеру — REPORT.md.
|
||
ARGON2_MEMORY_KIB = env_int("ARGON2_MEMORY_KIB", 32768) # 32 MiB: замер — REPORT.md, evidence/argon2-bench.json
|
||
ARGON2_ITERATIONS = env_int("ARGON2_ITERATIONS", 2)
|
||
ARGON2_PARALLELISM = env_int("ARGON2_PARALLELISM", 1)
|
||
# Бюджет CPU/RAM на хеширование в одной реплике: одновременно не больше N хешей (N x m памяти),
|
||
# остальные ждут не дольше ARGON2_QUEUE_SECONDS, затем 503 + Retry-After (не копим очередь).
|
||
ARGON2_MAX_CONCURRENCY = env_int("ARGON2_MAX_CONCURRENCY", 2)
|
||
ARGON2_QUEUE_SECONDS = env_int("ARGON2_QUEUE_SECONDS", 2)
|
||
|
||
# Общий для реплик (Redis) rate limit входа и регистрации: фиксированное окно.
|
||
LOGIN_RATE_WINDOW_SECONDS = env_int("LOGIN_RATE_WINDOW_SECONDS", 60)
|
||
LOGIN_RATE_PER_USERNAME = env_int("LOGIN_RATE_PER_USERNAME", 10) # попыток на username за окно
|
||
LOGIN_RATE_PER_CLIENT = env_int("LOGIN_RATE_PER_CLIENT", 600) # попыток входа с одного IP за окно
|
||
REGISTER_RATE_PER_CLIENT = env_int("REGISTER_RATE_PER_CLIENT", 600) # регистраций с одного IP за окно
|
||
# Ограничение размера JSON-запроса (вложения ограничены отдельно MAX_UPLOAD_BYTES).
|
||
MAX_JSON_BYTES = env_int("MAX_JSON_BYTES", 65536)
|
||
|
||
|
||
def check() -> None:
|
||
"""Проверка при старте: лучше сразу упасть с понятной ошибкой, чем на первом запросе."""
|
||
for name in ("TLS_CA_FILE", "TLS_CERT_FILE", "TLS_KEY_FILE"):
|
||
if not Path(globals()[name]).is_file():
|
||
raise RuntimeError(f"{name} is not a readable file")
|
||
if ATTACHMENT_GRACE_SECONDS < 2 * UPLOAD_TIMEOUT_SECONDS:
|
||
raise RuntimeError("ATTACHMENT_GRACE_SECONDS must be at least twice UPLOAD_TIMEOUT_SECONDS")
|
||
if SESSION_STORE != "redis":
|
||
raise RuntimeError("SESSION_STORE: only 'redis' is supported in this solution")
|
||
if ARGON2_MEMORY_KIB < 19456 or ARGON2_ITERATIONS < 2 or ARGON2_PARALLELISM < 1:
|
||
raise RuntimeError("Argon2id parameters below the lab minimum m=19456 KiB, t=2, p=1")
|