two api-replicas with LB-nginx

This commit is contained in:
2026-11-04 17:20:59 +03:00
parent f20b751207
commit 5c191c3bc5
50 changed files with 2991 additions and 311 deletions
+4 -6
View File
@@ -15,7 +15,6 @@ SESSION_STORE=redis
REDIS_HOST=redis
REDIS_PORT=6379
REDIS_DB=0
REDIS_PASSWORD=change-me
REDIS_MAX_CONNECTIONS=20
REDIS_POOL_TIMEOUT_SECONDS=1
REDIS_CONNECT_TIMEOUT_SECONDS=1
@@ -25,7 +24,6 @@ DB_HOST=postgres
DB_PORT=5432
DB_NAME=messenger
DB_USER=messenger
DB_PASSWORD=change-me
# Пул на одну реплику: суммарно API_REPLICAS * (POOL_SIZE + MAX_OVERFLOW)
# соединений должно помещаться в max_connections PostgreSQL.
@@ -37,12 +35,12 @@ DB_STATEMENT_TIMEOUT_MS=5000
# --- Балансировка и идемпотентность ---
API_REPLICAS=2
API_IMAGE=mtusi-messenger:lab3
API_BUILD_REVISION=development
IDEMPOTENCY_TTL_SECONDS=86400
# Пусто -> id вычисляется в app/core/instance.py (TODO 3.2)
# INSTANCE_ID=api-1
# TODO(4.1): сколько секунд отдавать readiness=503 перед закрытием сокета
SHUTDOWN_DRAIN_SECONDS=0
SHUTDOWN_DRAIN_SECONDS=1
GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS=5
READINESS_TIMEOUT_SECONDS=2
# Порт единственной публичной точки входа (nginx)
LB_HOST_PORT=8080
+2 -1
View File
@@ -34,4 +34,5 @@ coverage/
/venv
.ruff_cache/
/docs
AGENTS.md
AGENTS.md
.pytest_cache
+7 -5
View File
@@ -1,5 +1,7 @@
FROM python:3.12.15-slim-bookworm
LABEL io.mtusi.messenger.secrets="file-v1"
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
@@ -16,14 +18,14 @@ COPY alembic.ini ./
COPY migrations ./migrations
COPY app ./app
USER appuser
ARG API_BUILD_REVISION
LABEL io.mtusi.messenger.revision=$API_BUILD_REVISION
# TODO(4.1): uvicorn корректно завершается по SIGTERM (сигнал Docker по умолчанию).
# Проверьте, что python — PID 1 (exec-форма CMD), иначе сигнал не дойдёт.
USER appuser
EXPOSE 8080
HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/live', timeout=2)"]
HEALTHCHECK --interval=3s --timeout=3s --start-period=10s --retries=2 \
CMD ["python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2.5)"]
CMD ["python", "-m", "app"]
+44 -9
View File
@@ -1,7 +1,8 @@
-include .env
PYTHON ?= $(if $(wildcard venv/bin/python),venv/bin/python,python3)
BASE_URL ?= http://localhost:8080
PYTEST_ARGS ?=
BASE_URL ?= http://localhost:$(LB_HOST_PORT)
CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
@@ -10,18 +11,19 @@ COMPOSE = docker compose --env-file .env
# Отдельный тестовый стенд: свой compose-проект, свои порты, открытые БД/Redis
# (compose.test.yaml). COMPOSE_FILE подхватывают и scripts/*.sh.
TEST_PROJECT ?= $(notdir $(CURDIR))-test
TEST_PROJECT ?= mtusi-messenger-lab3-test
TEST_LB_PORT ?= 18080
TEST_DB_PORT ?= 15432
TEST_REDIS_PORT ?= 16379
TEST_DB_PORT ?= $(DB_HOST_PORT)
TEST_REDIS_PORT ?= $(REDIS_HOST_PORT)
TEST_BASE_URL = http://localhost:$(TEST_LB_PORT)
TEST_ENV = COMPOSE_PROJECT_NAME=$(TEST_PROJECT) COMPOSE_FILE=compose.yaml:compose.test.yaml \
LB_HOST_PORT=$(TEST_LB_PORT) DB_HOST_PORT=$(TEST_DB_PORT) REDIS_HOST_PORT=$(TEST_REDIS_PORT)
TEST_COMPOSE = $(TEST_ENV) $(COMPOSE)
TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(DB_PASSWORD)@localhost:$(TEST_DB_PORT)/$(DB_NAME)_test
TEST_DB_PASSWORD = $(if $(wildcard secrets/db_password),$(file <secrets/db_password),$(DB_PASSWORD))
TEST_DATABASE_URL ?= postgresql+asyncpg://$(DB_USER):$(TEST_DB_PASSWORD)@localhost:$(TEST_DB_PORT)/$(DB_NAME)_test
TEST_REDIS_HOST ?= localhost
TEST_REDIS_PASSWORD ?= $(REDIS_PASSWORD)
TEST_REDIS_PASSWORD ?= $(if $(wildcard secrets/redis_password),$(file <secrets/redis_password),$(REDIS_PASSWORD))
TEST_REDIS_DB ?= 15
export TEST_DATABASE_URL TEST_REDIS_HOST TEST_REDIS_PORT TEST_REDIS_PASSWORD TEST_REDIS_DB
@@ -36,7 +38,8 @@ endef
test-stand-up test-stand-down test-stand-destroy test-stand-ps \
test-stand-smoke test-stand-persistence test-stand-failover \
test-own test-docker test-limits test-concurrency test-migrations test-all \
explain expiry-demo failure-demo
explain expiry-demo failure-demo test-nginx test-grade3 test-stand-idempotency \
prepare-secrets rolling-update failover-all test-grade4
help:
@echo "Проверки: check | validate | test | load | test-persistence ACTION_SCRIPT=scripts/restart.sh"
@@ -46,6 +49,10 @@ help:
@echo " test-stand-smoke | test-stand-persistence | test-stand-failover"
@echo "Тесты: test-own | test-docker | test-limits | test-concurrency | test-migrations | test-all"
@echo "Демо: explain | expiry-demo | failure-demo (на тестовом стенде)"
@echo "Nginx: test-nginx (отдельный временный стенд без БД и приложения)"
@echo "Lab3: test-grade3 (все проверки уровня 3 с удалением тестовых volumes)"
@echo "Уровень4: prepare-secrets | rolling-update | failover-all"
@echo " test-grade4 (полный прогон на отдельном стенде с очисткой)"
@echo "Миграции: migration m='описание' (нужен поднятый тестовый стенд)"
# --- Проверки API и сценариев отказа (tests/) ---
@@ -56,6 +63,22 @@ check:
validate:
$(PYTHON) scripts/validate_openapi.py
test-nginx:
$(PYTHON) scripts/check_nginx.py
test-grade3:
@set -eu; trap '$(TEST_COMPOSE) down --volumes --remove-orphans' EXIT; \
$(MAKE) check validate; \
$(MAKE) test-stand-up; \
$(MAKE) test-docker test-stand-smoke test-stand-idempotency test-stand-persistence test-stand-failover
test-grade4:
@set -eu; trap '$(TEST_COMPOSE) down --volumes --remove-orphans' EXIT; \
$(MAKE) prepare-secrets check validate; \
$(MAKE) test-stand-up; \
$(MAKE) test-docker test-stand-smoke test-stand-idempotency test-stand-persistence test-stand-failover; \
$(TEST_ENV) $(PYTHON) -m scripts.check_grade4 --base-url "$(TEST_BASE_URL)"
test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
@@ -72,6 +95,15 @@ test-failover:
# --- Основной стенд ---
prepare-secrets:
$(PYTHON) -m scripts.prepare_secrets
rolling-update:
$(PYTHON) -m scripts.rolling_update --base-url "$(BASE_URL)" $(TLS_ARGS)
failover-all:
$(PYTHON) -m scripts.failover_all --base-url "$(BASE_URL)" $(TLS_ARGS)
up:
$(COMPOSE) up -d --build
$(call wait_ready,$(BASE_URL))
@@ -125,6 +157,9 @@ test-stand-ps:
test-stand-smoke:
$(PYTHON) tests/smoke.py --base-url "$(TEST_BASE_URL)"
test-stand-idempotency:
$(PYTHON) -m scripts.check_idempotency --base-url "$(TEST_BASE_URL)"
test-stand-persistence:
$(TEST_COMPOSE) ps
$(TEST_ENV) $(PYTHON) tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url "$(TEST_BASE_URL)"
@@ -139,10 +174,10 @@ test-stand-failover:
# --- Собственные тесты (student-tests/) ---
test-own:
$(PYTHON) -m pytest -q
$(PYTHON) -m pytest -q $(PYTEST_ARGS)
test-docker:
$(TEST_ENV) DOCKER_TESTS=1 $(PYTHON) -m pytest -q
$(TEST_ENV) DOCKER_TESTS=1 $(PYTHON) -m pytest -q $(PYTEST_ARGS)
test-limits:
$(PYTHON) -m pytest student-tests/test_limits.py -q
+78 -23
View File
@@ -1,37 +1,92 @@
# Отчёт — лабораторная 3
- Автор, группа: TODO
- Целевая оценка; выбранный трек 5, если нужен: TODO
- Commit/PR: TODO после публикации
- Использованные источники, библиотеки и помощь ИИ: TODO
Автор: **Григорян Илья Мурадович, БПИ2303**. Целевая оценка: **4**, трек 5 не заявлен.
Проверка: 04.11.2026. Базовый commit: `f20b751207ed9948bfcdab829c458a4af122d611`;
реализация находится в незакоммиченном рабочем дереве, PR ещё не создан.
Точный состав проверенного кода — [SHA-256 файлов](evidence/source-sha256.txt).
## Запуск из чистого clone
## Запуск и проверки
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
Нужны Python 3.12, Docker и Compose. Из корня чистого клона:
## Архитектура и решения
```sh
python3 -m venv .venv
.venv/bin/python -m pip install -r requirements.txt -r requirements-dev.txt
test -f .env || cp .env.example .env
make prepare-secrets PYTHON=.venv/bin/python
make up
make instances
```
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
Настройте `.env` перед запуском; существующий файл не заменяйте. Пароли читаются
из `secrets/`; существующие файлы не перезаписываются. По умолчанию вход —
`http://localhost:8080`, при изменении `LB_HOST_PORT` Make использует этот порт.
`make down` сохраняет данные. Миграции выполняет отдельный сервис перед API.
## Доказательства критериев
Полный прогон с отдельными данными и автоматическим удалением тестового стенда:
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | make test | TODO | TODO |
| Остальные пункты уровня 3 | TODO | TODO | TODO |
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
```sh
make test-grade4 PYTHON=.venv/bin/python
make test-nginx PYTHON=.venv/bin/python
```
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
Для ручного тестового стенда: `make test-stand-up`, затем `make test-docker
PYTHON=.venv/bin/python` и нужные `test-stand-*` из `make help`. По умолчанию вход
`:18080`, PostgreSQL `:15432`, Redis `:16379`. Pytest очищает `<DB_NAME>_test` и
Redis DB 15. `make test-stand-destroy` удаляет именно тестовые volumes.
## Эксперименты и отказы
## Реализация и результаты
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
Nginx → две API → общие PostgreSQL и Redis. Сообщение, счётчик и результат ключа
фиксируются одной транзакцией; PostgreSQL-блокировка сериализует одинаковый ключ
между репликами. Подробности, файлы и параметры — [EXPLAIN.md](EXPLAIN.md), ответы
для защиты — [DEFENCE.md](DEFENCE.md), методика — [evidence/README.md](evidence/README.md).
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| TODO | TODO | TODO | TODO |
Все строки ниже проверены командой `make test-grade4 PYTHON=.venv/bin/python`;
исходный вывод — [test-output.txt](evidence/test-output.txt).
## Ограничения и следующие шаги
| Критерий README | Наблюдение |
| --- | --- |
| 3: воспроизводимая топология, ≥2 API, общие хранилища | Стенд создан с нуля; две API, одна PostgreSQL, одна Redis, вход через Nginx. |
| 3: одна сессия на разных API | 24 конкурентных повтора с одной сессией обслужены двумя реальными репликами. |
| 3: чтение/запись при отказе ≤10 с | Публичный failover прошёл; отдельный отказ каждой API — восстановление за 1,800 / 1,782 с. |
| 3: общая идемпотентность | 24 повтора дали один Message и одну запись истории; конфликт тела, TTL и rollback покрыты pytest. |
| 3: smoke, persistence, failover | Все прошли, существующая сессия и подтверждённые сообщения сохранены. |
| 4: health, timeout, SIGTERM | При drain ready=503, live=200, новая работа=503; начатый POST=201, остановка за 2,145 с без SIGKILL. |
| 4: последовательный отказ каждой API | До/после остановки и восстановления записаны состояния; RPS и ошибки приведены ниже. |
| 4: лимиты, порты, секреты, масштабирование | Проверены фактические CPU/RAM, закрытые порты API, read-only секреты по назначению, отсутствие паролей в окружении и container_name. |
| 4: обновление под нагрузкой | Оба контейнера заменены новым образом, миграционная команда вызвана один раз, перед остановкой доступны ≥2 здоровых API. |
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
**156 pytest прошли за 42,30 с**. Проверки контракта и OpenAPI прошли.
Отдельный `make test-nginx` подтвердил конфигурацию, DNS без reload, ограничитель,
ошибки и gzip 2060 → 61 байт: [вывод](evidence/nginx-output.txt).
| Сценарий | Успешных ответов | RPS | Ошибки попыток | Восстановление |
| --- | ---: | ---: | --- | ---: |
| Rolling update, 23,627 с | 456 | 19,300 | 13 × 503 | Не измерялось отдельно |
| Отказ API 1, 13,853 с | 773 | 55,800 | 67 × 429; 16 × 503 | 1,800 с |
| Отказ API 2, 13,875 с | 773 | 55,710 | 99 × 429; 17 × 503 | 1,782 с |
Подтверждённые сообщения сохранены, дублей нет. Ошибки измерены за весь сценарий;
429 связаны с ограничителем, 503 — с временной недоступностью. Механизм обновления
проверен изменением метки образа без изменения бизнес-кода; новых ожидающих DDL
на этапе rolling не было. Будущие миграции требуют отдельной проверки совместимости.
## Параметры и ограничения
API: readiness каждые 3 с, timeout 3 с, две неудачи, start period 10 с; после старта
оценка unhealthy ≤12 с. Nginx использует пассивные проверки: connect ≤0,5 с на попытку,
пауза чтения ≤10 с, исключение peer на 5 с; без трафика обнаружение не происходит.
Drain 1 с + ожидание задач 5 с < Docker grace 8 с. CPU/RAM каждого сервиса,
оборудование, версии и профиль нагрузки — в [run.json](evidence/run.json) и
[методике](evidence/README.md). Это один прогон с двумя клиентами, не измерение
максимальной производительности. Средний RPS может превышать 50 из-за burst=100.
Стенд односерверный; PostgreSQL, Redis и Nginx остаются единичными точками отказа.
Откат контейнеров не откатывает БД. TTL ключа — 24 часа, очистка при повторном
использовании, фоновой очистки нет. Исходное задание и публичные tests не ослаблены.
Источники: [контракт](contracts/README.md), [курс](COURSE.md), закреплённые зависимости
и их установленные исходники, ссылки на документацию Docker в [README](README.md#первичные-материалы).
Для реализации, проверок и подготовки пояснений использован ИИ-помощник Codex;
приведённые результаты получены реальным запуском команд.
+27 -9
View File
@@ -1,11 +1,16 @@
from enum import StrEnum
from pathlib import Path
from typing import Literal, Self
from pydantic import Field, SecretStr, model_validator
from pydantic_settings import BaseSettings, SettingsConfigDict
from pydantic_settings import BaseSettings, PydanticBaseSettingsSource, SettingsConfigDict
from sqlalchemy import URL
ASYNC_DRIVER = "postgresql+asyncpg"
SECRETS_DIR = next(
(path for path in (Path("/run/secrets"), Path(__file__).resolve().parents[2] / "secrets") if (path / "db_password").is_file()),
None,
)
class LogLevel(StrEnum):
@@ -51,23 +56,36 @@ class Settings(BaseSettings):
db_connect_timeout_seconds: int = Field(default=3, ge=1)
db_statement_timeout_ms: int = Field(default=5000, ge=1)
# Балансировка между репликами и идемпотентность
instance_id: str | None = None # TODO(3.2): None -> вычислить в resolve_instance_id
idempotency_ttl_seconds: int = Field(default=86400, ge=1) # TODO(3.4)
shutdown_drain_seconds: float = Field(default=0, ge=0) # TODO(4.1)
graceful_shutdown_timeout_seconds: int = Field(default=5, ge=1) # TODO(4.1)
instance_id: str | None = None
idempotency_ttl_seconds: int = Field(default=86400, ge=1)
shutdown_drain_seconds: float = Field(default=1, ge=0)
graceful_shutdown_timeout_seconds: int = Field(default=5, ge=1)
readiness_timeout_seconds: float = Field(default=2, gt=0, lt=2.5)
# TODO(4.3): секреты из файлов (Docker secrets): pydantic-settings умеет
# secrets_dir="/run/secrets" — имя файла = имя поля (db_password, ...).
model_config = SettingsConfigDict(
env_file=".env",
env_file_encoding="utf-8",
case_sensitive=False,
extra="ignore",
secrets_dir=SECRETS_DIR,
)
@classmethod
def settings_customise_sources(
cls,
settings_cls: type[BaseSettings],
init_settings: PydanticBaseSettingsSource,
env_settings: PydanticBaseSettingsSource,
dotenv_settings: PydanticBaseSettingsSource,
file_secret_settings: PydanticBaseSettingsSource,
) -> tuple[PydanticBaseSettingsSource, ...]:
"""Явные параметры и файлы имеют приоритет над окружением."""
return init_settings, file_secret_settings, env_settings, dotenv_settings
@model_validator(mode="after")
def _require_database_source(self) -> Self:
if self.shutdown_drain_seconds + self.graceful_shutdown_timeout_seconds >= 8:
raise ValueError("Drain и graceful shutdown должны суммарно занимать менее 8 секунд")
if self.database_url is not None:
if not self.database_url.get_secret_value().startswith(ASYNC_DRIVER):
raise ValueError(f"DATABASE_URL должен начинаться с {ASYNC_DRIVER}://")
@@ -75,7 +93,7 @@ class Settings(BaseSettings):
if not (self.db_host and self.db_name and self.db_user and self.db_password):
raise ValueError(
"Задайте DATABASE_URL или DB_HOST, DB_NAME, DB_USER и DB_PASSWORD"
"Нужны DATABASE_URL либо DB_HOST, DB_NAME, DB_USER и секрет db_password"
)
return self
+16 -16
View File
@@ -1,5 +1,8 @@
"""Идентификатор API-реплики и заголовок X-Instance-Id."""
import os
from uuid import uuid4
from starlette.middleware.base import BaseHTTPMiddleware, RequestResponseEndpoint
from starlette.requests import Request
from starlette.responses import Response
@@ -8,25 +11,19 @@ INSTANCE_ID_HEADER = "X-Instance-Id"
def resolve_instance_id(configured: str | None) -> str:
"""Возвращает id реплики, стабильный в течение жизни процесса.
"""Выбирает INSTANCE_ID, HOSTNAME или UUID при старте приложения."""
if configured and configured.strip():
return configured.strip()
TODO(3.2): выбрать источник id.
- Если задан непустой INSTANCE_ID в настройках — вернуть его.
- Иначе — что-то, что позволит stop-one.sh найти именно этот контейнер
(подсказка: Docker кладёт короткий id контейнера в переменную HOSTNAME,
а `docker stop <короткий id>` работает).
- Значение вычисляется один раз при старте и не меняется до конца процесса.
"""
raise NotImplementedError("TODO(3.2): resolve_instance_id")
hostname = os.getenv("HOSTNAME", "").strip()
if hostname:
return hostname
return str(uuid4())
class InstanceIdMiddleware(BaseHTTPMiddleware):
"""Добавляет X-Instance-Id в каждый ответ API, включая ошибки и /health/*.
TODO(3.2): реализовать dispatch по образцу RequestIdMiddleware
(app/core/request_id.py) и подключить в create_app (app/main.py).
Проверьте, что заголовок есть и у ответов из exception handlers.
"""
"""Добавляет сохранённый идентификатор реплики в ответ."""
def __init__(self, app, instance_id: str) -> None:
super().__init__(app)
@@ -37,4 +34,7 @@ class InstanceIdMiddleware(BaseHTTPMiddleware):
request: Request,
call_next: RequestResponseEndpoint,
) -> Response:
raise NotImplementedError("TODO(3.2): InstanceIdMiddleware.dispatch")
response = await call_next(request)
response.headers[INSTANCE_ID_HEADER] = self.instance_id
return response
+35 -17
View File
@@ -1,12 +1,14 @@
"""Состояние жизненного цикла реплики: готова / уходит (graceful shutdown).
"""Готовность реплики и мягкое завершение сервера."""
Идея: при SIGTERM реплика сначала перестаёт быть "ready" (/health/ready -> 503),
чтобы балансировщик успел исключить её, и только затем uvicorn перестаёт
принимать соединения и дожидается текущих запросов.
"""
import asyncio
from types import FrameType
import uvicorn
class Lifecycle:
"""Хранит состояние завершения реплики."""
def __init__(self) -> None:
self._draining = False
@@ -15,18 +17,34 @@ class Lifecycle:
return self._draining
def start_draining(self) -> None:
"""TODO(4.1): вызвать при получении SIGTERM / в начале shutdown."""
"""Отключает приём новых бизнес-запросов."""
self._draining = True
# TODO(4.1): решить, где перехватывать SIGTERM.
# uvicorn сам ставит обработчик SIGTERM и сразу закрывает listening socket,
# поэтому "сначала readiness=503, потом закрыть приём" нужно сделать явно:
# - либо обернуть/переопределить обработчик сигнала uvicorn
# (uvicorn.Server.handle_exit) так, чтобы он сначала вызывал
# lifecycle.start_draining(), ждал SHUTDOWN_DRAIN_SECONDS и только потом
# передавал управление штатному завершению;
# - либо полагаться на passive-проверки nginx (proxy_next_upstream) и честно
# описать в REPORT.md, сколько запросов теряется.
# Сумма drain + timeout_graceful_shutdown должна быть меньше stop_grace_period
# в compose.yaml, иначе Docker добьёт процесс SIGKILL.
class GracefulServer(uvicorn.Server):
"""Оставляет время для исключения завершающейся реплики."""
def __init__(
self, config: uvicorn.Config, lifecycle: Lifecycle, drain_seconds: float
) -> None:
super().__init__(config)
self.lifecycle = lifecycle
self.drain_seconds = drain_seconds
self._drain_task: asyncio.Task[None] | None = None
def handle_exit(self, sig: int, frame: FrameType | None) -> None:
"""Первый сигнал запускает drain, повторный ускоряет остановку."""
if self._drain_task is not None:
if not self._drain_task.done():
self._drain_task.cancel()
super().handle_exit(sig, frame)
return
self.lifecycle.start_draining()
self._drain_task = asyncio.get_running_loop().create_task(
self._finish_draining(sig, frame)
)
async def _finish_draining(self, sig: int, frame: FrameType | None) -> None:
"""Передаёт остановку Uvicorn после drain-периода."""
await asyncio.sleep(self.drain_seconds)
super().handle_exit(sig, frame)
+3 -1
View File
@@ -2,7 +2,7 @@ from collections.abc import AsyncIterator
from fastapi import Request
from app.errors.exceptions import rate_limited
from app.errors.exceptions import rate_limited, unavailable
class RequestCapacity:
@@ -29,6 +29,8 @@ def create_request_capacity(max_in_flight: int) -> RequestCapacity:
async def acquire_request_slot(request: Request) -> AsyncIterator[None]:
if request.app.state.lifecycle.draining:
raise unavailable("Реплика завершает работу")
capacity: RequestCapacity = request.app.state.request_capacity
if not capacity.try_acquire():
+1 -1
View File
@@ -13,7 +13,7 @@ TOKEN_BYTES = 32
_hasher = PasswordHasher()
_executor = ThreadPoolExecutor(
max_workers=max(1, (os.cpu_count() or 1) // _hasher.parallelism),
max_workers=max(1, min(2, (os.cpu_count() or 1) // _hasher.parallelism)),
thread_name_prefix="argon2",
)
+32 -41
View File
@@ -1,15 +1,4 @@
"""Идемпотентность POST сообщения, общая для всех API-реплик.
Семантика:
- ключ: ASCII [A-Za-z0-9._:-]{1,128}; нет/неверный — 400;
- область уникальности: пользователь + метод + путь чата + ключ;
- тот же JSON в течение 24 ч -> тот же 201 и то же Message;
- другой JSON с тем же ключом -> 409;
- одновременные повторы через разные реплики -> ровно одно сообщение;
- повтор снова проверяет сессию и членство в чате;
- транзиентная 5xx не фиксируется как окончательный результат;
- побочный эффект (INSERT сообщения) и запись результата — атомарно.
"""
"""Атомарная отправка сообщения с защитой от повторов."""
import hashlib
import json
@@ -18,27 +7,26 @@ from uuid import UUID
from sqlalchemy.ext.asyncio import AsyncSession
from app.domain.chats import ensure_chat_member
from app.errors.exceptions import conflict, invalid_request, unavailable
from app.models.message import Message as MessageModel
from app.schemas.message import CreateMessage, Message
from app.schemas.user import User
from app.storage import idempotency as key_storage
from app.storage import messages as message_storage
IDEMPOTENCY_KEY_PATTERN = re.compile(r"[A-Za-z0-9._:-]{1,128}")
def validate_idempotency_key(key: str | None) -> str:
"""Возвращает ключ или бросает invalid_request (400).
TODO(3.4): проверить наличие и формат (fullmatch по IDEMPOTENCY_KEY_PATTERN).
"""
raise NotImplementedError("TODO(3.4): validate_idempotency_key")
"""Проверяет обязательный ASCII-ключ запроса."""
if key is None or IDEMPOTENCY_KEY_PATTERN.fullmatch(key) is None:
raise invalid_request("Требуется корректный Idempotency-Key")
return key
def request_fingerprint(new_message: CreateMessage) -> str:
"""Хеш семантического содержимого запроса для сравнения повторов.
Порядок ключей JSON не должен влиять на результат, поэтому хешируйте
нормализованную форму (например, json.dumps(..., sort_keys=True)
от new_message.model_dump()), а не сырые байты тела.
"""
"""Хеширует нормализованное содержимое запроса."""
canonical = json.dumps(
new_message.model_dump(mode="json"), sort_keys=True, ensure_ascii=False
)
@@ -54,22 +42,25 @@ async def send_message_idempotent(
max_messages: int,
ttl_seconds: int,
) -> Message:
"""Отправляет сообщение ровно один раз для (sender, POST, chat_id, key).
"""Создаёт сообщение или возвращает результат прежнего запроса."""
await ensure_chat_member(session, sender, chat_id)
scope = (sender.id, "POST", f"/api/v1/chats/{chat_id}/messages", idempotency_key)
fingerprint = request_fingerprint(new_message)
TODO(3.4). Один из рабочих вариантов на PostgreSQL:
1. ensure_chat_member(...) — доступ проверяется и на повторе.
2. В одной транзакции:
INSERT INTO idempotency_keys (...) VALUES (...)
ON CONFLICT (user_id, method, path, key) DO NOTHING RETURNING ...
- вставилось -> создать сообщение, записать message_id в строку ключа,
COMMIT (сообщение и ключ фиксируются вместе или не фиксируются вовсе);
- конфликт -> прочитать существующую строку. Параллельная транзакция
с тем же ключом будет ждать на уникальном индексе, пока первая
не завершится, поэтому дубля не будет.
3. Если fingerprint отличается -> conflict() (409).
4. Если совпадает -> вернуть сохранённое сообщение (тот же id/created_at).
5. Просроченные (> ttl_seconds) ключи считать отсутствующими.
Альтернатива — Redis SET NX + PostgreSQL; тогда отдельно продумайте
атомарность "сообщение записано, а ключ — нет" и наоборот.
"""
raise NotImplementedError("TODO(3.4): send_message_idempotent")
await key_storage.lock_key(session, scope)
previous = await key_storage.get_active_key(session, scope, ttl_seconds)
if previous is not None:
if previous.request_hash != fingerprint:
raise conflict("Idempotency-Key уже использован для другого сообщения")
message = await session.get(MessageModel, previous.message_id)
else:
if not await message_storage.reserve_message_slot(session, max_messages):
raise unavailable("Достигнут лимит количества сообщений")
message = await message_storage.create_message(
session, chat_id=chat_id, sender_id=sender.id, text=new_message.text
)
await key_storage.save_result(session, scope, fingerprint, message.id)
result = Message.model_validate(message)
await session.commit()
return result
+1 -24
View File
@@ -9,35 +9,12 @@ from app.domain.pagination import (
decode_cursor,
split_page,
)
from app.errors.exceptions import unavailable
from app.schemas.message import CreateMessage, Message, MessagePage
from app.schemas.message import Message, MessagePage
from app.schemas.user import User
from app.storage import messages as messages_storage
from app.storage.types import Position
async def send_message(
session: AsyncSession,
sender: User,
chat_id: UUID,
new_message: CreateMessage,
max_messages: int,
) -> Message:
"""Отправляет сообщение от имени участника; при исчерпании лимита даёт 503."""
await ensure_chat_member(session, sender, chat_id)
if not await messages_storage.reserve_message_slot(session, max_messages):
raise unavailable("Достигнут лимит количества сообщений")
message = await messages_storage.create_message(
session, chat_id=chat_id, sender_id=sender.id, text=new_message.text
)
await session.commit()
sent_message = Message.model_validate(message)
return sent_message
async def list_messages(
session: AsyncSession,
user: User,
+12 -6
View File
@@ -1,3 +1,5 @@
import asyncio
from fastapi import APIRouter, Request
from app.core.database import check_database
@@ -15,12 +17,16 @@ async def liveness() -> Health:
@router.get("/ready")
async def readiness(request: Request) -> Health:
# TODO(4.1): если реплика получила SIGTERM (lifecycle.draining) — сразу 503,
# чтобы LB исключил её до закрытия сокета.
# TODO(4.1): проверки зависимостей должны укладываться в timeout healthcheck;
# зафиксируйте в REPORT.md, какие зависимости критичны.
if not await check_database(request.app.state.engine):
if request.app.state.lifecycle.draining:
raise unavailable()
if not await check_redis(request.app.state.redis):
try:
async with asyncio.timeout(request.app.state.settings.readiness_timeout_seconds):
dependencies = await asyncio.gather(
check_database(request.app.state.engine),
check_redis(request.app.state.redis),
)
except TimeoutError:
raise unavailable() from None
if not all(dependencies):
raise unavailable()
return Health(status="ok")
+8 -9
View File
@@ -1,9 +1,10 @@
from typing import Annotated
from uuid import UUID
from fastapi import APIRouter, Query
from fastapi import APIRouter, Header, Query
from app.domain.messages import list_messages, send_message
from app.domain.idempotency import send_message_idempotent, validate_idempotency_key
from app.domain.messages import list_messages
from app.endpoints.dependencies import AppSettings, CurrentUser, DbSession
from app.schemas.message import CreateMessage, Message, MessagePage
@@ -17,14 +18,12 @@ async def send_new_message(
sender: CurrentUser,
session: DbSession,
settings: AppSettings,
# TODO(3.4): принять заголовок Idempotency-Key:
# idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None
# и вызывать app.domain.idempotency.send_message_idempotent(...) вместо send_message.
# Нет/неверный ключ -> 400 (validate_idempotency_key). Валидацию делайте сами,
# а не через pattern= у Header, чтобы текст ошибки был в общем формате.
idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None,
) -> Message:
return await send_message(
session, sender, chat_id, new_message, settings.max_messages
return await send_message_idempotent(
session, sender, chat_id, new_message,
validate_idempotency_key(idempotency_key),
settings.max_messages, settings.idempotency_ttl_seconds,
)
+4
View File
@@ -11,6 +11,7 @@ from sqlalchemy.exc import DBAPIError, InterfaceError, OperationalError
from sqlalchemy.exc import TimeoutError as PoolTimeoutError
from starlette.exceptions import HTTPException as StarletteHTTPException
from app.core.instance import INSTANCE_ID_HEADER
from app.core.request_id import REQUEST_ID_HEADER
from app.errors.exceptions import ApiError, internal_error, unavailable
@@ -43,6 +44,9 @@ def _build_response(
**(headers or {}),
REQUEST_ID_HEADER: request_id,
}
instance_id = getattr(request.app.state, "instance_id", None)
if instance_id is not None:
response_headers[INSTANCE_ID_HEADER] = instance_id
body = {
"error": {
+13 -9
View File
@@ -7,6 +7,8 @@ from fastapi import Depends, FastAPI
from app.core.config import Settings
from app.core.database import create_db_engine, create_session_factory
from app.core.instance import InstanceIdMiddleware, resolve_instance_id
from app.core.lifecycle import GracefulServer, Lifecycle
from app.core.redis import create_redis_client
from app.core.request_capacity import acquire_request_slot, create_request_capacity
from app.core.request_id import RequestIdMiddleware
@@ -45,12 +47,12 @@ def create_app(settings: Settings | None = None) -> FastAPI:
application.state.session_factory = create_session_factory(engine)
application.state.redis = redis
application.state.request_capacity = create_request_capacity(settings.max_in_flight)
# TODO(3.2): application.state.instance_id = resolve_instance_id(settings.instance_id)
# и application.add_middleware(InstanceIdMiddleware, instance_id=...)
# (app/core/instance.py). Middleware, добавленный последним, — внешний.
# TODO(4.1): application.state.lifecycle = Lifecycle() (app/core/lifecycle.py)
application.state.instance_id = resolve_instance_id(settings.instance_id)
application.state.lifecycle = Lifecycle()
application.add_middleware(RequestIdMiddleware)
application.add_middleware(
InstanceIdMiddleware, instance_id=application.state.instance_id
)
register_exception_handlers(application)
limited = [Depends(acquire_request_slot)]
@@ -65,15 +67,17 @@ def create_app(settings: Settings | None = None) -> FastAPI:
def main() -> None:
settings = Settings() # type: ignore
uvicorn.run(
"app.main:create_app",
factory=True,
application = create_app(settings)
config = uvicorn.Config(
application,
host=settings.app_host,
port=settings.app_port,
log_level=settings.log_level.lower(),
# TODO(4.1): согласовать с stop_grace_period в compose.yaml и drain-периодом
timeout_graceful_shutdown=settings.graceful_shutdown_timeout_seconds,
)
GracefulServer(
config, application.state.lifecycle, settings.shutdown_drain_seconds
).run()
if __name__ == "__main__":
+2 -1
View File
@@ -2,7 +2,8 @@ from app.models.base import Base
from app.models.chat import Chat
from app.models.chat_member import ChatMember
from app.models.counter import Counter
from app.models.idempotency_key import IdempotencyKey
from app.models.message import Message
from app.models.user import User
__all__ = ["Base", "Chat", "ChatMember", "Counter", "Message", "User"]
__all__ = ["Base", "Chat", "ChatMember", "Counter", "IdempotencyKey", "Message", "User"]
+19 -23
View File
@@ -1,28 +1,24 @@
"""ORM-модель записи идемпотентности.
"""Сохранённый результат отправки сообщения."""
TODO(3.4): раскомментировать/доработать, добавить в app/models/__init__.py
и сгенерировать миграцию: `make migration m="add idempotency keys"`
(с поднятой БД), затем проверить сгенерированный файл руками.
import uuid
from datetime import datetime
Примерная схема:
from sqlalchemy import ForeignKey, Index, String, func
from sqlalchemy.orm import Mapped, mapped_column
class IdempotencyKey(Base):
__tablename__ = "idempotency_keys"
__table_args__ = (
PrimaryKeyConstraint("user_id", "method", "path", "key"),
Index("ix_idempotency_keys_created_at", "created_at"), # для чистки по TTL
)
from app.models.base import Base
user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"))
method: Mapped[str] = mapped_column(String(8))
path: Mapped[str] = mapped_column(String(255))
key: Mapped[str] = mapped_column(String(128))
request_hash: Mapped[str] = mapped_column(String(64))
message_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("messages.id"))
created_at: Mapped[datetime] = mapped_column(server_default=func.now())
Вопросы проектирования:
- почему достаточно сохранить message_id, а не весь JSON ответа;
- как и когда удаляются ключи старше IDEMPOTENCY_TTL_SECONDS;
- что видит второй параллельный запрос, пока первый ещё не COMMIT.
"""
class IdempotencyKey(Base):
"""Ключ запроса и связанное сообщение."""
__tablename__ = "idempotency_keys"
__table_args__ = (Index("ix_idempotency_keys_created_at", "created_at"),)
user_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("users.id"), primary_key=True)
method: Mapped[str] = mapped_column(String(8), primary_key=True)
path: Mapped[str] = mapped_column(String(255), primary_key=True)
key: Mapped[str] = mapped_column(String(128), primary_key=True)
request_hash: Mapped[str] = mapped_column(String(64))
message_id: Mapped[uuid.UUID] = mapped_column(ForeignKey("messages.id"))
created_at: Mapped[datetime] = mapped_column(server_default=func.clock_timestamp())
+63
View File
@@ -0,0 +1,63 @@
"""Хранение и блокировка ключей в PostgreSQL."""
from datetime import timedelta
import hashlib
import json
from uuid import UUID
from sqlalchemy import BigInteger, func, literal, select, tuple_
from sqlalchemy.dialects.postgresql import insert
from sqlalchemy.ext.asyncio import AsyncSession
from app.models.idempotency_key import IdempotencyKey
Scope = tuple[UUID, str, str, str]
async def lock_key(session: AsyncSession, scope: Scope) -> None:
"""Сериализует один ключ до конца транзакции."""
raw = json.dumps([str(scope[0]), *scope[1:]]).encode()
lock_id = int.from_bytes(hashlib.sha256(raw).digest()[:8], signed=True)
await session.execute(
select(func.pg_advisory_xact_lock(literal(lock_id, type_=BigInteger)))
)
async def get_active_key(
session: AsyncSession, scope: Scope, ttl_seconds: int
) -> IdempotencyKey | None:
"""Читает результат, пока срок ключа не истёк."""
stmt = select(IdempotencyKey).where(
tuple_(
IdempotencyKey.user_id,
IdempotencyKey.method,
IdempotencyKey.path,
IdempotencyKey.key,
) == tuple_(*scope),
IdempotencyKey.created_at
> func.clock_timestamp() - timedelta(seconds=ttl_seconds),
)
return await session.scalar(stmt)
async def save_result(
session: AsyncSession, scope: Scope, request_hash: str, message_id: UUID
) -> None:
"""Сохраняет новый результат или заменяет истёкший."""
stmt = insert(IdempotencyKey).values(
user_id=scope[0], method=scope[1], path=scope[2], key=scope[3],
request_hash=request_hash, message_id=message_id,
)
await session.execute(
stmt.on_conflict_do_update(
index_elements=[
IdempotencyKey.user_id, IdempotencyKey.method,
IdempotencyKey.path, IdempotencyKey.key,
],
set_={
"request_hash": request_hash,
"message_id": message_id,
"created_at": func.clock_timestamp(),
},
)
)
+2 -2
View File
@@ -4,7 +4,7 @@
services:
postgres:
ports:
- "127.0.0.1:${DB_HOST_PORT:-15432}:5432"
- "127.0.0.1:${DB_HOST_PORT:?Set DB_HOST_PORT in .env}"
redis:
ports:
- "127.0.0.1:${REDIS_HOST_PORT:-16379}:6379"
- "127.0.0.1:${REDIS_HOST_PORT:?Set REDIS_HOST_PORT in .env}"
+95 -40
View File
@@ -1,75 +1,125 @@
# Клиент → nginx (LB) → api × N → postgres + redis.
# Незавершённые места помечены TODO(<номер>).
#
# Запуск: docker compose --env-file .env up -d --build (или make up)
name: mtusi-messenger-lab3
x-api-image: &api-image
build: .
image: mtusi-messenger:lab3
build:
context: .
args:
API_BUILD_REVISION: ${API_BUILD_REVISION:?Set API_BUILD_REVISION in .env}
image: ${API_IMAGE:?Set API_IMAGE in .env}
x-base-env: &base-env
APP_HOST: ${APP_HOST:?Set APP_HOST in .env}
APP_PORT: ${APP_PORT:?Set APP_PORT in .env}
APP_ENV: ${APP_ENV:?Set APP_ENV in .env}
LOG_LEVEL: ${LOG_LEVEL:?Set LOG_LEVEL in .env}
MAX_MESSAGES: ${MAX_MESSAGES:?Set MAX_MESSAGES in .env}
MAX_IN_FLIGHT: ${MAX_IN_FLIGHT:?Set MAX_IN_FLIGHT in .env}
DB_HOST: ${DB_HOST:?Set DB_HOST in .env}
DB_PORT: ${DB_PORT:?Set DB_PORT in .env}
DB_NAME: ${DB_NAME:?Set DB_NAME in .env}
DB_USER: ${DB_USER:?Set DB_USER in .env}
DB_POOL_SIZE: ${DB_POOL_SIZE:?Set DB_POOL_SIZE in .env}
DB_MAX_OVERFLOW: ${DB_MAX_OVERFLOW:?Set DB_MAX_OVERFLOW in .env}
DB_POOL_TIMEOUT_SECONDS: ${DB_POOL_TIMEOUT_SECONDS:?Set DB_POOL_TIMEOUT_SECONDS in .env}
DB_CONNECT_TIMEOUT_SECONDS: ${DB_CONNECT_TIMEOUT_SECONDS:?Set DB_CONNECT_TIMEOUT_SECONDS in .env}
DB_STATEMENT_TIMEOUT_MS: ${DB_STATEMENT_TIMEOUT_MS:?Set DB_STATEMENT_TIMEOUT_MS in .env}
SHUTDOWN_DRAIN_SECONDS: ${SHUTDOWN_DRAIN_SECONDS:?Set SHUTDOWN_DRAIN_SECONDS in .env}
GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS: ${GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS:?Set GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS in .env}
READINESS_TIMEOUT_SECONDS: ${READINESS_TIMEOUT_SECONDS:?Set READINESS_TIMEOUT_SECONDS in .env}
services:
postgres:
image: postgres:16.10-bookworm
restart: unless-stopped
# TODO(4.3): секреты через `secrets:` (POSTGRES_PASSWORD_FILE), а не env.
environment:
POSTGRES_USER: ${DB_USER}
POSTGRES_DB: ${DB_NAME}
POSTGRES_PASSWORD: ${DB_PASSWORD}
POSTGRES_USER: ${DB_USER:?Set DB_USER in .env}
POSTGRES_DB: ${DB_NAME:?Set DB_NAME in .env}
POSTGRES_PASSWORD_FILE: /run/secrets/db_password
secrets:
- db_password
volumes:
- pgdata:/var/lib/postgresql/data
# Порты наружу не публикуются; для локальных pytest см. compose.test.yaml.
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 5s
interval: 3s
timeout: 3s
retries: 10
# TODO(4.3): deploy.resources.limits (cpus / memory)
deploy:
resources:
limits:
cpus: "1.0"
memory: 512M
redis:
image: redis:7.4.2-bookworm
restart: unless-stopped
# TODO(4.3): пароль через secrets, а не в командной строке
command: ["redis-server", "/usr/local/etc/redis/redis.conf", "--requirepass", "${REDIS_PASSWORD}"]
environment:
REDISCLI_AUTH: ${REDIS_PASSWORD}
entrypoint: ["/bin/sh", "/usr/local/bin/start-redis.sh"]
secrets:
- redis_password
volumes:
- ./infra/redis/redis.conf:/usr/local/etc/redis/redis.conf:ro
- ./infra/redis/start-redis.sh:/usr/local/bin/start-redis.sh:ro
- redisdata:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 5s
test: ["CMD-SHELL", "REDISCLI_AUTH=\"$$(cat /run/secrets/redis_password)\" redis-cli ping"]
interval: 3s
timeout: 3s
retries: 10
# TODO(4.3): deploy.resources.limits
deploy:
resources:
limits:
cpus: "0.5"
memory: 512M
# Однократные миграции до старта реплик: api ждёт service_completed_successfully,
# поэтому реплики не устраивают гонку `alembic upgrade`.
# TODO(4.4): описать совместимость миграций с работающей версией (expand/contract).
migrate:
<<: *api-image
command: ["alembic", "upgrade", "head"]
env_file: .env
environment: *base-env
secrets:
- db_password
depends_on:
postgres:
condition: service_healthy
restart: "no"
healthcheck:
disable: true
deploy:
resources:
limits:
cpus: "0.5"
memory: 256M
api:
<<: *api-image
restart: unless-stopped
env_file: .env
environment:
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
# Не задавайте container_name и ports: несколько реплик одного service,
# доступ только через nginx.
<<: *base-env
REDIS_HOST: ${REDIS_HOST:?Set REDIS_HOST in .env}
REDIS_PORT: ${REDIS_PORT:?Set REDIS_PORT in .env}
REDIS_DB: ${REDIS_DB:?Set REDIS_DB in .env}
REDIS_MAX_CONNECTIONS: ${REDIS_MAX_CONNECTIONS:?Set REDIS_MAX_CONNECTIONS in .env}
REDIS_POOL_TIMEOUT_SECONDS: ${REDIS_POOL_TIMEOUT_SECONDS:?Set REDIS_POOL_TIMEOUT_SECONDS in .env}
REDIS_CONNECT_TIMEOUT_SECONDS: ${REDIS_CONNECT_TIMEOUT_SECONDS:?Set REDIS_CONNECT_TIMEOUT_SECONDS in .env}
REDIS_SOCKET_TIMEOUT_SECONDS: ${REDIS_SOCKET_TIMEOUT_SECONDS:?Set REDIS_SOCKET_TIMEOUT_SECONDS in .env}
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:?Set SESSION_TTL_SECONDS in .env}
IDEMPOTENCY_TTL_SECONDS: ${IDEMPOTENCY_TTL_SECONDS:?Set IDEMPOTENCY_TTL_SECONDS in .env}
secrets:
- db_password
- redis_password
deploy:
replicas: ${API_REPLICAS:-2}
# TODO(4.3): resources.limits: { cpus: "...", memory: "..." }
# TODO(4.1): healthcheck по /health/ready (interval/timeout/retries),
# согласованный с проверками nginx; сейчас действует HEALTHCHECK
# из Dockerfile по /health/live.
# TODO(4.1): stop_signal / stop_grace_period > drain + graceful timeout.
replicas: ${API_REPLICAS:?Set API_REPLICAS in .env}
resources:
limits:
cpus: "1.0"
memory: 512M
healthcheck:
test: ["CMD", "python", "-c", "import os, urllib.request; urllib.request.urlopen('http://127.0.0.1:' + os.environ['APP_PORT'] + '/health/ready', timeout=2.5)"]
interval: 3s
timeout: 3s
start_period: 10s
retries: 2
stop_signal: SIGTERM
stop_grace_period: 8s
depends_on:
postgres:
condition: service_healthy
@@ -84,8 +134,7 @@ services:
volumes:
- ./infra/nginx/nginx.conf:/etc/nginx/nginx.conf:ro
ports:
# Единственная публичная точка входа.
- "127.0.0.1:${LB_HOST_PORT:-8080}:8080"
- "127.0.0.1:${LB_HOST_PORT:?Set LB_HOST_PORT in .env}:8080"
healthcheck:
test: ["CMD", "wget", "-q", "-O", "/dev/null", "http://127.0.0.1:8080/lb-health"]
interval: 5s
@@ -94,12 +143,18 @@ services:
depends_on:
api:
condition: service_healthy
# TODO(4.3): deploy.resources.limits
deploy:
resources:
limits:
cpus: "0.5"
memory: 128M
volumes:
pgdata:
redisdata:
# TODO(4.3): secrets:
# db_password:
# file: ./secrets/db_password # каталог secrets/ в .gitignore
secrets:
db_password:
file: ./secrets/db_password
redis_password:
file: ./secrets/redis_password
+99 -3
View File
@@ -1,5 +1,101 @@
# Доказательства
# Доказательства лабораторной 3
Храните небольшие обезличенные результаты: команды и stdout проверок, JSON/CSV агрегатов нагрузки, EXPLAIN, dashboard JSON, текст разбора отказа. Укажите дату, commit, аппаратные лимиты и профиль нагрузки.
Прогон от 04.11.2026, автор: Григорян Илья Мурадович, БПИ2303. Цель — оценка 4.
Команды выполнялись на незакоммиченном рабочем дереве поверх commit
`f20b751207ed9948bfcdab829c458a4af122d611`, а не на чистом состоянии этого commit.
Состав исполняемого кода и конфигурации закреплён в [source-sha256.txt](source-sha256.txt).
Документация не включена в этот fingerprint; её подготовка продолжалась после тестов.
Не добавляйте .env, session tokens, cookies, приватные ключи, credentials, реальные сообщения, raw dumps и signed URLs. Для скриншотов скрывайте секреты. Большие логи/бинарные traces сохраняйте отдельно по правилам преподавателя; одного скриншота без методики недостаточно.
## Артефакты
| Файл | Содержание |
| --- | --- |
| [run.json](run.json) | Время прогона, базовый commit, версии Docker/Compose/Python, оборудование, параметры, лимиты и команды. |
| [test-output.txt](test-output.txt) | Реальный stdout/stderr полного `test-grade4`: 156 pytest, smoke, конкурентные повторы, persistence, failover, SIGTERM, rolling и остановка каждой реплики. Абсолютный путь checkout заменён на `<repository>`. |
| [nginx-output.txt](nginx-output.txt) | Реальный вывод отдельного `test-nginx`, включая gzip, ограничение частоты и DNS. |
| [metrics.json](metrics.json) | Машиночитаемые строки метрик и состояний реплик из полного вывода, без пересчёта чисел. |
| [source-sha256.txt](source-sha256.txt) | SHA-256 исходников, скриптов, тестов и конфигурации, использованных при запуске. Проверка: `sha256sum -c evidence/source-sha256.txt`. |
| [cleanup.txt](cleanup.txt) | Итоговая проверка удаления ресурсов лабораторной; conserver и его данные сохранены. |
Результаты относятся только к этому прогону и составу файлов. После изменения кода,
окружения или ресурсов их нужно получить заново. Ниже приведён способ повторения;
старые численные значения при новом запуске не обязаны совпасть.
## Как повторить
Нужны Docker, Compose и Python 3.12 с зависимостями проекта. Из корня:
```sh
test -f .env || cp .env.example .env
make prepare-secrets PYTHON=.venv/bin/python
make test-grade4 PYTHON=.venv/bin/python
make test-nginx PYTHON=.venv/bin/python
```
Существующий `.env` не заменяется. Пароли находятся в `secrets/`, а не в артефактах.
`test-grade4` создаёт отдельный проект `mtusi-messenger-lab3-test` с двумя API,
PostgreSQL, Redis, migrate и Nginx. Вход — localhost:18080, PostgreSQL:15432,
Redis:16379. Фактические параметры этого запуска перечислены в `run.json`.
В конце, включая ошибку, тестовые контейнеры, сеть и volumes удаляются.
## Что измерялось
1. Контракт и OpenAPI; 156 pytest с реальными PostgreSQL и Redis, включая реальный
restart Redis. Собственные тесты используют отдельную БД `<DB_NAME>_test`
и Redis DB 15; API стенда использует свою основную БД и Redis DB 0.
2. Публичный HTTP smoke, 24 одновременных повтора одного ключа восемью потоками
через Nginx, restart всех компонентов с сохранением volumes и существующей
сессии, публичный failover.
3. Проверка фактических Docker CPU/RAM, портов, read-only секретов и окружения.
Пароли не считываются в вывод inspect; аудит проверяет имена переменных/монтирований.
4. SIGTERM одной API: незавершённый POST удерживается PostgreSQL advisory lock,
сигнал отправляется процессу, проверяются ready=503/live=200/новая работа=503.
Через 1,2 с блокировка освобождается; исходный POST получает 201. Проверяются
выход без OOM/SIGKILL, бюджет <8 с и наличие сообщения в истории. API восстановлена.
5. Rolling: два клиента пишут в общий чат, timeout 2 с, пауза 80 мс после каждой
попытки, одна секунда до и после обновления. Новая метка `API_BUILD_REVISION`
даёт новый образ с прежним бизнес-кодом. Сборка одна, `alembic upgrade head`
вызван один раз без ожидающих новых миграций. Перед каждой остановкой проверяются
две другие здоровые API; в конце оба старых контейнера и образ API заменены.
6. Отказ каждой из двух актуальных API: два клиента, закрытый цикл без заданного
arrival rate, 2 с прогрева, остановка выбранной API с timeout 8 с, 10 с после
завершения hook. При ошибке пауза 100 мс, ключ сохраняется до успешного ответа.
Перед следующим отказом предыдущая API восстановлена и отвечает через LB.
Состояния `before`, `stopped`, `restored` записаны для каждой цели.
7. После обновления и отказов прочитана полная история: все подтверждённые ID
присутствуют, текстовые метки не дублируются. Nginx отдельно проверен временными
HTTP-backend без данных мессенджера, включая третью реплику через DNS без reload.
RPS rolling = успешные ответы запросов, начатых в интервале обновления / длительность
этого интервала. Его p95 относится к этим успешным запросам. Счётчик ошибок rolling
охватывает всё время работы двух клиентов, включая секунду до и после.
RPS failover = число успешных ответов / время от запуска клиентов до последнего
успешного завершения. Это ответы, а не обязательно число новых уникальных строк:
ответ на повтор ключа также считается успешным. `first_recovery_seconds` — время
от начала hook до первого завершения успешного POST, начатого после конца hook.
Показатель включает длительность команды остановки, а не только сетевой простой.
Ошибки разделены на `http_429` (ограничитель), `http_503` (временная недоступность),
`connection` и `contract`; в успешном прогоне последние две категории отсутствовали
в rolling и последовательном failover. Нельзя приписывать все ошибки отказу API:
профиль также достигает ограничителя Nginx 50 запросов/с с burst=100.
## Ресурсы и границы
| Контейнер | CPU | RAM |
| --- | ---: | ---: |
| PostgreSQL | 1 | 512 MiB |
| Redis | 0,5 | 512 MiB |
| API, каждый | 1 | 512 MiB |
| migrate | 0,5 | 256 MiB |
| Nginx | 0,5 | 128 MiB |
Обычно работают две API, при обновлении временно три. Пулы БД: 5 + 10 на API,
до 45 соединений на три API, не считая миграций и диагностики. Redis: AOF,
appendfsync always, maxmemory 256 MiB, noeviction. Нагрузка синтетическая, один
прогон на одном хосте. Это не поиск предельного RPS, не отказ хоста, диска или
хранилища и не доказательство совместимости произвольных будущих миграций.
В доказательства не включены `.env`, пароли, токены сессий, cookies, приватные
ключи, дампы БД и тела сообщений. При добавлении новых артефактов сохраняйте это
правило; большие логи и бинарные traces храните отдельно по правилам преподавателя.
+19
View File
@@ -0,0 +1,19 @@
Cleanup at 2026-11-04T14:08:42.159262+00:00
$ docker compose --env-file .env -p mtusi-messenger-lab3 -f compose.yaml down --volumes --remove-orphans
$ docker compose --env-file .env -p mtusi-messenger-lab3-test -f compose.yaml -f compose.test.yaml down --volumes --remove-orphans
Containers:
conserver: Exited (128) 4 weeks ago
Volumes:
test_conserver-logs
Images:
mtusi-messenger:lab3
conserver:latest
postgres:16.10-bookworm
nginx:1.28.0-alpine
redis:7.4.2-bookworm
Project containers and volumes: absent.
Existing .env and secrets/: preserved.
conserver and its volume: preserved.
Only main Compose images and conserver image retained.
+147
View File
@@ -0,0 +1,147 @@
[
{
"observed_instances_before": 2,
"successful_writes": 108,
"failed_attempts": 4,
"first_recovery_seconds": 1.845
},
{
"scenario": "rolling update",
"replacements": 2,
"migration_runs": 1,
"successful_writes": 456,
"failed_attempts": 13,
"errors_by_kind": {
"http_503": 13
},
"elapsed_seconds": 23.627,
"successful_rps": 19.3,
"p95_seconds": 0.043
},
{
"scenario": "replica_failure",
"phase": "before",
"target": "bcbb50630124",
"replicas": [
{
"instance": "bcbb50630124",
"running": true,
"health": "healthy"
},
{
"instance": "df18f4fb557f",
"running": true,
"health": "healthy"
}
]
},
{
"scenario": "replica_failure",
"phase": "stopped",
"target": "bcbb50630124",
"replicas": [
{
"instance": "bcbb50630124",
"running": false,
"health": "unhealthy"
},
{
"instance": "df18f4fb557f",
"running": true,
"health": "healthy"
}
]
},
{
"scenario": "replica_failure",
"phase": "restored",
"target": "bcbb50630124",
"replicas": [
{
"instance": "bcbb50630124",
"running": true,
"health": "healthy"
},
{
"instance": "df18f4fb557f",
"running": true,
"health": "healthy"
}
]
},
{
"instance": "bcbb50630124",
"successful_writes": 773,
"failed_attempts": 83,
"errors_by_kind": {
"http_429": 67,
"http_503": 16
},
"elapsed_seconds": 13.853,
"successful_rps": 55.8,
"first_recovery_seconds": 1.8
},
{
"scenario": "replica_failure",
"phase": "before",
"target": "df18f4fb557f",
"replicas": [
{
"instance": "bcbb50630124",
"running": true,
"health": "healthy"
},
{
"instance": "df18f4fb557f",
"running": true,
"health": "healthy"
}
]
},
{
"scenario": "replica_failure",
"phase": "stopped",
"target": "df18f4fb557f",
"replicas": [
{
"instance": "bcbb50630124",
"running": true,
"health": "healthy"
},
{
"instance": "df18f4fb557f",
"running": false,
"health": "unhealthy"
}
]
},
{
"scenario": "replica_failure",
"phase": "restored",
"target": "df18f4fb557f",
"replicas": [
{
"instance": "bcbb50630124",
"running": true,
"health": "healthy"
},
{
"instance": "df18f4fb557f",
"running": true,
"health": "healthy"
}
]
},
{
"instance": "df18f4fb557f",
"successful_writes": 773,
"failed_attempts": 116,
"errors_by_kind": {
"http_429": 99,
"http_503": 17
},
"elapsed_seconds": 13.875,
"successful_rps": 55.71,
"first_recovery_seconds": 1.782
}
]
+11
View File
@@ -0,0 +1,11 @@
.venv/bin/python scripts/check_nginx.py
nginx version: nginx/1.28.0
PASS: nginx -t и балансировка двух реплик
PASS: gzip 2060 → 61 байт, содержимое сохранено
PASS: JSON и заголовки ошибки API передаются без подмены
PASS: отправленный POST не повторяется на другой реплике
PASS: лимит вернул 391 ответов 429; health доступен
PASS: третья реплика обнаружена через DNS без reload nginx
PASS: отказ реплики, первое успешное чтение через 0.207 с
PASS: недоступность всех backend возвращает JSON 503
PASS: JSON access log содержит время backend и результат лимита
+149
View File
@@ -0,0 +1,149 @@
{
"started_at_utc": "2026-11-04T13:59:48.203542+00:00",
"base_commit": "f20b751207ed9948bfcdab829c458a4af122d611",
"worktree_dirty": true,
"source_manifest_sha256": "73187c6a987b4fce648f79198a89a99b238bc5aa0617339d662b09c86cb423cb",
"runtime_profile": {
"API_REPLICAS": "2",
"APP_PORT": "8080",
"LB_HOST_PORT": "8080",
"DB_HOST_PORT": "15432",
"REDIS_HOST_PORT": "16379",
"MAX_MESSAGES": "100000",
"MAX_IN_FLIGHT": "16",
"DB_POOL_SIZE": "5",
"DB_MAX_OVERFLOW": "10",
"DB_POOL_TIMEOUT_SECONDS": "3",
"DB_CONNECT_TIMEOUT_SECONDS": "3",
"DB_STATEMENT_TIMEOUT_MS": "5000",
"REDIS_MAX_CONNECTIONS": "20",
"REDIS_POOL_TIMEOUT_SECONDS": "1",
"REDIS_CONNECT_TIMEOUT_SECONDS": "1",
"REDIS_SOCKET_TIMEOUT_SECONDS": "0.5",
"SESSION_TTL_SECONDS": "3600",
"IDEMPOTENCY_TTL_SECONDS": "86400",
"SHUTDOWN_DRAIN_SECONDS": "1",
"GRACEFUL_SHUTDOWN_TIMEOUT_SECONDS": "5",
"READINESS_TIMEOUT_SECONDS": "2"
},
"commands": [
"make test-grade4 PYTHON=.venv/bin/python",
"make test-nginx PYTHON=.venv/bin/python"
],
"local_python": "Python 3.12.14",
"docker_compose": "5.6.1",
"docker_host": {
"server_version": "29.9.2",
"os": "linux",
"architecture": "x86_64",
"cpus": 8,
"memory_bytes": 16400363520,
"kernel": "7.2.11-zen1-1-zen"
},
"host_cpu_model": "Intel(R) Core(TM) i7-10510U CPU @ 1.80GHz",
"finished_at_utc": "2026-11-04T14:07:19.867546+00:00",
"results": {
"test_grade4_exit_code": 0,
"test_nginx_exit_code": 0,
"pytest_passed": 156,
"pytest_seconds": 42.3
},
"container_limits": {
"postgres": {
"cpus": 1,
"memory_mib": 512
},
"redis": {
"cpus": 0.5,
"memory_mib": 512
},
"api_each": {
"cpus": 1,
"memory_mib": 512
},
"migrate": {
"cpus": 0.5,
"memory_mib": 256
},
"nginx": {
"cpus": 0.5,
"memory_mib": 128
}
},
"test_profile": {
"project": "mtusi-messenger-lab3-test",
"compose_files": [
"compose.yaml",
"compose.test.yaml"
],
"lb_host_port": 18080,
"api_replicas": 2,
"test_postgres_port": 15432,
"test_redis_port": 16379,
"pytest_redis_db": 15,
"rolling": {
"clients": 2,
"timeout_seconds": 2,
"pause_after_attempt_seconds": 0.08,
"warmup_seconds": 1,
"after_update_seconds": 1,
"image_change": "API_BUILD_REVISION label; same business code",
"pending_migrations": false
},
"failover_each": {
"clients": 2,
"timeout_seconds": 2,
"warmup_seconds": 2,
"after_stop_hook_seconds": 10,
"error_backoff_seconds": 0.1,
"stop_timeout_seconds": 8
}
},
"installed_local_packages": {
"fastapi": "0.143.3",
"uvicorn": "0.54.0",
"pydantic": "2.14.1",
"pydantic-settings": "2.16.0",
"SQLAlchemy": "2.1.4",
"alembic": "1.20.0",
"asyncpg": "0.32.0",
"redis": "8.1.0",
"pytest": "9.1.1",
"pytest-asyncio": "1.4.1"
},
"images": [
{
"tag": "mtusi-messenger:lab3",
"id": "sha256:9eb260e40dd7704888aa66098ff9514a13da1dcb28afb46eb4c8b2bd75b1f413",
"repo_digests": [
"mtusi-messenger@sha256:9eb260e40dd7704888aa66098ff9514a13da1dcb28afb46eb4c8b2bd75b1f413"
],
"revision": "verification-81ccd2376178"
},
{
"tag": "postgres:16.10-bookworm",
"id": "sha256:38471f330eb885e04de130b768d6db4e10469e2311879c7e5c699f6d2d8a1c74",
"repo_digests": [
"postgres@sha256:38471f330eb885e04de130b768d6db4e10469e2311879c7e5c699f6d2d8a1c74"
],
"revision": null
},
{
"tag": "redis:7.4.2-bookworm",
"id": "sha256:fbdbaea47b9ae4ecc2082ecdb4e1cea81e32176ffb1dcf643d422ad07427e5d9",
"repo_digests": [
"redis@sha256:fbdbaea47b9ae4ecc2082ecdb4e1cea81e32176ffb1dcf643d422ad07427e5d9"
],
"revision": null
},
{
"tag": "nginx:1.28.0-alpine",
"id": "sha256:30f1c0d78e0ad60901648be663a710bdadf19e4c10ac6782c235200619158284",
"repo_digests": [
"nginx@sha256:30f1c0d78e0ad60901648be663a710bdadf19e4c10ac6782c235200619158284"
],
"revision": null
}
],
"manifest_scope": "Executable sources, tests and configuration; excludes documentation, .env and secrets."
}
+107
View File
@@ -0,0 +1,107 @@
ce3cd59eb07b3f3cfb85c19c9dfcba82aeca3b4231d523c6a2c85d28bf2b66f9 .env.example
2ea849842e877eca40e5dd853a5299a81be15fa414476fbfe434ac487f59ec1f Dockerfile
dd18f3dabac00cf562e2d4eec2615a3b7e37bb5343b47f1eb0f0fb49c2a11b7e Makefile
274785e9cfb1af978fcdf254f3b9c93847216d9183cf290098f857f174f43b41 alembic.ini
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/__init__.py
5839d94c506f0362278a4f85bca8346774f5f323112963dd3830e525a069fb61 app/__main__.py
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/core/__init__.py
f66f54d722c4bde445e402c5f80fc2c826dd02a35b49a7ef8e78183aae577e30 app/core/config.py
e9ae2ff773dfd0f3f0515b6fd29c8b23820cd1a3b83e2b99dccaca8f0ddf8a40 app/core/database.py
da4dcfda3dabeb595aa7b917d321e794074676fd258828c84be4322b917ac43c app/core/instance.py
aedcaa71c991f0147603bad32bbd105ebdc689cfc388d274e83ce693f32ba534 app/core/lifecycle.py
69056a1660683bc5086b558b38660c304650d261f760248499ace499031c7e4e app/core/redis.py
290d97e3551e1661feb04debc0272c9c91fe7636d1771de9e78055c64e23933c app/core/request_capacity.py
e1f3f08c65cf17ea24574682050e0435d5a5c22b7b2194ea40aad941716871b4 app/core/request_id.py
7717e9ea31415dd9803f14e6290e709bfb63aa38cb1524db9b04881cf2512256 app/core/security.py
6acb951afe3a628d9bd9ae25ab8c321b8debb0f481c745881a7af1f48e620c90 app/domain/__init__.py
d7026b518eb7f3f054a5aaa5307171db031718c0c70555d40c03e7aabc9f539d app/domain/auth.py
33f20c63c3fdcb491adb2153a147e822e0a16de4a5f634355a6d2db514aaa668 app/domain/chats.py
a2bc40d13dca0215bc817c8781038586827d8b5601dd916b18c0f472e28e17b3 app/domain/idempotency.py
f127324bf34b423b33dd0e446ab049740ee6364785b34a805556331b8e324c22 app/domain/messages.py
df9aa94fab247467fe5f6fa030bdf3e587b5749060f0c3d663f5bd3e57e8dfe9 app/domain/pagination.py
31ec7ba4c47ae6c31661eb8b4231efe9f561784c3bc0555c7d9b9bde804fe88f app/domain/users.py
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/endpoints/__init__.py
0cb1dded40038b80eafabcb288f43b1b7fcac1d8d41898e657eb9b62afaa2aab app/endpoints/auth.py
2fc7d2b4f155e1cdba6d02ac157b1c2d74932c930d6cba7ac93c0a811af1494a app/endpoints/chats.py
1980c53bce1e96c801bb0ad49c6d35957c07f3e50db1804475a67f07a7d96082 app/endpoints/dependencies.py
2e1606211c689a8959041433bcb4b70e4c5fd1647038fe391eb5435b9d07ddca app/endpoints/health.py
a6424660ce901defac67b5d66a882f8051a531328fc6d4aa998c407ca276c4e3 app/endpoints/messages.py
13fe05bec4b4b0a9e7a2f90756065bf97e257601b119a71465b24fc0144f3bf9 app/endpoints/users.py
e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855 app/errors/__init__.py
355a762e6dc81dd844671982a68d944fa10d9631ef91cd3afd9312f2cffb8ec2 app/errors/exceptions.py
5e5616f8bb0b1b3fdaaba69f2e9248de79ebd3c1d0d123c9c613aa106e691960 app/errors/handlers.py
21a24f61599534856d11c5ce574111ce8a1d395f06aef5618558c4e54afefbc0 app/main.py
116ec0d604cecd9306827761bfa2290a87dc99c6c5519bfd5b618f0de6d6dddf app/models/__init__.py
548f10800483dd91a4d321c3cef845f3f5b126169a50474bf846f78839fdb43e app/models/base.py
7076f06111aca1e3845a8515112fa1302da9bd331cf79c699259c91d3d23c9cf app/models/chat.py
dfb64d43bd519d06f09e479eab4bdd277f317fdb92e206fdedf0afbed1fe18ad app/models/chat_member.py
35eaa453501b48d178d7b17fd22314783386b64951cbb518b450698ba65219f8 app/models/counter.py
693039c889d92ebdb5ef3fc6833278f59b4aa88f802b4726b9c3bf441f83fb18 app/models/idempotency_key.py
9bbf725b6eae51e23e4fc71aea3dbc137d5a275b069e7e378351773297a7559f app/models/message.py
b5f1bbdc4370e2671427c8d7590aba58916b1981f225c4734d8bdeb944b1539a app/models/user.py
7c9d4ef216ed8b027ddfbad9746147cf0fed6463baf396b7244bd9b1b286e9ee app/schemas/__init__.py
9a3f14dc23e704d9fdce681ae7187a6b95638f9736711a8edef245fbbaea3eb6 app/schemas/base.py
2111aef9c942b34d02afa99da6d23a1d5ca0f6cfd75a1c0ebfb2ba85a29584b1 app/schemas/chat.py
defae263397458b7b7d1acdb3dfa2b774c00e5ec3981c8b098748d1586777fb6 app/schemas/message.py
617bcba33dcb01e4f66a50b5c425ebcbc1aef1c6148148f0eb862a7743bcf9b6 app/schemas/session.py
01fc238693c3686595cc910fadce6200e9753d0c4a0397ff327d8a0c937dc4df app/schemas/user.py
33296ca85924a22644fda573be072e5b810a284b939469580445925a85f0b5e9 app/storage/__init__.py
e479c8be1f56030fc4faaa74417fb959fb2c1f0c57f72974df8b538ff1209a7b app/storage/chats.py
2a9243ad419e7cc48ce0c6da13053df6773bea53a2342eb408cb3ebe2455f921 app/storage/idempotency.py
f196fc426771cc9a628d25f466113badd1de1f123e9b3adc3cff9dc96e49824d app/storage/messages.py
aeb6851a54d71051912ad588c47de3d5a3d92d518a0a198dbb3e283dd64837c7 app/storage/sessions.py
46a0562d557ac96bd49f9975ff25ac8cce7f7f803b8c280d1d0bf2463ebfdaec app/storage/types.py
f9dc7df7affda7144991944ff20a1ae5b372921b14fd391afa189d0e613dc45e app/storage/users.py
46f25ac85ff2a20a52cddf67b38c69f340bf007a355cd2e18c46e6aab9d22757 compose.test.yaml
2a40970440a7c3fcdcb621a00ba9e55b3d5cae4c8da8cf2b8bef3b70dc29f263 compose.yaml
d88506d8590ce549fd43dda7eea87f040dfff128af071f457b87e17df6282f5a infra/nginx/nginx.conf
9d4e7faeab76340dadda9916430048c32c849fb2bf02206653ea827e3304b666 infra/redis/redis.conf
0f6fe080f5f7cd1d77da5f8ee9989874e9617bd7f4830f90b91978a5bfb88056 infra/redis/start-redis.sh
37dce514d48aa4e021e063f6ebb8fb3e34275f6a76f51926d789802cad8dfa75 migrations/env.py
4ae6aee859bcbcdb238d4cb2fa35419503d7a1d5a3caaffd0f0d2e9e9dce2937 migrations/versions/49d2c947a3f1_add_idempotency_keys.py
cbe0b9e7584f26c0b859936a2584c147fe3f1ffaa9eb55c85ff753ecb10aa5a4 migrations/versions/abd273076068_add_counters.py
dd0e8073817e3a08bae19b17d4d502aa0dca0639f95d0b08caaf0e5dce16f302 migrations/versions/db06fd3126ff_create_initial_schema.py
92ce287c8eb0aa508e0efd4553650b4ebd2474d1987587d6467c26e316e6a547 pytest.ini
4cefdb67007caf026d1613be7c519c01b4c8343db7c4f4b618677e01cf113525 requirements-dev.txt
6f31c6f105a5774db02e970977bf2d26fbdba47dbb6e81836124816555d6d83f requirements.txt
599958169a2b3c35b72b9b27f54d1c156032b2fadf041cc0e905bd49e48d8c60 scripts/__init__.py
7c4402c2a6ab80d3b4676e1866d6ecc87b6daea14c080bcb9be9a7e8b959d671 scripts/check_contract.py
22befc4a28b1a08452c769d66106d0a5b7fabc4edca7d5be1657cdf72824d899 scripts/check_grade4.py
1ebdc8a4423305b6b972254e0b856b9381f7a5279aaa537a3c9d3cdb791adccf scripts/check_idempotency.py
c95f74ebfec55b047424d65ed201519a79cd3292b9067fcf6913f5ac1bf3ab0b scripts/check_nginx.py
0926fac2e73573a6e8b32c254bfc635132823aed9c4b429e91bf180e047bc32f scripts/deployment.py
4cf255992270adfdaa0a3fd304050ed858b7a49d9e3c8856337a310cf59f8596 scripts/expiry_demo.sh
21f2e3baa4d9615e0411edbecfbdc394d471b70b4f237d1e45557c9602b0ecad scripts/explain_history.py
af3422b5b039583980599765cea8315546a1a3de80671f78c7c205faa2bac65f scripts/failover_all.py
e06776d5e44eded34a7fc849ba4cabe955428cf9f924e077a48511656538e7b2 scripts/failure_demo.sh
a5dcd78d708a7d1e69d92f56cb97e0a0a4f69577aac530d8ee195cd293dfc0cc scripts/prepare_secrets.py
0328246ba75defbced992104e986fde973f63e3830d83251eced5953263e944b scripts/restart.example.sh
442cb99a2a32e91f6348b18e2729e777e4f14acf82ed8aa899abdd1bf19ca4cc scripts/restart.sh
60d48ba1c8050a79f8a3725a0ea7bba34dadba3bef0b86bd2d2e6a768e6ca7d5 scripts/rolling_update.py
1bcf34394520b89d95b7605ec56675be799eea920e83cfbba306d5dc0a6d9811 scripts/stop-one.example.sh
c78f3fee788c907764162069ee09e3bd043b3b3eb3823f5bbb8f84dd1ab5bed0 scripts/stop-one.sh
4e981acbfc10dac58817bf922d5896e996798551fedc1b2385130e1cddb13d54 scripts/validate_openapi.py
fa12e0945cc8d7b3fdfbf476fd6a140c0a8262bb6728a1fd360cac335922da61 student-tests/conftest.py
8c11a6fbc9003c2d92225bfc676edfffe416e70d8b6972a864cf6c5c0b64c95b student-tests/helpers.py
20cd1c8ea397fe558a9ded78723dd319cabe47f520a631375171c448a01b1de2 student-tests/test_auth.py
f57751337441fbc909549d553cd32e20d7f7918dc42f2000c15f9ba2706349a4 student-tests/test_chats.py
b9c2ed985bb2cf0261bfb928f0bcc2694c8980a5c55fea4c445d0ca410ca30c6 student-tests/test_concurrency.py
b8c9a1f7535318b946adff13b11ac2459622a1a9b23962f0981d0fc7793de0c9 student-tests/test_constraints.py
76b4fe648fd257eb603cfc06da76b59b783986f96a9b357bc87238210757ef34 student-tests/test_errors.py
045203d83f8ff50e48b8fad4328dba7f12de8adffebef597efadfd40c79ed5c1 student-tests/test_failures.py
2594b7bce03d36e6c32c1644e76f4d8f40e7099de6c687e13a74706e329bcefe student-tests/test_health.py
edaf79363adb942f9501d933deb86e39aed558f32c1a73188ae2d18d088378ae student-tests/test_history_plan.py
640a12067597a7e576d3db0fb6f9bbb14639a14d701f6a9b682ed97ad70cdf8e student-tests/test_idempotency.py
722951c437488d0c5d63839d418b2456c37a40c9e8dc55a52c7e8ea3a4066c3c student-tests/test_instance.py
e39e046d8fd85711682f43220cbeded8212f9870fb6475d32f946a56b7864332 student-tests/test_lifecycle.py
71e48fab2816753b213603bd977c9c1babb2b540596cd3401c1e62a6f538a3b5 student-tests/test_limits.py
cc040ae5ee2f196362fab4c7006711bf8d8c7f5e2f56acc8c74646ef2efb801d student-tests/test_messages.py
834077f0541a2a939adc726342fba70c0b7da4b54cd8715709685a3ad23cc16c student-tests/test_migrations.py
2c573efd6b0a6204a8bac483bb6e2594c565f2d32faa04ebc3540298eb02af2d student-tests/test_pagination.py
cb981f15ad186faa2e1f8b6aecb7766eed66378b6db9dfc496dd1d76afc94b1b student-tests/test_sessions.py
bf840d8dcb6094412b9e2947df4a0a3c3f32c5d80af9df19693ed5b52b9c8d6d student-tests/test_users.py
851376079a214a655f6343bbc3f34b0e57192d8f7d84c33eb4e0a79a22d6a1bb tests/__init__.py
8d50976fc7c7bbb81e88a152f613c61ab25eaf53dba33c6a9dfab19f868d546d tests/client.py
6d3511ea719c7a7e841083e73d435c86dcbfd9f4e5c2a07d62eb9614b01d9933 tests/load.py
1f96663a174b3978d24eff66f2741f5f8c9b788d3242261d37a972720c52788b tests/resilience.py
52ac38eb343ff7d43e7543588e1da58ca06c9fce74b2b0d0bf0e4982bc23c1db tests/smoke.py
+254
View File
@@ -0,0 +1,254 @@
make[1]: Entering directory '<repository>'
.venv/bin/python -m scripts.prepare_secrets
Готов файл secrets/db_password
Готов файл secrets/redis_password
.venv/bin/python scripts/check_contract.py
PASS: offline skeleton structure, local refs and Python syntax; application NOT tested.
.venv/bin/python scripts/validate_openapi.py
PASS: full OpenAPI 3.1 and JSON Schema validation; application NOT tested.
make[1]: Leaving directory '<repository>'
make[1]: Entering directory '<repository>'
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env up -d --build
Image mtusi-messenger:lab3 Building
Image mtusi-messenger:lab3 Building
#1 [internal] load local bake definitions
#1 reading from stdin 1.17kB done
#1 DONE 0.0s
#2 [migrate internal] load build definition from Dockerfile
#2 transferring dockerfile: 797B done
#2 DONE 0.0s
#3 [api internal] load metadata for docker.io/library/python:3.12.15-slim-bookworm
#3 DONE 1.6s
#4 [api internal] load .dockerignore
#4 transferring context: 196B done
#4 DONE 0.0s
#5 [migrate internal] load build context
#5 transferring context: 9.54kB done
#5 DONE 0.0s
#6 [api 1/8] FROM docker.io/library/python:3.12.15-slim-bookworm@sha256:6a0e06f5ba0b373d051aabd3fffb9b873f27f9a2a3a14bcbe37dee6f0e3bbc70
#6 resolve docker.io/library/python:3.12.15-slim-bookworm@sha256:6a0e06f5ba0b373d051aabd3fffb9b873f27f9a2a3a14bcbe37dee6f0e3bbc70 0.1s done
#6 resolve docker.io/library/python:3.12.15-slim-bookworm@sha256:6a0e06f5ba0b373d051aabd3fffb9b873f27f9a2a3a14bcbe37dee6f0e3bbc70 0.1s done
#6 DONE 0.1s
#7 [api 3/8] RUN useradd --system --uid 10001 --no-create-home appuser
#7 CACHED
#8 [api 2/8] WORKDIR /app
#8 CACHED
#9 [api 4/8] COPY requirements.txt .
#9 CACHED
#10 [api 5/8] RUN pip install -r requirements.txt
#10 CACHED
#11 [api 6/8] COPY alembic.ini ./
#11 CACHED
#12 [migrate 7/8] COPY migrations ./migrations
#12 CACHED
#13 [api 8/8] COPY app ./app
#13 DONE 0.1s
#14 [api] exporting to image
#14 exporting layers
#14 exporting layers 0.2s done
#14 exporting manifest sha256:a38b66c8e8c9b12b9eab37bd5b9001417df363c0db1c134dd9a886f1b1d38db0 0.1s done
#14 exporting config sha256:85fe2165395388f47b557b69d0bcd64f5ca03b55e357bdf82a61d574a1e9d0a1 0.1s done
#14 exporting attestation manifest sha256:2566fe78ad8b26cb5663b995fc409959a46564667f75ca05ca0a7f9f27b66cb9
#14 exporting attestation manifest sha256:2566fe78ad8b26cb5663b995fc409959a46564667f75ca05ca0a7f9f27b66cb9 0.1s done
#14 exporting manifest list sha256:435908277c9d70ce7fe230dc31513387f06f3db8988a195098d73696063f3019 0.0s done
#14 naming to docker.io/library/mtusi-messenger:lab3 0.0s done
#14 unpacking to docker.io/library/mtusi-messenger:lab3
#14 unpacking to docker.io/library/mtusi-messenger:lab3 0.1s done
#14 DONE 0.6s
#15 [migrate] exporting to image
#15 exporting layers 0.2s done
#15 exporting manifest sha256:31fea3178ed4db5e71fcf6539c49c1d989201a9a161da75e6c7cdd462f629b20 0.0s done
#15 exporting config sha256:9f951ee3892d23fe585ad14c06c3d35f7b7ad9c7c1b22f2552f60aa9737267f0 0.1s done
#15 exporting attestation manifest sha256:a9852058a36e506388255dc54e4ed346c65721e78d66eb74902a12a7f2805971 0.1s done
#15 exporting manifest list sha256:7e9d2b8b999e69f985a7f29c0e29d0189287c744dc76e9a2e1d761c4ebba33f2 0.0s done
#15 naming to docker.io/library/mtusi-messenger:lab3 0.0s done
#15 unpacking to docker.io/library/mtusi-messenger:lab3 0.1s done
#15 DONE 0.5s
#16 [migrate] resolving provenance for metadata file
#16 DONE 0.0s
#17 [api] resolving provenance for metadata file
#17 DONE 0.0s
Image mtusi-messenger:lab3 Built
Image mtusi-messenger:lab3 Built
Volume mtusi-messenger-lab3-test_pgdata Creating
Network mtusi-messenger-lab3-test_default Creating
Volume mtusi-messenger-lab3-test_pgdata Creating
Network mtusi-messenger-lab3-test_default Creating
Volume mtusi-messenger-lab3-test_redisdata Creating
Volume mtusi-messenger-lab3-test_redisdata Creating
Volume mtusi-messenger-lab3-test_pgdata Created
Volume mtusi-messenger-lab3-test_pgdata Created
Volume mtusi-messenger-lab3-test_redisdata Created
Volume mtusi-messenger-lab3-test_redisdata Created
Network mtusi-messenger-lab3-test_default Created
Network mtusi-messenger-lab3-test_default Created
Container mtusi-messenger-lab3-test-redis-1 Creating
Container mtusi-messenger-lab3-test-postgres-1 Creating
Container mtusi-messenger-lab3-test-redis-1 Created
Container mtusi-messenger-lab3-test-postgres-1 Created
Container mtusi-messenger-lab3-test-migrate-1 Creating
Container mtusi-messenger-lab3-test-migrate-1 Created
Container mtusi-messenger-lab3-test-api-2 Creating
Container mtusi-messenger-lab3-test-api-1 Creating
Container mtusi-messenger-lab3-test-api-1 Created
Container mtusi-messenger-lab3-test-api-2 Created
Container mtusi-messenger-lab3-test-nginx-1 Creating
Container mtusi-messenger-lab3-test-nginx-1 Created
Container mtusi-messenger-lab3-test-redis-1 Starting
Container mtusi-messenger-lab3-test-postgres-1 Starting
Container mtusi-messenger-lab3-test-redis-1 Started
Container mtusi-messenger-lab3-test-postgres-1 Started
Container mtusi-messenger-lab3-test-postgres-1 Waiting
Container mtusi-messenger-lab3-test-postgres-1 Healthy
Container mtusi-messenger-lab3-test-migrate-1 Starting
Container mtusi-messenger-lab3-test-migrate-1 Started
Container mtusi-messenger-lab3-test-redis-1 Waiting
Container mtusi-messenger-lab3-test-migrate-1 Waiting
Container mtusi-messenger-lab3-test-postgres-1 Waiting
Container mtusi-messenger-lab3-test-postgres-1 Healthy
Container mtusi-messenger-lab3-test-redis-1 Healthy
Container mtusi-messenger-lab3-test-migrate-1 Exited
Container mtusi-messenger-lab3-test-api-2 Starting
Container mtusi-messenger-lab3-test-api-2 Started
Container mtusi-messenger-lab3-test-api-1 Starting
Container mtusi-messenger-lab3-test-api-1 Started
Container mtusi-messenger-lab3-test-api-2 Waiting
Container mtusi-messenger-lab3-test-api-1 Waiting
Container mtusi-messenger-lab3-test-api-2 Healthy
Container mtusi-messenger-lab3-test-api-1 Healthy
Container mtusi-messenger-lab3-test-nginx-1 Starting
Container mtusi-messenger-lab3-test-nginx-1 Started
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env exec -T postgres sh -c 'createdb -U "$POSTGRES_USER" "$POSTGRES_DB"_test 2>&1 | grep -v "already exists"; true'
make[1]: Leaving directory '<repository>'
make[1]: Entering directory '<repository>'
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 DOCKER_TESTS=1 .venv/bin/python -m pytest -q
........................................................................ [ 46%]
........................................................................ [ 92%]
............ [100%]
156 passed in 42.30s
.venv/bin/python tests/smoke.py --base-url "http://localhost:18080"
PASS: lab3 public API scenario; infrastructure and grading evidence remain separate.
.venv/bin/python -m scripts.check_idempotency --base-url "http://localhost:18080"
PASS: 24 concurrent replays, 2 replicas, one message
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-messenger-lab3-test-api-1 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 54 seconds (healthy) 8080/tcp
mtusi-messenger-lab3-test-api-2 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 54 seconds (healthy) 8080/tcp
mtusi-messenger-lab3-test-nginx-1 nginx:1.28.0-alpine "/docker-entrypoint.…" nginx About a minute ago Up 48 seconds (healthy) 80/tcp, 127.0.0.1:18080->8080/tcp
mtusi-messenger-lab3-test-postgres-1 postgres:16.10-bookworm "docker-entrypoint.s…" postgres About a minute ago Up About a minute (healthy) 127.0.0.1:15432->5432/tcp
mtusi-messenger-lab3-test-redis-1 redis:7.4.2-bookworm "/bin/sh /usr/local/…" redis About a minute ago Up 6 seconds (healthy) 127.0.0.1:16379->6379/tcp
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 .venv/bin/python tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url "http://localhost:18080"
Executing explicit persistence hook; hook output suppressed to avoid leaking secrets.
PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence.
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-messenger-lab3-test-api-1 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 11 seconds (healthy) 8080/tcp
mtusi-messenger-lab3-test-api-2 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 11 seconds (healthy) 8080/tcp
mtusi-messenger-lab3-test-nginx-1 nginx:1.28.0-alpine "/docker-entrypoint.…" nginx About a minute ago Up 5 seconds (healthy) 80/tcp, 127.0.0.1:18080->8080/tcp
mtusi-messenger-lab3-test-postgres-1 postgres:16.10-bookworm "docker-entrypoint.s…" postgres About a minute ago Up 17 seconds (healthy) 127.0.0.1:15432->5432/tcp
mtusi-messenger-lab3-test-redis-1 redis:7.4.2-bookworm "/bin/sh /usr/local/…" redis About a minute ago Up 21 seconds (healthy) 127.0.0.1:16379->6379/tcp
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env ps
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-messenger-lab3-test-api-1 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 12 seconds (healthy) 8080/tcp
mtusi-messenger-lab3-test-api-2 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 12 seconds (healthy) 8080/tcp
mtusi-messenger-lab3-test-nginx-1 nginx:1.28.0-alpine "/docker-entrypoint.…" nginx About a minute ago Up 5 seconds (healthy) 80/tcp, 127.0.0.1:18080->8080/tcp
mtusi-messenger-lab3-test-postgres-1 postgres:16.10-bookworm "docker-entrypoint.s…" postgres About a minute ago Up 17 seconds (healthy) 127.0.0.1:15432->5432/tcp
mtusi-messenger-lab3-test-redis-1 redis:7.4.2-bookworm "/bin/sh /usr/local/…" redis About a minute ago Up 21 seconds (healthy) 127.0.0.1:16379->6379/tcp
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 .venv/bin/python tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url "http://localhost:18080"
Executing explicit failover hook; hook output suppressed to avoid leaking secrets.
{"observed_instances_before": 2, "successful_writes": 108, "failed_attempts": 4, "first_recovery_seconds": 1.845}
PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence.
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env ps -a api
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
mtusi-messenger-lab3-test-api-1 mtusi-messenger:lab3 "python -m app" api About a minute ago Exited (0) 13 seconds ago
mtusi-messenger-lab3-test-api-2 mtusi-messenger:lab3 "python -m app" api About a minute ago Up 28 seconds (healthy) 8080/tcp
COMPOSE_PROJECT_NAME=mtusi-messenger-lab3-test COMPOSE_FILE=compose.yaml:compose.test.yaml LB_HOST_PORT=18080 DB_HOST_PORT=15432 REDIS_HOST_PORT=16379 docker compose --env-file .env up -d --wait api
Container mtusi-messenger-lab3-test-api-2 Running
Container mtusi-messenger-lab3-test-postgres-1 Running
Container mtusi-messenger-lab3-test-redis-1 Running
Container mtusi-messenger-lab3-test-postgres-1 Waiting
Container mtusi-messenger-lab3-test-postgres-1 Healthy
Container mtusi-messenger-lab3-test-migrate-1 Starting
Container mtusi-messenger-lab3-test-migrate-1 Started
Container mtusi-messenger-lab3-test-migrate-1 Waiting
Container mtusi-messenger-lab3-test-postgres-1 Waiting
Container mtusi-messenger-lab3-test-redis-1 Waiting
Container mtusi-messenger-lab3-test-redis-1 Healthy
Container mtusi-messenger-lab3-test-postgres-1 Healthy
Container mtusi-messenger-lab3-test-migrate-1 Exited
Container mtusi-messenger-lab3-test-api-1 Starting
Container mtusi-messenger-lab3-test-api-1 Started
Container mtusi-messenger-lab3-test-redis-1 Waiting
Container mtusi-messenger-lab3-test-migrate-1 Waiting
Container mtusi-messenger-lab3-test-api-2 Waiting
Container mtusi-messenger-lab3-test-api-1 Waiting
Container mtusi-messenger-lab3-test-postgres-1 Waiting
Container mtusi-messenger-lab3-test-migrate-1 Exited
Container mtusi-messenger-lab3-test-redis-1 Healthy
Container mtusi-messenger-lab3-test-postgres-1 Healthy
Container mtusi-messenger-lab3-test-api-2 Healthy
Container mtusi-messenger-lab3-test-api-1 Healthy
make[1]: Leaving directory '<repository>'
PASS infrastructure: CPU/RAM, private API ports, scoped read-only file secrets, no environment passwords
PASS SIGTERM: readiness 503, live 200, new work 503, in-flight POST 201; exit in 2.145s
Сборка нового образа API
Однократное применение совместимых миграций
Заменена реплика 5955785d8b55
Заменена реплика 23feb43a87e9
Готово: 2 здоровых реплик нового образа
{"scenario": "rolling update", "replacements": 2, "migration_runs": 1, "successful_writes": 456, "failed_attempts": 13, "errors_by_kind": {"http_503": 13}, "elapsed_seconds": 23.627, "successful_rps": 19.3, "p95_seconds": 0.043}
{"scenario": "replica_failure", "phase": "before", "target": "bcbb50630124", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]}
{"scenario": "replica_failure", "phase": "stopped", "target": "bcbb50630124", "replicas": [{"instance": "bcbb50630124", "running": false, "health": "unhealthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]}
{"scenario": "replica_failure", "phase": "restored", "target": "bcbb50630124", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]}
{"instance": "bcbb50630124", "successful_writes": 773, "failed_attempts": 83, "errors_by_kind": {"http_429": 67, "http_503": 16}, "elapsed_seconds": 13.853, "successful_rps": 55.8, "first_recovery_seconds": 1.8}
{"scenario": "replica_failure", "phase": "before", "target": "df18f4fb557f", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]}
{"scenario": "replica_failure", "phase": "stopped", "target": "df18f4fb557f", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": false, "health": "unhealthy"}]}
{"scenario": "replica_failure", "phase": "restored", "target": "df18f4fb557f", "replicas": [{"instance": "bcbb50630124", "running": true, "health": "healthy"}, {"instance": "df18f4fb557f", "running": true, "health": "healthy"}]}
{"instance": "df18f4fb557f", "successful_writes": 773, "failed_attempts": 116, "errors_by_kind": {"http_429": 99, "http_503": 17}, "elapsed_seconds": 13.875, "successful_rps": 55.71, "first_recovery_seconds": 1.782}
PASS infrastructure: CPU/RAM, private API ports, scoped read-only file secrets, no environment passwords
Container mtusi-messenger-lab3-test-nginx-1 Stopping
Container mtusi-messenger-lab3-test-nginx-1 Stopped
Container mtusi-messenger-lab3-test-nginx-1 Removing
Container mtusi-messenger-lab3-test-nginx-1 Removed
Container mtusi-messenger-lab3-test-api-3 Stopping
Container mtusi-messenger-lab3-test-api-4 Stopping
Container mtusi-messenger-lab3-test-api-3 Stopped
Container mtusi-messenger-lab3-test-api-3 Removing
Container mtusi-messenger-lab3-test-api-3 Removed
Container mtusi-messenger-lab3-test-api-4 Stopped
Container mtusi-messenger-lab3-test-api-4 Removing
Container mtusi-messenger-lab3-test-api-4 Removed
Container mtusi-messenger-lab3-test-redis-1 Stopping
Container mtusi-messenger-lab3-test-migrate-1 Stopping
Container mtusi-messenger-lab3-test-migrate-1 Stopped
Container mtusi-messenger-lab3-test-migrate-1 Removing
Container mtusi-messenger-lab3-test-migrate-1 Removed
Container mtusi-messenger-lab3-test-postgres-1 Stopping
Container mtusi-messenger-lab3-test-redis-1 Stopped
Container mtusi-messenger-lab3-test-redis-1 Removing
Container mtusi-messenger-lab3-test-redis-1 Removed
Container mtusi-messenger-lab3-test-postgres-1 Stopped
Container mtusi-messenger-lab3-test-postgres-1 Removing
Container mtusi-messenger-lab3-test-postgres-1 Removed
Volume mtusi-messenger-lab3-test_redisdata Removing
Volume mtusi-messenger-lab3-test_pgdata Removing
Network mtusi-messenger-lab3-test_default Removing
Volume mtusi-messenger-lab3-test_pgdata Removed
Volume mtusi-messenger-lab3-test_redisdata Removed
Network mtusi-messenger-lab3-test_default Removed
+201 -4
View File
@@ -1,7 +1,204 @@
# Инфраструктура студента
# Инфраструктура проекта
Здесь разместите конфигурации выбранных сервисов; основную топологию — в корневом compose.yaml/stack.yaml. `compose.example.yaml` — только worksheet ролей и намеренно не запускается. `contracts/infrastructure.json` задаёт минимальные роли, не готовые образы/пароли.
Топология — [compose.yaml](../compose.yaml) и [тестовый override](../compose.test.yaml).
Запуск и результаты — [REPORT.md](../REPORT.md), объяснение изменений относительно
lab2 и терминов — [EXPLAIN.md](../EXPLAIN.md), ответы для защиты —
[DEFENCE.md](../DEFENCE.md). `compose.example.yaml` остаётся исходным worksheet задания.
В REPORT.md сопоставьте роль → service name → версия/digest → health/readiness → volume → сеть/порт → способ передачи credentials. Приведите bootstrap (schema, bucket, broker topology, а с lab6 provisioning) и безопасное повторение этих команд.
## Nginx в текущем решении
Приложение строится из исходников. Не используйте заранее существующий образ преподавательского сервера вместо своей реализации. Restart hook перезапускает все соответствующие stores с volumes; failover hook останавливает только заданную API-реплику.
Конфигурация — [nginx/nginx.conf](nginx/nginx.conf), образ — `nginx:1.28.0-alpine`
из `compose.yaml`. Клиент обращается к Nginx, тот распределяет запросы между
репликами `api`; данные и сессии остаются общими в PostgreSQL и Redis.
| Настройка | Значение и назначение |
| --- | --- |
| DNS | `127.0.0.11`, `valid=5s`, `resolver_timeout=1s`: обновление адресов сервиса `api` без reload Nginx. `resolve` работает с общей зоной `zone api_backend 64k`. |
| Балансировка | Round-robin, без закрепления клиента за репликой. |
| Проверки отказа | Пассивные: `max_fails=1`, `fail_timeout=5s`. Ошибка запроса временно исключает backend; Nginx сам не опрашивает `/health/ready`. |
| Соединения | HTTP/1.1, пустой `Connection`, кэш до 16 свободных соединений на worker с временем простоя до 4 с. Это не ограничитель одновременных запросов. |
| Тайм-ауты к API | Подключение 500 мс; отправка/чтение 10 с между операциями ввода-вывода. |
| Переключение | Не более двух попыток, окно начала следующей попытки 2 с; условия — ошибка соединения, тайм-аут, 502/503/504. Эти 2 с не являются общим ограничением длительности ответа. |
| Ограничение запросов | На IP, видимый Nginx: в среднем 50 запросов/с, `burst=100 nodelay` допускает всплеск без очереди. Состояние общее для worker-процессов одного Nginx; `/health/*` и `/lb-health` не ограничиваются. |
| Превышение лимита | JSON 429 `rate_limited`, `Retry-After: 1`, `X-Request-Id`, совпадающий с `error.request_id`. |
| Нет доступных backend | Собственная ошибка LB — JSON 503 `unavailable`, `Retry-After: 1` и `X-Request-Id`. У ответов LB нет `X-Instance-Id` реплики. |
| Ошибки приложения | JSON и заголовки API передаются без подмены, в том числе собственный 429 приложения. |
| Gzip | Для `application/json` от 1024 байт, уровень 3, при согласии клиента через `Accept-Encoding`; `Vary: Accept-Encoding` различает варианты ответа. Меньше переданных байт ценой вычислений на сжатие; ускорение нужно измерять. |
| Наблюдение | JSON access log в stdout: request id, статус, время, адрес/статус backend, id реплики и результат ограничения. Заголовок авторизации и тела запросов не журналируются; вместо полного URL записывается путь без query string. |
`non_idempotent` не включён: уже отправленный POST нельзя прозрачно повторять
для входа или создания чата. Повтор сообщения после неопределённого результата
выполняется клиентом с прежним `Idempotency-Key`; ключ и сообщение сохраняются
атомарно в PostgreSQL. Ошибка подключения до отправки допускает другую попытку.
Лимит Nginx действует по IP, а `MAX_IN_FLIGHT` приложения — по числу одновременных
запросов на реплику. Это разные ограничения. За NAT несколько клиентов могут
получать один бюджет; произвольный `X-Forwarded-For` не меняет ключ лимита.
При исследовании производительности учитывайте ответы 429 и заданный порог;
50 запросов/с — начальная настройка стенда, а не измеренная ёмкость системы.
Период DNS 5 с и пассивные проверки не задают универсального срока обнаружения
любого отказа. Например, подключение к молчащему адресу ограничено 500 мс, а
зависание уже установленного соединения — тайм-аутом чтения. Время восстановления
нужно измерять для выбранного отказа и нагрузки; проверка через Nginx входит
в `make test-grade4 PYTHON=.venv/bin/python`.
## Реализация уровня 4
Единый прогон: `make test-grade4 PYTHON=.venv/bin/python`. Он проверяет контракт,
pytest, публичные сценарии, SIGTERM, замену образа под записью и отказ каждой
реплики. Тестовый проект и его volumes удаляются при выходе. Выбор pytest:
`PYTEST_ARGS="student-tests/test_sessions.py"`. Реальный вывод и метаданные
сохранены в [evidence/](../evidence/README.md), таблица критериев — в [отчёте](../REPORT.md).
### Завершение и readiness
`GracefulServer` в `app/core/lifecycle.py` перехватывает первый SIGTERM/SIGINT:
переводит приложение в drain, ждёт `SHUTDOWN_DRAIN_SECONDS`, затем запускает
штатное завершение Uvicorn. Во время drain `/health/ready` и новые бизнес-запросы
получают 503; ранее принятые запросы продолжаются. `/health/live` остаётся 200.
Повторный сигнал пропускает оставшуюся drain-паузу.
Реализация рассчитана на установленный Uvicorn 0.54.0 и использует его
`Server.handle_exit`; при обновлении зависимости этот интерфейс нужно пересмотреть.
Профиль по умолчанию: drain 1 с, ожидание текущих запросов 5 с, Docker grace 8 с.
Настройки приложения требуют `drain + graceful < 8`. В прежнем `.env` следует
изменить `SHUTDOWN_DRAIN_SECONDS=0` на `1`, если он был скопирован из старого примера.
Команда остановки одной реплики использует такой же предел 8 с; требование
публичного hook завершиться за 10 с учитывается отдельно при последующей проверке.
Readiness одновременно проверяет PostgreSQL и Redis с общим бюджетом 2 с.
Python healthcheck ждёт до 2,5 с, Docker — до 3 с; проверки API выполняются каждые
3 с с двумя неудачами для unhealthy и стартовым периодом 10 с. После выхода из
стартового периода консервативная оценка перехода healthy → unhealthy составляет
`2 × (3 + 3) = 12 с`. Nginx не использует этот статус для маршрутизации: он исключает
backend по собственным пассивным проверкам. Для отказа установления соединения
тайм-аут одной попытки — 500 мс, для зависания чтения — 10 с между порциями данных.
Эти границы относятся к разным отказам, а не к единому времени восстановления.
### Ресурсы
| Контейнер | CPU | RAM |
| --- | --- | --- |
| postgres | 1 | 512 MiB |
| redis | 0,5 | 512 MiB |
| api, каждая реплика | 1 | 512 MiB |
| migrate | 0,5 | 256 MiB |
| nginx | 0,5 | 128 MiB |
У Nginx два worker-процесса. Пул вычисления Argon2 ограничен двумя задачами, чтобы
параллельный вход не расходовал память пропорционально числу CPU Docker-host.
Во время обновления временно работает `N + 1` API-реплик; необходимы свободные
ресурсы и запас соединений PostgreSQL. При стандартных пулах две реплики дают
до 30 соединений, три — до 45, не считая миграций и диагностики.
### Секреты
Перед первым запуском нового профиля:
```sh
make prepare-secrets PYTHON=.venv/bin/python
```
Скрипт создаёт отсутствующие `secrets/db_password` и `secrets/redis_password`.
Прежние значения из локального `.env` сохраняются; если их нет, генерируются
случайные пароли. Существующие секреты не перезаписываются, значения не выводятся.
Это не ротация пароля уже созданной БД. Каталог исключён из Git.
Compose монтирует файлы в `/run/secrets/`. PostgreSQL получает только пароль БД,
Redis — только свой пароль, API — оба, миграции — только пароль БД, Nginx — ни одного.
Все переменные Compose обязательны: значения задаются в `.env`, подстановок
по умолчанию нет; отсутствующая переменная останавливает запуск. Новые ключи
сверяйте с `.env.example`. Контейнерам передаются перечисленные несекретные настройки, весь `.env`
через `env_file` больше не передаётся. Порядок настроек приложения: явные параметры,
файлы секретов, окружение, локальный `.env`. На хосте также поддерживается `secrets/`.
В контейнерах API внутренний порт фиксирован на 8080, идентификатор берётся из
собственного HOSTNAME; общий `INSTANCE_ID` всем репликам из `.env` не передаётся.
Каталог создаётся с правами 0700, файлы — 0444: Compose использует bind-mount
файлов, и их должны читать UID приложения и служебные UID PostgreSQL/Redis.
Доступ других пользователей хоста ограничивает родительский каталог. Существующие
файлы также получают этот режим. Пароли не должны содержать крайние пробелы или
переносы строк. Локальные тесты Make читают те же файлы, сохраняя fallback старого `.env`.
Redis запускается через `infra/redis/start-redis.sh`: SHA-256 пароля записывается
во временный ACL-файл с правами 0600 для пользователя redis. В аргументах процесса
и конфигурации окружения контейнера пароль отсутствует. Healthcheck читает файл
только для вызова `redis-cli`. Настройка ACL совместима с Redis 7.4.
### Обновление и сценарии отказа
Первый переход со старого образа уровня 3 на файловые секреты выполняется через
`make up` с допустимым окном обслуживания: старый образ не умеет читать секреты
нового профиля и не годится для автоматического отката. После перехода образы
маркируются `io.mtusi.messenger.secrets=file-v1`.
```sh
make rolling-update PYTHON=.venv/bin/python
make failover-all PYTHON=.venv/bin/python
```
Rolling update собирает API один раз, однократно применяет миграции, затем
для каждой старой реплики добавляет одну новую, ждёт healthy и наблюдения её ID
через Nginx, останавливает и удаляет старую. Число реплик возвращается к исходному.
При неизменившемся образе замена пропускается. При неудаче сценарий пытается
восстановить исходный образ через пересоздание API без отката БД; аварийный откат
может вызвать перерыв. Неиспользуемый прежний образ удаляется после успеха, если
у него нет других тегов и контейнеров.
Миграции при работающих старых репликах должны только расширять схему. Текущие
миграции добавляют таблицы и совместимы с прежним API; удаление или переименование
используемых полей требует отдельного перехода. Совместимость произвольной будущей
миграции сценарий автоматически не доказывает. Откат образа не отменяет миграцию.
`failover-all` проверяет каждую реплику под записью:
останавливает одну выбранную API, сохраняет ключ при неопределённом POST,
восстанавливает её до следующей, проверяет подтверждённые сообщения и выводит
RPS, ошибки и время восстановления в stdout. По умолчанию два клиента, 2 с прогрева
и 15 с после остановки. Лимит Nginx 50 запросов/с влияет на профиль нагрузки.
После ошибок применяется пауза 100 мс; нагрузка использует закрытый цикл и не
является доказательством максимальной пропускной способности. Для обычного профиля
срок сессии должен быть не менее 300 с. Результаты в файлы не записываются.
Оба сценария используют общую блокировку проекта, чтобы не выполняться одновременно.
Ручные команды изменения Docker/Compose во время сценария выполнять не следует.
Интеграционная проверка обновления меняет метку `API_BUILD_REVISION`, получая
другой ID образа без изменения бизнес-кода, и проверяет замену обоих контейнеров,
наличие здоровых реплик перед остановкой, однократный запуск миграций и сохранность
записей. Это проверка механизма обновления; произвольные будущие изменения API
и схемы требуют собственных проверок совместимости. Для повторения только
обновления и отказов на готовом тестовом проекте используется
`python -m scripts.check_grade4 --base-url http://localhost:18080 --phase update-and-failover`
с теми же `COMPOSE_FILE` и `COMPOSE_PROJECT_NAME`, что у тестового стенда.
Конкурентный сценарий сообщений использует локальный `tests/client.py`, а не
внешний пакет `client`. Запуск из корня — `python -m scripts.check_idempotency`
с параметром `--base-url`; цель Make уже использует этот способ запуска.
## Проверка Nginx без данных мессенджера
```sh
make test-nginx PYTHON=.venv/bin/python
```
Нужны Docker Compose и локальный образ `nginx:1.28.0-alpine`. Скрипт
`scripts/check_nginx.py` создаёт отдельный проект с уникальным именем, случайным
локальным портом и тестовыми HTTP-backend на том же образе; `.env` приложения,
PostgreSQL и Redis не используются. Образы автоматически не скачиваются.
Тестовые контейнеры и сеть удаляются в конце, volumes не создаются.
Проверяются `nginx -t`, две реплики и добавление третьей через DNS без reload,
gzip с проверкой исходных байт, лимит 429 и исключение health, передача ошибки API,
отсутствие повторной отправки POST, чтение после остановки backend, JSON 503 при
отказе всех backend и формат access log. Сценарий не доказывает сохранность
сообщений, общую идемпотентность и мягкое завершение реального API — для них нужны
публичные и собственные проверки приложения.
Для уже запущенного основного стенда синтаксис можно проверить командой
`docker compose --env-file .env exec -T nginx nginx -t`; после проверки изменение
применяется через `docker compose --env-file .env exec -T nginx nginx -s reload`.
Источники директив: [upstream/DNS](https://nginx.org/en/docs/http/ngx_http_upstream_module.html),
[proxy/timeouts/retry](https://nginx.org/en/docs/http/ngx_http_proxy_module.html),
[limit_req](https://nginx.org/en/docs/http/ngx_http_limit_req_module.html),
[gzip](https://nginx.org/en/docs/http/ngx_http_gzip_module.html).
+90 -28
View File
@@ -1,34 +1,85 @@
# nginx как единая точка входа перед репликами api.
# Сейчас — минимальный рабочий round-robin; доработки помечены TODO.
# Единая точка входа: round-robin между API-репликами, без sticky sessions.
# Директивы рассчитаны на закреплённый nginx:1.28.0-alpine.
worker_processes auto;
worker_processes 2;
events {
worker_connections 1024;
}
http {
access_log /dev/stdout;
error_log /dev/stderr warn;
# В логе используем request_id ответа API, для собственных ошибок — id nginx.
map $upstream_http_x_request_id $response_request_id {
"" $request_id;
default $upstream_http_x_request_id;
}
# TODO(3.3): DNS-обновление адресов backend.
# Сейчас `server api:8080` резолвится ОДИН раз при старте nginx: если
# реплику пересоздали с новым IP или увеличили число реплик, nginx об этом
# не узнает. Варианты:
# resolver 127.0.0.11 valid=5s ipv6=off; # встроенный DNS Docker
# upstream api_backend { zone api_backend 64k; server api:8080 resolve; }
# (параметр `resolve` в open-source nginx доступен с 1.27.3).
log_format requests escape=json
'{"time":"$time_iso8601","request_id":"$response_request_id",'
'"method":"$request_method","uri":"$uri","status":$status,'
'"bytes":$body_bytes_sent,"request_time":$request_time,'
'"upstream":"$upstream_addr","upstream_status":"$upstream_status",'
'"upstream_time":"$upstream_response_time",'
'"instance_id":"$upstream_http_x_instance_id",'
'"limit_status":"$limit_req_status"}';
access_log /dev/stdout requests;
error_log /dev/stderr warn;
server_tokens off;
# DNS Docker возвращает адреса всех реплик сервиса api.
resolver 127.0.0.11 valid=5s ipv6=off;
resolver_timeout 1s;
# Общий для worker-процессов лимит на IP, который видит nginx.
# Клиентский X-Forwarded-For не используется в качестве ключа лимита.
limit_req_zone $binary_remote_addr zone=per_client:10m rate=50r/s;
gzip on;
gzip_vary on;
gzip_min_length 1024;
gzip_comp_level 3;
gzip_types application/json;
upstream api_backend {
server api:8080;
# TODO(4.1): пассивные проверки: max_fails=... fail_timeout=...
# (активных health checks в open-source nginx нет — это nginx Plus).
# TODO(4.1): keepalive N; + proxy_http_version 1.1 и пустой Connection.
zone api_backend 64k;
server api:8080 resolve max_fails=1 fail_timeout=5s;
# Кэш свободных соединений на worker, а не лимит запросов к API.
keepalive 16;
keepalive_timeout 4s;
}
server {
listen 8080;
client_header_timeout 10s;
client_body_timeout 10s;
send_timeout 10s;
keepalive_timeout 30s;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 500ms;
proxy_send_timeout 10s;
proxy_read_timeout 10s;
# Пассивное обнаружение отказов; Docker healthcheck сам не управляет LB.
# non_idempotent не включён: уже отправленные POST не повторяем.
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
# Окно перехода на другой backend, не общий deadline ответа.
proxy_next_upstream_timeout 2s;
# JSON и заголовки ошибок API передаются без подмены.
proxy_intercept_errors off;
error_page 429 = @rate_limited;
error_page 502 503 504 = @unavailable;
# Проверка самого LB для healthcheck в compose; не проксируется в API.
location = /lb-health {
access_log off;
@@ -36,20 +87,31 @@ http {
return 200 "ok\n";
}
location / {
# Проверки готовности/жизни не расходуют бюджет бизнес-запросов.
location /health/ {
proxy_pass http://api_backend;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
# TODO(4.1): таймауты, согласованные с API и тестами:
# proxy_connect_timeout ...; proxy_send_timeout ...; proxy_read_timeout ...;
# TODO(4.1): переключение на другой backend при отказе:
# proxy_next_upstream error timeout http_502 http_503 ...;
# proxy_next_upstream_tries ...; proxy_next_upstream_timeout ...;
# Внимание: POST nginx по умолчанию НЕ повторяет после отправки
# запроса (non_idempotent). Подумайте, безопасно ли добавлять
# non_idempotent при наличии Idempotency-Key.
# Не используйте ip_hash/sticky как "лечение" раздельного состояния.
location / {
limit_req zone=per_client burst=100 nodelay;
limit_req_status 429;
limit_req_log_level warn;
proxy_pass http://api_backend;
}
# Это ответы балансировщика: X-Instance-Id реплики у них отсутствует.
location @rate_limited {
default_type application/json;
add_header X-Request-Id $request_id always;
add_header Retry-After 1 always;
return 429 '{"error":{"code":"rate_limited","message":"Request rate exceeded","request_id":"$request_id"}}';
}
location @unavailable {
default_type application/json;
add_header X-Request-Id $request_id always;
add_header Retry-After 1 always;
return 503 '{"error":{"code":"unavailable","message":"API temporarily unavailable","request_id":"$request_id"}}';
}
}
}
+10
View File
@@ -0,0 +1,10 @@
#!/bin/sh
set -eu
password_hash=$(tr -d '\r\n' </run/secrets/redis_password | sha256sum | cut -d ' ' -f 1)
mkdir -p /run/redis
umask 077
printf 'user default reset on #%s ~* &* +@all\n' "$password_hash" >/run/redis/users.acl
chown redis:redis /run/redis/users.acl
chmod 600 /run/redis/users.acl
exec /usr/local/bin/docker-entrypoint.sh redis-server /usr/local/etc/redis/redis.conf --aclfile /run/redis/users.acl
@@ -0,0 +1,43 @@
"""Добавляет результаты идемпотентных запросов."""
from alembic import op
import sqlalchemy as sa
revision = "49d2c947a3f1"
down_revision = "abd273076068"
branch_labels = None
depends_on = None
def upgrade() -> None:
"""Создаёт таблицу ключей без изменения существующих данных."""
op.create_table(
"idempotency_keys",
sa.Column("user_id", sa.UUID(), nullable=False),
sa.Column("method", sa.String(8), nullable=False),
sa.Column("path", sa.String(255), nullable=False),
sa.Column("key", sa.String(128), nullable=False),
sa.Column("request_hash", sa.String(64), nullable=False),
sa.Column("message_id", sa.UUID(), nullable=False),
sa.Column(
"created_at", sa.DateTime(timezone=True),
server_default=sa.text("clock_timestamp()"), nullable=False,
),
sa.ForeignKeyConstraint(
["user_id"], ["users.id"], name=op.f("fk_idempotency_keys_user_id_users")
),
sa.ForeignKeyConstraint(
["message_id"], ["messages.id"],
name=op.f("fk_idempotency_keys_message_id_messages"),
),
sa.PrimaryKeyConstraint(
"user_id", "method", "path", "key", name=op.f("pk_idempotency_keys")
),
)
op.create_index("ix_idempotency_keys_created_at", "idempotency_keys", ["created_at"])
def downgrade() -> None:
"""Удаляет таблицу результатов запросов."""
op.drop_index("ix_idempotency_keys_created_at", table_name="idempotency_keys")
op.drop_table("idempotency_keys")
+1
View File
@@ -0,0 +1 @@
"""Команды управления учебным стендом."""
+348
View File
@@ -0,0 +1,348 @@
"""Проверяет инфраструктуру, SIGTERM и обновление реального стенда."""
import asyncio
from collections import Counter
from concurrent.futures import ThreadPoolExecutor
import hashlib
import json
from pathlib import Path
import subprocess
from threading import Event
import time
from uuid import uuid4
import asyncpg
from scripts.deployment import ComposeProject, ROOT, deployment_lock
from scripts.failover_all import exercise, failure_kind, history
from scripts.rolling_update import update
from tests.client import Client, Failure, arguments, check, run
PROBE = """import json, sys, urllib.request, urllib.error
payload = json.load(sys.stdin)
results = []
for item in payload:
data = json.dumps(item['body']).encode() if 'body' in item else None
request = urllib.request.Request(item['url'], data=data, headers=item.get('headers', {}), method=item.get('method', 'GET'))
try:
response = urllib.request.urlopen(request, timeout=7)
except urllib.error.HTTPError as error:
response = error
with response:
results.append({'status': response.status, 'body': json.loads(response.read())})
print(json.dumps(results))
"""
def probe(project, runner, requests):
"""Обращается к внутреннему API, передавая токен только через stdin."""
result = subprocess.run(
["docker", "exec", "-i", runner, "python", "-c", PROBE],
input=json.dumps(requests),
text=True,
capture_output=True,
timeout=10,
)
check(result.returncode == 0, "internal HTTP probe failed")
return json.loads(result.stdout)
def audit(project):
"""Проверяет фактические лимиты, порты и область доступа к секретам."""
allowed = {
"postgres": {"db_password"},
"redis": {"redis_password"},
"migrate": {"db_password"},
"api": {"db_password", "redis_password"},
"nginx": set(),
}
ids = project.run("ps", "--all", "--quiet").splitlines()
containers = json.loads(project.docker("inspect", *ids))
for item in containers:
service = item["Config"]["Labels"]["com.docker.compose.service"]
check(service in allowed, "unexpected service")
host = item["HostConfig"]
check(
host["Memory"] > 0 and host["NanoCpus"] > 0,
service + ": missing CPU/RAM limit",
)
env_names = {entry.split("=", 1)[0] for entry in item["Config"]["Env"]}
check(
not env_names
& {
"DB_PASSWORD",
"REDIS_PASSWORD",
"POSTGRES_PASSWORD",
"REDISCLI_AUTH",
"DATABASE_URL",
},
service + ": password in environment",
)
secrets = {
Path(mount["Destination"]).name
for mount in item["Mounts"]
if mount["Destination"].startswith("/run/secrets/")
}
check(secrets == allowed[service], service + ": incorrect secret scope")
if service == "api":
check(not host["PortBindings"], "API publishes ports")
for mount in item["Mounts"]:
if mount["Destination"].startswith("/run/secrets/"):
check(not mount["RW"], "writable secret mount")
check(
"container_name" not in project.config["services"][service],
"fixed container name",
)
check(
len(containers) == 6,
"expected PostgreSQL, Redis, migrate, Nginx and two API replicas",
)
print(
"PASS infrastructure: CPU/RAM, private API ports, scoped read-only file secrets, no environment passwords",
flush=True,
)
async def graceful(project, base_url):
"""Удерживает реальный POST в БД и завершает его после SIGTERM."""
replicas = project.replicas()
target, runner = replicas[:2]
client = Client(base_url)
actor, _, _, chat = await asyncio.to_thread(client.bootstrap)
path = f"/api/v1/chats/{chat['id']}/messages"
key = uuid4().hex
raw = json.dumps([actor["id"], "POST", path, key]).encode()
lock_id = int.from_bytes(hashlib.sha256(raw).digest()[:8], signed=True)
database = project.config["services"]["postgres"]
env = database["environment"]
conn = await asyncpg.connect(
host="127.0.0.1",
port=int(database["ports"][0]["published"]),
database=env["POSTGRES_DB"],
user=env["POSTGRES_USER"],
password=(ROOT / "secrets/db_password").read_text().strip(),
timeout=3,
)
address = project.docker(
"inspect",
"--format",
"{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}",
target.id,
)
port = project.config["services"]["api"]["environment"]["APP_PORT"]
direct = f"http://{address}:{port}"
started = time.monotonic()
task = None
try:
async with conn.transaction():
await conn.execute("SELECT pg_advisory_xact_lock($1)", lock_id)
task = asyncio.create_task(
asyncio.to_thread(
probe,
project,
runner.id,
[
{
"url": direct + path,
"method": "POST",
"body": {"text": "graceful-" + key},
"headers": {
"Authorization": "Bearer " + actor["token"],
"Idempotency-Key": key,
"Content-Type": "application/json",
},
}
],
)
)
deadline = time.monotonic() + 3
while not await conn.fetchval(
"SELECT EXISTS(SELECT 1 FROM pg_stat_activity WHERE wait_event = 'advisory' AND datname = current_database())"
):
check(time.monotonic() < deadline, "POST did not reach database lock")
await asyncio.sleep(0.02)
started = time.monotonic()
await asyncio.to_thread(
project.docker, "kill", "--signal", "SIGTERM", target.id
)
results = await asyncio.to_thread(
probe,
project,
runner.id,
[
{"url": direct + "/health/ready"},
{"url": direct + "/health/live"},
{"url": direct + "/api/v1/users/me"},
],
)
check(
[item["status"] for item in results] == [503, 200, 503],
"incorrect drain readiness/liveness/new work",
)
await asyncio.sleep(max(0, 1.2 - (time.monotonic() - started)))
result = (await task)[0]
check(result["status"] == 201, "in-flight POST failed during SIGTERM")
await asyncio.to_thread(project.docker, "wait", target.id, timeout=10)
state = json.loads(
project.docker("inspect", "--format", "{{json .State}}", target.id)
)
check(
not state["OOMKilled"] and state["ExitCode"] != 137,
"forced shutdown instead of graceful completion",
)
check(time.monotonic() - started < 8, "shutdown exceeded Docker grace budget")
items = await asyncio.to_thread(history, client, actor, chat)
check(
result["body"]["id"] in {item["id"] for item in items},
"acknowledged in-flight message lost",
)
print(
f"PASS SIGTERM: readiness 503, live 200, new work 503, in-flight POST 201; exit in {time.monotonic() - started:.3f}s",
flush=True,
)
finally:
await conn.close()
if task:
await asyncio.gather(task, return_exceptions=True)
if any(item.id == target.id and item.running for item in project.replicas()):
await asyncio.to_thread(project.docker, "stop", target.id)
await asyncio.to_thread(project.docker, "start", target.id)
await asyncio.to_thread(project.wait_healthy, {item.id for item in replicas})
await asyncio.to_thread(project.wait_routed, target.instance_id, base_url)
class ObservedProject(ComposeProject):
"""Подсчитывает миграции и проверяет готовность перед заменой."""
def __init__(self):
self.migrations = 0
self.replacements = 0
self.replacement_started = []
super().__init__()
def run(self, *args, **kwargs):
if args[:6] == ("run", "--rm", "--no-deps", "--pull", "never", "migrate"):
self.migrations += 1
return super().run(*args, **kwargs)
def docker(self, *args, **kwargs):
if args[0] == "stop":
healthy = [
item
for item in self.replicas()
if item.id != args[1] and item.running and item.health == "healthy"
]
check(len(healthy) >= 2, "rolling update reduces healthy capacity")
self.replacements += 1
self.replacement_started.append(time.monotonic())
return super().docker(*args, **kwargs)
def rolling(base_url):
"""Заменяет образ под постоянной записью с проверкой сохранности."""
project = ObservedProject()
before = project.replicas()
client = Client(base_url)
actor, _, _, chat = client.bootstrap()
stop = Event()
results, errors = [], []
def worker():
local = Client(base_url, timeout=2)
key = uuid4().hex
while not stop.is_set():
started = time.monotonic()
try:
result = local.message(actor, chat, "rolling-" + key, key=key)
results.append(
(started, time.monotonic(), result["json"]["id"], result["elapsed"])
)
key = uuid4().hex
except Failure as error:
errors.append(failure_kind(error))
stop.wait(0.08)
with ThreadPoolExecutor(max_workers=2) as pool:
jobs = [pool.submit(worker) for _ in range(2)]
try:
time.sleep(1)
started = time.monotonic()
update(project, base_url, revision="verification-" + uuid4().hex[:12])
finished = time.monotonic()
time.sleep(1)
finally:
stop.set()
for job in jobs:
job.result(timeout=5)
after = project.replicas()
check(
project.migrations == 1 and project.replacements == len(before),
"migration/replacement count incorrect",
)
check(
{item.image for item in before}.isdisjoint({item.image for item in after}),
"new image was not deployed",
)
check(
{item.id for item in before}.isdisjoint({item.id for item in after}),
"old containers remain",
)
writes = [row for row in results if started <= row[0] <= finished]
check(bool(writes), "no writes during update")
check(
any(project.replacement_started[0] <= row[0] <= finished for row in writes),
"no writes during container replacement",
)
items = history(client, actor, chat)
check(
{row[2] for row in results} <= {item["id"] for item in items},
"rolling update lost confirmed messages",
)
check(
len(items) == len({item["text"] for item in items}),
"rolling update created duplicate messages",
)
latencies = sorted(row[3] for row in writes)
print(
json.dumps(
{
"scenario": "rolling update",
"replacements": project.replacements,
"migration_runs": project.migrations,
"successful_writes": len(writes),
"failed_attempts": len(errors),
"errors_by_kind": dict(Counter(errors)),
"elapsed_seconds": round(finished - started, 3),
"successful_rps": round(len(writes) / (finished - started), 3),
"p95_seconds": round(
latencies[min(len(latencies) - 1, int(len(latencies) * 0.95))], 3
),
}
),
flush=True,
)
def main():
"""Выполняет проверки только на отдельном тестовом проекте."""
def configure(parser):
parser.add_argument(
"--phase", choices=("all", "update-and-failover"), default="all"
)
args = arguments("Grade 4 integration checks", configure)
project = ComposeProject()
check(project.name.endswith("-test"), "use isolated test Compose project")
with deployment_lock(project):
audit(project)
if args.phase == "all":
asyncio.run(graceful(project, args.base_url))
rolling(args.base_url)
args.duration, args.concurrency = 10, 2
exercise(project, args)
audit(project)
if __name__ == "__main__":
run(main)
+39
View File
@@ -0,0 +1,39 @@
"""Проверяет конкурентные повторы через балансировщик."""
from concurrent.futures import ThreadPoolExecutor
from uuid import uuid4
from tests.client import Client, arguments, check, run
def main() -> None:
"""Отправляет один ключ параллельно через разные реплики."""
args = arguments("Concurrent idempotency through load balancer")
client = Client(args.base_url, args.ca_file)
alice, _, _, chat = client.bootstrap()
key = uuid4().hex
body = "parallel-" + key
def send(_):
return Client(args.base_url, args.ca_file).message(alice, chat, body, key=key)
with ThreadPoolExecutor(max_workers=8) as pool:
results = list(pool.map(send, range(24)))
ids = {result["json"]["id"] for result in results}
replicas = {result["headers"]["X-Instance-Id"] for result in results}
check(len(ids) == 1, "parallel retries created duplicate messages")
check(len(replicas) >= 2, "parallel retries did not reach two API replicas")
history = client.call(
"GET",
f"/api/v1/chats/{chat['id']}/messages?limit=100",
actor=alice,
schema="MessagePage",
)["json"]["items"]
check(
len(history) == 1 and history[0] == results[0]["json"], "history has duplicates"
)
print(f"PASS: 24 concurrent replays, {len(replicas)} replicas, one message")
if __name__ == "__main__":
run(main)
+261
View File
@@ -0,0 +1,261 @@
#!/usr/bin/env python3
"""Проверки реального nginx в отдельном Compose-проекте без БД и приложения."""
from concurrent.futures import ThreadPoolExecutor
import gzip
import json
from pathlib import Path
import subprocess
import tempfile
import time
from urllib.error import HTTPError, URLError
from urllib.request import Request, urlopen
from uuid import uuid4
ROOT = Path(__file__).resolve().parents[1]
IMAGE = "nginx:1.28.0-alpine"
PAYLOAD = json.dumps({"text": "message " * 256}).encode()
def check(condition: bool, message: str) -> None:
if not condition:
raise AssertionError(message)
class Stand:
def __init__(self, directory: str) -> None:
self.directory = Path(directory)
self.project = "mtusi-lab3-nginx-check-" + uuid4().hex[:12]
self.base_url = ""
backend = self.directory / "backend.conf"
backend.write_text(
"worker_processes 1;\n"
"events { worker_connections 1024; }\n"
"http {\n"
" log_format backend 'BACKEND $request_method $uri';\n"
" access_log /dev/stdout backend;\n"
" server {\n"
" listen 8080;\n"
" default_type application/json;\n"
" add_header X-Instance-Id $hostname always;\n"
" add_header X-Request-Id $request_id always;\n"
" add_header Retry-After 7 always;\n"
' location /health/ { return 200 \'{"status":"ok"}\'; }\n'
" location = /api/limited {\n"
' return 429 \'{"error":{"code":"rate_limited",'
'"message":"upstream limit","request_id":"$request_id"}}\';\n'
" }\n"
" location = /api/post-failure {\n"
' return 503 \'{"error":{"code":"unavailable",'
'"message":"upstream failure","request_id":"$request_id"}}\';\n'
" }\n"
" location / { return 200 '" + PAYLOAD.decode() + "'; }\n"
" }\n"
"}\n"
)
self.compose_file = self.directory / "compose.json"
self.compose_file.write_text(
json.dumps(
{
"services": {
"api": {
"image": IMAGE,
"volumes": [f"{backend}:/etc/nginx/nginx.conf:ro"],
},
"nginx": {
"image": IMAGE,
"volumes": [
f"{ROOT / 'infra/nginx/nginx.conf'}:/etc/nginx/nginx.conf:ro"
],
"ports": ["127.0.0.1::8080"],
},
}
}
)
)
def compose(self, *args: str) -> str:
# Явный файл, уникальный проект и пустой env-file исключают основной стенд.
result = subprocess.run(
[
"docker",
"compose",
"--env-file",
"/dev/null",
"-f",
str(self.compose_file),
"-p",
self.project,
*args,
],
cwd=self.directory,
capture_output=True,
text=True,
timeout=45,
)
if result.returncode:
raise RuntimeError(result.stdout + result.stderr)
return result.stdout + result.stderr
def call(self, path: str, *, method: str = "GET", encoding: str = "identity"):
request = Request(
self.base_url + path,
method=method,
headers={"Accept-Encoding": encoding},
data=b"{}" if method == "POST" else None,
)
try:
response = urlopen(request, timeout=3)
except HTTPError as error:
response = error
except (URLError, TimeoutError):
return 0, {}, b""
with response:
return (
response.status,
{key.lower(): value for key, value in response.headers.items()},
response.read(),
)
def wait_instances(self, count: int) -> set[str]:
seen: set[str] = set()
deadline = time.monotonic() + 15
while time.monotonic() < deadline:
status, headers, _ = self.call("/health/live")
if status == 200:
seen.add(headers["x-instance-id"])
if len(seen) == count:
return seen
time.sleep(0.05)
raise AssertionError(f"Ожидалось {count} реплик, наблюдалось {len(seen)}")
def check_error(response, status: int, code: str) -> None:
actual_status, headers, body = response
check(actual_status == status, f"Ожидался HTTP {status}, получен {actual_status}")
check(
headers.get("content-type", "").startswith("application/json"), "Ошибка не JSON"
)
error = json.loads(body)["error"]
check(error["code"] == code, "Неверный код ошибки")
check(error["request_id"] == headers.get("x-request-id"), "request_id не совпадает")
def run_checks(stand: Stand) -> None:
stand.compose("up", "-d", "--pull", "never", "--scale", "api=2", "api", "nginx")
address = stand.compose("port", "nginx", "8080").strip()
stand.base_url = "http://" + address
stand.wait_instances(2)
print(stand.compose("exec", "-T", "nginx", "nginx", "-v").strip())
stand.compose("exec", "-T", "nginx", "nginx", "-t")
print("PASS: nginx -t и балансировка двух реплик")
status, headers, body = stand.call("/api/large", encoding="gzip")
check(
status == 200 and headers.get("content-encoding") == "gzip", "Нет gzip для JSON"
)
check(gzip.decompress(body) == PAYLOAD, "gzip изменил содержимое")
check(len(body) < len(PAYLOAD), "gzip не уменьшил тестовый ответ")
check(
"accept-encoding" in headers.get("vary", "").lower(),
"Нет Vary: Accept-Encoding",
)
check(stand.call("/api/large")[2] == PAYLOAD, "Ответ без gzip изменён")
small = stand.call("/health/live", encoding="gzip")
check(
small[0] == 200 and "content-encoding" not in small[1], "Маленький ответ сжат"
)
print(f"PASS: gzip {len(PAYLOAD)} → {len(body)} байт, содержимое сохранено")
limited = stand.call("/api/limited")
check_error(limited, 429, "rate_limited")
check(limited[1].get("retry-after") == "7", "Подменён Retry-After приложения")
check("x-instance-id" in limited[1], "Потерян id backend на ошибке API")
print("PASS: JSON и заголовки ошибки API передаются без подмены")
failure = stand.call("/api/post-failure", method="POST")
check_error(failure, 503, "unavailable")
backend_logs = stand.compose("logs", "--no-color", "--no-log-prefix", "api")
check(backend_logs.count("BACKEND POST /api/post-failure") == 1, "POST повторился")
print("PASS: отправленный POST не повторяется на другой реплике")
with ThreadPoolExecutor(max_workers=32) as pool:
responses = list(pool.map(lambda _: stand.call("/api/large"), range(500)))
rejected = [response for response in responses if response[0] == 429]
check(bool(rejected), "Не удалось вызвать ограничение частоты")
check(
all(response[0] in (200, 429) for response in responses), "Ошибка при нагрузке"
)
for response in rejected:
check_error(response, 429, "rate_limited")
check(response[1].get("retry-after") == "1", "Нет Retry-After балансировщика")
check("x-instance-id" not in response[1], "LB выдал себя за API-реплику")
with ThreadPoolExecutor(max_workers=16) as pool:
health = list(pool.map(lambda _: stand.call("/health/ready"), range(100)))
check(all(response[0] == 200 for response in health), "Лимит затронул health")
check(stand.call("/lb-health")[0] == 200, "Проверка LB недоступна")
print(f"PASS: лимит вернул {len(rejected)} ответов 429; health доступен")
stand.compose(
"up", "-d", "--pull", "never", "--scale", "api=3", "--no-recreate", "api"
)
instances = stand.wait_instances(3)
print("PASS: третья реплика обнаружена через DNS без reload nginx")
target = sorted(instances)[0]
containers = stand.compose("ps", "-q", "api").splitlines()
matching = [container for container in containers if container.startswith(target)]
check(len(matching) == 1, "Не найдена тестовая реплика для остановки")
# Все id взяты только из уникального временного Compose-проекта.
started = time.monotonic()
subprocess.run(
["docker", "stop", "--time", "1", matching[0]], check=True, capture_output=True
)
recovery = None
for _ in range(20):
status, headers, _ = stand.call("/health/live")
if status == 200:
check(headers["x-instance-id"] != target, "Остановленная реплика отвечает")
if recovery is None:
recovery = time.monotonic() - started
check(recovery is not None and recovery < 10, "Чтение не восстановилось за 10 с")
print(f"PASS: отказ реплики, первое успешное чтение через {recovery:.3f} с")
stand.compose("stop", "--timeout", "1", "api")
unavailable = stand.call("/health/ready")
check_error(unavailable, 503, "unavailable")
check(
unavailable[1].get("retry-after") == "1", "Нет Retry-After при отказе всех API"
)
check("x-instance-id" not in unavailable[1], "У ошибки LB есть id реплики")
check(stand.call("/lb-health")[0] == 200, "Отказ API сломал проверку самого LB")
print("PASS: недоступность всех backend возвращает JSON 503")
logs = stand.compose("logs", "--no-color", "--no-log-prefix", "nginx")
entries = [json.loads(line) for line in logs.splitlines() if line.startswith("{")]
check(bool(entries), "Нет JSON access log")
check(
all("request_id" in entry and "upstream_time" in entry for entry in entries),
"Неполный лог",
)
check(
any(entry["limit_status"] == "REJECTED" for entry in entries),
"Лимит не отражён в логе",
)
print("PASS: JSON access log содержит время backend и результат лимита")
def main() -> None:
with tempfile.TemporaryDirectory(prefix="mtusi-lab3-nginx-check-") as directory:
stand = Stand(directory)
try:
run_checks(stand)
except Exception:
print(stand.compose("logs", "--no-color", "--tail", "20"), flush=True)
raise
finally:
stand.compose("down", "--remove-orphans", "--timeout", "1")
if __name__ == "__main__":
main()
+107
View File
@@ -0,0 +1,107 @@
"""Общие операции с репликами текущего Compose-проекта."""
from contextlib import contextmanager
from dataclasses import dataclass
import fcntl
import json
import os
from pathlib import Path
import ssl
import subprocess
import tempfile
import time
from urllib.error import HTTPError, URLError
from urllib.request import urlopen
ROOT = Path(__file__).resolve().parents[1]
@dataclass(frozen=True)
class Replica:
"""Состояние контейнера API."""
id: str
image: str
instance_id: str
running: bool
health: str | None
class ComposeProject:
"""Работает только с выбранным Compose-проектом."""
def __init__(self) -> None:
self.command = ["docker", "compose", "--env-file", ".env"]
self.config = json.loads(self.run("config", "--format", "json"))
self.name = self.config["name"]
def docker(self, *args: str, timeout: int = 90, env=None) -> str:
"""Выполняет Docker-команду с ограничением времени."""
result = subprocess.run(
["docker", *args], cwd=ROOT, text=True, capture_output=True,
timeout=timeout, env={**os.environ, **(env or {})},
)
if result.returncode:
raise RuntimeError(result.stderr.strip() or result.stdout.strip())
return result.stdout.strip()
def run(self, *args: str, timeout: int = 90, env=None) -> str:
"""Выполняет команду Compose с текущими overrides."""
return self.docker(*self.command[1:], *args, timeout=timeout, env=env)
def replicas(self) -> list[Replica]:
"""Читает состояние API без окружения контейнеров."""
ids = self.run("ps", "--all", "--quiet", "api").splitlines()
if not ids:
return []
template = (
'{"id":{{json .Id}},"image":{{json .Image}},'
'"hostname":{{json .Config.Hostname}},"running":{{json .State.Running}},'
'"health":{{if .State.Health}}{{json .State.Health.Status}}{{else}}null{{end}}}'
)
rows = self.docker("inspect", "--format", template, *ids).splitlines()
configured = str(self.config["services"]["api"].get("environment", {}).get("INSTANCE_ID") or "").strip()
return [
Replica(row["id"], row["image"], configured or row["hostname"], row["running"], row["health"])
for row in map(json.loads, rows)
]
def wait_healthy(self, ids: set[str], timeout: float = 40) -> None:
"""Ожидает готовность конкретных реплик."""
deadline = time.monotonic() + timeout
while time.monotonic() < deadline:
current = {replica.id: replica for replica in self.replicas()}
if not ids <= current.keys():
raise RuntimeError("Контейнер API исчез во время развёртывания")
if all(current[id].running and current[id].health == "healthy" for id in ids):
return
if any(not current[id].running for id in ids):
raise RuntimeError("Контейнер API завершился до готовности")
time.sleep(0.25)
raise TimeoutError("API не стал healthy за отведённое время")
def wait_routed(self, instance_id: str, base_url: str, ca_file=None) -> None:
"""Ожидает ответа реплики через балансировщик."""
context = ssl.create_default_context(cafile=ca_file)
deadline = time.monotonic() + 40
while time.monotonic() < deadline:
try:
with urlopen(base_url.rstrip("/") + "/health/live", timeout=3, context=context) as response:
if response.status == 200 and response.headers.get("X-Instance-Id") == instance_id:
return
except (HTTPError, URLError, TimeoutError, OSError):
pass
time.sleep(0.1)
raise TimeoutError("Реплика не появилась в ответах балансировщика")
@contextmanager
def deployment_lock(project: ComposeProject):
"""Исключает параллельные изменения одного стенда."""
path = Path(tempfile.gettempdir()) / f"{project.name}-deployment.lock"
with path.open("a") as lock:
try:
fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
except BlockingIOError:
raise RuntimeError("Другой процесс уже изменяет этот Compose-проект") from None
yield
+148
View File
@@ -0,0 +1,148 @@
"""Сценарий поочерёдного отказа всех API-реплик под записью."""
from collections import Counter
from concurrent.futures import ThreadPoolExecutor
import json
import os
import re
import subprocess
from threading import Event, Lock
import time
from urllib.parse import quote
from uuid import uuid4
from scripts.deployment import ComposeProject, ROOT, deployment_lock
from tests.client import Client, Failure, arguments, check, run
def failure_kind(error: Failure) -> str:
"""Различает HTTP-отказы, ошибки соединения и проверки контракта."""
match = re.search(r"received (\d{3})$", str(error))
if match:
return "http_" + match.group(1)
return "connection" if "connection/TLS failure" in str(error) else "contract"
def snapshot(project: ComposeProject, phase: str, target: str) -> list:
"""Печатает состояние API без окружения и секретов."""
replicas = project.replicas()
print(json.dumps({
"scenario": "replica_failure", "phase": phase, "target": target,
"replicas": [{"instance": item.instance_id, "running": item.running, "health": item.health} for item in replicas],
}), flush=True)
return replicas
def history(client: Client, actor: dict, chat: dict) -> list[dict]:
"""Читает всю историю без повторов курсора."""
path = f"/api/v1/chats/{chat['id']}/messages?limit=100"
items = []
cursors = set()
for _ in range(1000):
page = client.call("GET", path, actor=actor, schema="MessagePage")["json"]
items.extend(page["items"])
cursor = page["next_cursor"]
if cursor is None:
return items
check(cursor not in cursors, "cursor cycle")
cursors.add(cursor)
path = f"/api/v1/chats/{chat['id']}/messages?limit=100&cursor={quote(cursor, safe='')}"
raise Failure("history exceeded safety bound")
def exercise(project: ComposeProject, args) -> None:
"""Останавливает каждую реплику и восстанавливает её перед следующей."""
replicas = project.replicas()
check(len(replicas) >= 2, "at least two API replicas are required")
project.wait_healthy({item.id for item in replicas})
client = Client(args.base_url, args.ca_file, timeout=2)
for item in replicas:
project.wait_routed(item.instance_id, client.base, args.ca_file)
actor, _, _, chat = client.bootstrap()
confirmed = set()
for target in replicas:
snapshot(project, "before", target.instance_id)
stop = Event()
lock = Lock()
successes = []
errors = []
def worker():
local = Client(client.base, args.ca_file, timeout=2)
key = uuid4().hex
while not stop.is_set():
started = time.monotonic()
try:
result = local.message(actor, chat, "failover-" + key, key=key)
with lock:
successes.append((started, time.monotonic(), result["json"]["id"]))
key = uuid4().hex
except Failure as error:
with lock:
errors.append(failure_kind(error))
time.sleep(0.1)
started = time.monotonic()
with ThreadPoolExecutor(max_workers=args.concurrency) as pool:
jobs = [pool.submit(worker) for _ in range(args.concurrency)]
try:
time.sleep(2)
stop_started = time.monotonic()
subprocess.run(
[str(ROOT / "scripts/stop-one.sh")], cwd=ROOT,
env={**os.environ, "TARGET_INSTANCE_ID": target.instance_id},
check=True, timeout=10, capture_output=True,
)
stop_finished = time.monotonic()
stopped = snapshot(project, "stopped", target.instance_id)
check(any(item.id == target.id and not item.running for item in stopped), "target API was not stopped")
check(any(item.id != target.id and item.running and item.health == "healthy" for item in stopped), "no healthy surviving API")
time.sleep(args.duration)
finally:
stop.set()
try:
for job in jobs:
job.result(timeout=5)
finally:
project.docker("start", target.id)
project.wait_healthy({item.id for item in replicas})
project.wait_routed(target.instance_id, client.base, args.ca_file)
snapshot(project, "restored", target.instance_id)
elapsed = max(end for _, end, _ in successes) - started if successes else 0
recovered = [end for begin, end, _ in successes if begin >= stop_finished]
check(bool(recovered), "no confirmed writes after failure")
recovery = min(recovered) - stop_started
check(recovery <= 10, "writes did not recover within 10 seconds")
confirmed.update(id for _, _, id in successes)
items = history(client, actor, chat)
check(confirmed <= {item["id"] for item in items}, "confirmed messages were lost")
texts = [item["text"] for item in items]
check(len(texts) == len(set(texts)), "uncertain retry created duplicates")
print(json.dumps({
"instance": target.instance_id,
"successful_writes": len(successes),
"failed_attempts": len(errors),
"errors_by_kind": dict(Counter(errors)),
"elapsed_seconds": round(elapsed, 3),
"successful_rps": round(len(successes) / elapsed, 3) if elapsed else 0,
"first_recovery_seconds": round(recovery, 3),
}), flush=True)
def main() -> None:
"""Готовит параметры эксперимента отказа реплик."""
def configure(parser):
parser.add_argument("--duration", type=float, default=15)
parser.add_argument("--concurrency", type=int, default=2)
args = arguments("Fail each API replica under write load", configure)
check(1 <= args.duration <= 120 and 1 <= args.concurrency <= 8, "invalid workload")
project = ComposeProject()
with deployment_lock(project):
exercise(project, args)
if __name__ == "__main__":
run(main)
+46
View File
@@ -0,0 +1,46 @@
"""Подготавливает локальные файлы Docker secrets."""
import os
from pathlib import Path
import secrets
from pydantic import SecretStr
from pydantic_settings import BaseSettings, SettingsConfigDict
ROOT = Path(__file__).resolve().parents[1]
class ExistingSecrets(BaseSettings):
"""Читает прежние пароли без вывода значений."""
db_password: SecretStr | None = None
redis_password: SecretStr | None = None
model_config = SettingsConfigDict(env_file=ROOT / ".env", extra="ignore")
def main() -> None:
"""Создаёт отсутствующие файлы, сохраняя существующие значения."""
directory = ROOT / "secrets"
directory.mkdir(mode=0o700, exist_ok=True)
directory.chmod(0o700)
existing = ExistingSecrets()
for name in ("db_password", "redis_password"):
path = directory / name
if path.is_symlink():
raise RuntimeError(f"Секрет {name} не должен быть символьной ссылкой")
if path.exists() and not path.is_file():
raise RuntimeError(f"Секрет {name} должен быть обычным файлом")
if not path.exists():
previous = getattr(existing, name)
value = previous.get_secret_value() if previous else secrets.token_urlsafe(32)
if not value or value.strip() != value or "\n" in value or "\r" in value:
raise ValueError(f"Секрет {name} должен занимать одну строку без крайних пробелов")
descriptor = os.open(path, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
with os.fdopen(descriptor, "w") as file:
file.write(value + "\n")
path.chmod(0o444)
print(f"Готов файл secrets/{name}")
if __name__ == "__main__":
main()
-5
View File
@@ -1,6 +1,4 @@
#!/bin/sh
# Перезапуск API и всех хранилищ с сохранением volumes (make test-persistence).
# У api несколько реплик, перед ними nginx.
set -eu
cd "$(dirname "$0")/.."
@@ -8,7 +6,6 @@ compose() {
docker compose --env-file .env "$@"
}
# Ждёт, пока ВСЕ контейнеры service станут healthy (у api их несколько).
wait_healthy() {
for service in "$@"; do
attempts=0
@@ -29,7 +26,5 @@ compose restart postgres redis
wait_healthy postgres redis
compose restart api
wait_healthy api
# TODO(3.3): если nginx перерезолвит DNS сам, рестарт LB не обязателен —
# но перезапуск «всего стенда» в защите всё равно его включает.
compose restart nginx
wait_healthy nginx
+92
View File
@@ -0,0 +1,92 @@
"""Поочерёдно заменяет API с одной дополнительной репликой."""
import argparse
import sys
from scripts.deployment import ComposeProject, deployment_lock
def update(project: ComposeProject, base_url: str, ca_file=None, revision: str | None = None) -> None:
"""Собирает образ, применяет миграции и заменяет реплики."""
original = project.replicas()
if len(original) < 2 or any(not item.running or item.health != "healthy" for item in original):
raise RuntimeError("До обновления нужны минимум две здоровые API-реплики")
old_images = {item.image for item in original}
if len(old_images) != 1:
raise RuntimeError("Сначала восстановите единый образ работающих реплик")
old_image = old_images.pop()
profile = project.docker(
"image", "inspect", old_image,
"--format", '{{index .Config.Labels "io.mtusi.messenger.secrets"}}',
)
if profile != "file-v1":
raise RuntimeError("Сначала выполните первоначальный переход на файловые секреты через make up")
count = len(original)
print("Сборка нового образа API", flush=True)
build_args = ("--build-arg", f"API_BUILD_REVISION={revision}") if revision else ()
project.run("build", *build_args, "api", timeout=300)
tag = project.config["services"]["api"]["image"]
new_image = project.docker("image", "inspect", tag, "--format", "{{.Id}}")
print("Однократное применение совместимых миграций", flush=True)
project.run("run", "--rm", "--no-deps", "--pull", "never", "migrate")
if old_image == new_image:
print("Образ не изменился; замена контейнеров не требуется")
return
try:
for old in original:
project.run(
"up", "-d", "--no-deps", "--no-build", "--pull", "never",
"--no-recreate", "--scale", f"api={count + 1}", "api",
)
current = project.replicas()
additions = [item for item in current if item.id not in {replica.id for replica in original} and item.image == new_image]
if not additions:
raise RuntimeError("Новая реплика не создана")
project.wait_healthy({item.id for item in additions})
for added in additions:
project.wait_routed(added.instance_id, base_url, ca_file)
survivors = {item.id for item in project.replicas() if item.id != old.id}
project.wait_healthy(survivors)
project.docker("stop", old.id)
project.docker("rm", old.id)
print(f"Заменена реплика {old.instance_id}", flush=True)
final = project.replicas()
if len(final) != count or any(item.image != new_image for item in final):
raise RuntimeError("Состав реплик после обновления не соответствует плану")
project.wait_healthy({item.id for item in final})
except Exception:
print("Обновление прервано; восстанавливается прежний образ без отката БД", file=sys.stderr)
project.run(
"up", "-d", "--no-deps", "--no-build", "--pull", "never",
"--force-recreate", "--scale", f"api={count}", "api",
env={"API_IMAGE": old_image},
)
project.wait_healthy({item.id for item in project.replicas()})
raise
dangling = project.docker("image", "ls", "--quiet", "--no-trunc", "--filter", "dangling=true").splitlines()
if old_image in dangling:
references = project.docker("ps", "--all", "--quiet", "--filter", f"ancestor={old_image}")
if not references:
try:
project.docker("image", "rm", old_image)
except RuntimeError:
print("Прежний образ не удалён: состояние Docker изменилось", file=sys.stderr)
print(f"Готово: {count} здоровых реплик нового образа")
def main() -> None:
"""Запускает обновление с блокировкой проекта."""
parser = argparse.ArgumentParser(description="Rolling update of API replicas")
parser.add_argument("--base-url", default="http://localhost:8080")
parser.add_argument("--ca-file", default=None)
parser.add_argument("--revision", default=None)
args = parser.parse_args()
project = ComposeProject()
with deployment_lock(project):
update(project, args.base_url or "http://localhost:8080", args.ca_file, args.revision)
if __name__ == "__main__":
main()
+24 -15
View File
@@ -1,21 +1,30 @@
#!/bin/sh
# Останавливает одну API-реплику по TARGET_INSTANCE_ID (сценарий отказа, make test-failover).
# TODO(3.5): реализовать — см. docs/LAB3_TASKS.md, задача 3.5.
set -eu
cd "$(dirname "$0")/.."
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
# Что нужно сделать:
# 1. Сопоставить TARGET_INSTANCE_ID (значение X-Instance-Id) с контейнером.
# Проще всего, если X-Instance-Id = короткий id контейнера (HOSTNAME):
# docker compose --env-file .env ps -q api -> полные id реплик api
# и найти тот, что начинается с TARGET_INSTANCE_ID.
# 2. Убедиться, что это контейнер service `api` ЭТОГО compose-проекта,
# а не postgres/nginx/чужой контейнер. Не нашли -> exit 1.
# 3. Остановить его (docker stop [-t N]) и оставить остановленным.
# Не трогать БД/LB/volumes. Уложиться в 10 секунд.
# 4. Напечатать (в stderr), что именно остановлено — пригодится для отчёта.
# Восстановление — отдельно: make restore.
case "$TARGET_INSTANCE_ID" in
*[!a-zA-Z0-9_.:-]*|'') exit 1 ;;
esac
echo 'TODO: implement stop-one.sh' >&2
exit 2
target=""
for container in $(docker compose --env-file .env ps -q api); do
hostname=$(docker inspect --format '{{.Config.Hostname}}' "$container")
configured=$(docker inspect --format '{{range .Config.Env}}{{if eq (index (split . "=") 0) "INSTANCE_ID"}}{{println .}}{{end}}{{end}}' "$container" \
| sed -n 's/^INSTANCE_ID=//p' | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
if [ "$TARGET_INSTANCE_ID" = "$hostname" ] || [ "$TARGET_INSTANCE_ID" = "$configured" ]; then
if [ -n "$target" ]; then
echo 'Instance id matches multiple API containers' >&2
exit 1
fi
target="$container"
fi
done
if [ -z "$target" ]; then
echo 'Target API instance not found in this Compose project' >&2
exit 1
fi
echo "Stopping API container $target" >&2
docker stop --timeout 8 "$target" >/dev/null
+3 -3
View File
@@ -8,7 +8,7 @@ from sqlalchemy import text
from app.main import create_app
from conftest import close_app, make_client
from helpers import PASSWORD, basic_header, bearer, create_user, register
from helpers import PASSWORD, basic_header, bearer, create_user, idempotency_header, register
async def test_parallel_registration_of_same_username_creates_exactly_one_user(
@@ -62,7 +62,7 @@ async def test_100_messages_from_10_clients(make_settings):
*(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=bearer(user),
headers={**bearer(user), **idempotency_header()},
json={"text": f"client-{index}-message-{n}"},
)
for n in range(10)
@@ -207,7 +207,7 @@ async def test_message_limit_is_exact_under_concurrency(make_settings, db_engine
*(
client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=bearer(user),
headers={**bearer(user), **idempotency_header()},
json={"text": f"m{i}"},
)
for i in range(20)
+156
View File
@@ -0,0 +1,156 @@
"""Повторы сообщений через приложения с общими хранилищами."""
import asyncio
from contextlib import AsyncExitStack
import pytest
from sqlalchemy import text
from app.errors.exceptions import unavailable
from app.main import create_app
from app.storage import idempotency as key_storage
from conftest import close_app, make_client
from helpers import bearer, create_chat, create_user, idempotency_header, send_message
@pytest.fixture
async def replicas(request, make_settings):
overrides = getattr(request, "param", {})
apps = [create_app(make_settings(instance_id=name, **overrides)) for name in ("api-a", "api-b")]
try:
async with AsyncExitStack() as stack:
clients = [await stack.enter_async_context(make_client(app)) for app in apps]
yield clients
finally:
for app in apps:
await close_app(app)
@pytest.mark.parametrize("key", [None, "", "a b", "a/b", "x" * 129])
async def test_invalid_key_returns_400(client, key):
user = await create_user(client)
chat = await create_chat(client, user)
headers = bearer(user)
if key is not None:
headers["Idempotency-Key"] = key
response = await client.post(
f"/api/v1/chats/{chat['id']}/messages", headers=headers, json={"text": "hello"}
)
assert response.status_code == 400
assert response.json()["error"]["code"] == "invalid_request"
@pytest.mark.parametrize("key", ["a", "x" * 128, "key_1.2:3-4"])
async def test_valid_key_boundaries(client, key):
user = await create_user(client)
chat = await create_chat(client, user)
assert (await send_message(client, user, chat, "hello", key)).status_code == 201
async def test_replay_and_conflict_across_replicas(replicas, db_engine):
first, second = replicas
user = await create_user(first)
chat = await create_chat(first, user)
original = await send_message(first, user, chat, "Привет", "same-key")
repeated = await second.post(
f"/api/v1/chats/{chat['id']}/messages",
headers={**bearer(user), **idempotency_header("same-key"), "Content-Type": "application/json"},
content='{ "text" : "\\u041f\\u0440\\u0438\\u0432\\u0435\\u0442" }',
)
conflict = await send_message(second, user, chat, "другой текст", "same-key")
assert original.status_code == repeated.status_code == 201
assert original.json() == repeated.json()
assert original.headers["X-Instance-Id"] != repeated.headers["X-Instance-Id"]
assert conflict.status_code == 409
async with db_engine.connect() as connection:
assert (await connection.execute(text("SELECT count(*) FROM messages"))).scalar_one() == 1
assert (await connection.execute(text("SELECT value FROM counters WHERE name='messages'"))).scalar_one() == 1
async def test_parallel_replays_create_one_message(replicas, db_engine):
user = await create_user(replicas[0])
chat = await create_chat(replicas[0], user)
responses = await asyncio.gather(*(
send_message(replicas[index % 2], user, chat, "parallel", "one-key")
for index in range(24)
))
assert all(response.status_code == 201 for response in responses)
assert len({response.json()["id"] for response in responses}) == 1
assert {response.headers["X-Instance-Id"] for response in responses} == {"api-a", "api-b"}
async with db_engine.connect() as connection:
assert (await connection.execute(text("SELECT count(*) FROM messages"))).scalar_one() == 1
assert (await connection.execute(text("SELECT count(*) FROM idempotency_keys"))).scalar_one() == 1
async def test_key_scope_separates_users_and_chats(client):
alice = await create_user(client)
bob = await create_user(client)
shared = await create_chat(client, alice, bob)
other = await create_chat(client, alice)
responses = [
await send_message(client, alice, shared, "a", "shared-key"),
await send_message(client, bob, shared, "b", "shared-key"),
await send_message(client, alice, other, "c", "shared-key"),
]
assert all(response.status_code == 201 for response in responses)
assert len({response.json()["id"] for response in responses}) == 3
async def test_expired_key_can_be_reused_without_removing_message(client, db_engine):
user = await create_user(client)
chat = await create_chat(client, user)
first = await send_message(client, user, chat, "old", "expiring-key")
async with db_engine.begin() as connection:
await connection.execute(text(
"UPDATE idempotency_keys SET created_at = clock_timestamp() - interval '25 hours'"
))
second = await send_message(client, user, chat, "new", "expiring-key")
assert first.status_code == second.status_code == 201
assert first.json()["id"] != second.json()["id"]
history = await client.get(
f"/api/v1/chats/{chat['id']}/messages", headers=bearer(user)
)
assert [item["text"] for item in history.json()["items"]] == ["old", "new"]
async def test_failed_transaction_does_not_poison_key(client, db_engine, monkeypatch):
user = await create_user(client)
chat = await create_chat(client, user)
original = key_storage.save_result
async def fail_after_insert(*args):
await original(*args)
raise unavailable()
monkeypatch.setattr(key_storage, "save_result", fail_after_insert)
failed = await send_message(client, user, chat, "retry", "retry-key")
assert failed.status_code == 503
async with db_engine.connect() as connection:
for table in ("messages", "idempotency_keys", "counters"):
assert (await connection.execute(text(f"SELECT count(*) FROM {table}"))).scalar_one() == 0
monkeypatch.setattr(key_storage, "save_result", original)
recovered = await send_message(client, user, chat, "retry", "retry-key")
assert recovered.status_code == 201
@pytest.mark.parametrize("replicas", [{"max_messages": 1}], indirect=True)
async def test_replay_works_when_message_limit_is_full(replicas):
user = await create_user(replicas[0])
chat = await create_chat(replicas[0], user)
first = await send_message(replicas[0], user, chat, "last", "last-key")
replay = await send_message(replicas[1], user, chat, "last", "last-key")
rejected = await send_message(replicas[1], user, chat, "extra", "other-key")
assert first.status_code == replay.status_code == 201
assert first.json() == replay.json()
assert rejected.status_code == 503
async def test_replay_checks_session_and_membership(client, db_engine):
user = await create_user(client)
chat = await create_chat(client, user)
assert (await send_message(client, user, chat, "private", "private-key")).status_code == 201
async with db_engine.begin() as connection:
await connection.execute(text("DELETE FROM chat_members"))
assert (await send_message(client, user, chat, "private", "private-key")).status_code == 404
await client.delete("/api/v1/auth/sessions/current", headers=bearer(user))
assert (await send_message(client, user, chat, "private", "private-key")).status_code == 401
+106
View File
@@ -0,0 +1,106 @@
"""Идентификатор реплики и заголовки ответов без PostgreSQL, Redis и Docker."""
from uuid import UUID
import pytest
from fastapi import Request
from app.core.instance import resolve_instance_id
from app.errors.exceptions import unavailable
from app.main import create_app
from conftest import close_app, make_client
@pytest.fixture(autouse=True)
def clean_db() -> None:
"""Заменяет очистку БД из conftest: эти тесты не обращаются к хранилищам."""
@pytest.mark.parametrize(
("configured", "expected"),
[
("api-explicit", "api-explicit"),
(" api-explicit ", "api-explicit"),
(None, "container-123"),
("", "container-123"),
(" ", "container-123"),
],
)
def test_resolve_prefers_configured_id_then_hostname(monkeypatch, configured, expected):
monkeypatch.setenv("HOSTNAME", " container-123 ")
assert resolve_instance_id(configured) == expected
@pytest.mark.parametrize("hostname", [None, "", " "])
def test_resolve_without_config_or_hostname_returns_uuid(monkeypatch, hostname):
if hostname is None:
monkeypatch.delenv("HOSTNAME", raising=False)
else:
monkeypatch.setenv("HOSTNAME", hostname)
assert UUID(resolve_instance_id(None)).version == 4
@pytest.fixture
async def instance_client(make_settings):
app = create_app(
make_settings(
instance_id="api-test",
database_url="postgresql+asyncpg://unused@127.0.0.1:1/unused",
redis_port=1,
)
)
@app.get("/__test__/request-id", include_in_schema=False)
async def request_id(request: Request) -> dict[str, str]:
return {"request_id": request.state.request_id}
@app.get("/__test__/explode", include_in_schema=False)
async def explode() -> None:
raise RuntimeError("test error")
@app.get("/__test__/unavailable", include_in_schema=False)
async def dependency_failure() -> None:
raise unavailable()
try:
async with make_client(app, raise_app_exceptions=False) as client:
yield client
finally:
await close_app(app)
@pytest.mark.parametrize(
("method", "path", "status"),
[
("GET", "/health/live", 200),
("POST", "/api/v1/users", 400),
("GET", "/api/v1/users/me", 401),
("GET", "/no-such-path", 404),
("DELETE", "/health/live", 405),
("GET", "/__test__/explode", 500),
("GET", "/__test__/unavailable", 503),
],
)
async def test_instance_header_is_present_on_success_and_errors(
instance_client, method, path, status
):
response = await instance_client.request(method, path)
assert response.status_code == status
assert response.headers["X-Instance-Id"] == "api-test"
assert response.headers["X-Request-Id"]
if status >= 400:
assert response.json()["error"]["request_id"] == response.headers["X-Request-Id"]
async def test_instance_id_is_stable_while_request_ids_are_distinct(instance_client):
first = await instance_client.get("/__test__/request-id")
second = await instance_client.get("/__test__/request-id")
assert first.status_code == second.status_code == 200
assert first.headers["X-Instance-Id"] == second.headers["X-Instance-Id"] == "api-test"
assert first.headers["X-Request-Id"] != second.headers["X-Request-Id"]
for response in (first, second):
assert response.json()["request_id"] == response.headers["X-Request-Id"]
+50
View File
@@ -0,0 +1,50 @@
"""Готовность при завершении и ограничение времени проверки зависимостей."""
import asyncio
import time
import pytest
from app.endpoints import health
from app.main import create_app
from conftest import close_app, make_client
@pytest.fixture(autouse=True)
def clean_db() -> None:
"""Эти проверки не обращаются к хранилищам."""
async def test_draining_keeps_liveness_but_rejects_new_work(make_settings):
app = create_app(make_settings())
app.state.lifecycle.start_draining()
try:
async with make_client(app) as client:
assert (await client.get('/health/live')).status_code == 200
assert (await client.get('/health/ready')).status_code == 503
assert (await client.get('/api/v1/users/me')).status_code == 503
finally:
await close_app(app)
async def test_readiness_timeout_cancels_dependency_checks(make_settings, monkeypatch):
cancelled = []
async def stalled(_):
try:
await asyncio.sleep(30)
finally:
cancelled.append(True)
monkeypatch.setattr(health, 'check_database', stalled)
monkeypatch.setattr(health, 'check_redis', stalled)
app = create_app(make_settings(readiness_timeout_seconds=0.03))
try:
async with make_client(app) as client:
started = time.monotonic()
response = await client.get('/health/ready')
assert response.status_code == 503
assert time.monotonic() - started < 1
assert len(cancelled) == 2
finally:
await close_app(app)
+8 -8
View File
@@ -6,7 +6,7 @@ import httpx
from app.main import create_app
from conftest import close_app, make_client
from helpers import assert_request_id, bearer, create_chat, create_user
from helpers import assert_request_id, bearer, create_chat, create_user, idempotency_header
def _assert_error(response: httpx.Response, status: int, code: str) -> None:
@@ -25,12 +25,12 @@ async def test_message_limit_rejects_without_deleting_confirmed_messages(make_se
for index in range(2):
ok = await client.post(
url, headers=bearer(user), json={"text": f"confirmed-{index}"}
url, headers={**bearer(user), **idempotency_header()}, json={"text": f"confirmed-{index}"}
)
assert ok.status_code == 201
rejected = await client.post(
url, headers=bearer(user), json={"text": "rejected"}
url, headers={**bearer(user), **idempotency_header()}, json={"text": "rejected"}
)
_assert_error(rejected, 503, "unavailable")
@@ -48,7 +48,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat
app = create_app(make_settings(max_in_flight=2))
original_send_message = message_endpoint.send_message
original_send_message = message_endpoint.send_message_idempotent
accepted_count = 0
all_slots_taken = asyncio.Event()
release = asyncio.Event()
@@ -65,12 +65,12 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat
user = await create_user(client)
chat = await create_chat(client, user)
monkeypatch.setattr(message_endpoint, "send_message", blocking_send_message)
monkeypatch.setattr(message_endpoint, "send_message_idempotent", blocking_send_message)
url = f"/api/v1/chats/{chat['id']}/messages"
held = [
asyncio.create_task(
client.post(url, headers=bearer(user), json={"text": f"held-{i}"})
client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": f"held-{i}"})
)
for i in range(2)
]
@@ -79,7 +79,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat
rejected = await asyncio.gather(
*(
client.post(url, headers=bearer(user), json={"text": f"rejected-{i}"})
client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": f"rejected-{i}"})
for i in range(4)
)
)
@@ -92,7 +92,7 @@ async def test_in_flight_limit_returns_429_and_recovers(make_settings, monkeypat
release.set()
assert all(r.status_code == 201 for r in await asyncio.gather(*held))
recovered = await client.post(url, headers=bearer(user), json={"text": "after"})
recovered = await client.post(url, headers={**bearer(user), **idempotency_header()}, json={"text": "after"})
assert recovered.status_code == 201
assert_request_id(recovered)
await close_app(app)
+2 -1
View File
@@ -8,6 +8,7 @@ from helpers import (
bearer,
create_chat,
create_user,
idempotency_header,
send_message,
)
@@ -58,7 +59,7 @@ async def test_extra_message_field_is_rejected(client: AsyncClient):
response = await client.post(
f"/api/v1/chats/{chat['id']}/messages",
headers=bearer(alice),
headers={**bearer(alice), **idempotency_header()},
json={"text": "hello", "sender_id": alice["id"]},
)
+1 -1
View File
@@ -8,7 +8,7 @@ from sqlalchemy import inspect, text
from app.models import Base
from conftest import reset_schema, upgrade_head
EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "counters"}
EXPECTED_TABLES = {"users", "chats", "chat_members", "messages", "counters", "idempotency_keys"}
@pytest.fixture
+1
View File
@@ -0,0 +1 @@
"""Публичный HTTP-клиент и проверки контракта."""