Лабораторная работа 3 — Павлов Никита БВТ2301 (Оценка 5, Трек 1) #93
@@ -14,6 +14,7 @@ volumes/
|
||||
data/
|
||||
backups/
|
||||
# Runtime/build artifacts
|
||||
venv/
|
||||
.venv/
|
||||
__pycache__/
|
||||
*.py[cod]
|
||||
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
FROM python:3.11.9-slim-bookworm
|
||||
|
||||
RUN apt-get update && apt-get install -y --no-install-recommends curl \
|
||||
&& rm -rf /var/lib/apt/lists/*
|
||||
|
||||
RUN groupadd -r appgroup && useradd -r -g appgroup appuser
|
||||
|
||||
WORKDIR /app
|
||||
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
|
||||
COPY migrations/ ./migrations/
|
||||
COPY src/ ./src/
|
||||
|
||||
RUN chown -R appuser:appgroup /app
|
||||
|
||||
USER appuser
|
||||
|
||||
EXPOSE 8080
|
||||
|
||||
HEALTHCHECK --interval=10s --timeout=3s --start-period=3s --retries=3 \
|
||||
CMD curl -f http://localhost:8080/health/live || exit 1
|
||||
|
||||
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -1,37 +1,165 @@
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Павлов Никита, БВТ2301
|
||||
- Целевая оценка; выбранный трек 5, если нужен: Оценка 5, Трек 1 (Цена масштабирования)
|
||||
- Commit/PR: Отправлен в ветку main
|
||||
- Использованные источники, библиотеки и помощь ИИ: FastAPI, Nginx, asyncpg, Redis, Argon2-cffi, Pydantic, Uvicorn, Pytest, Docker Compose, PostgreSQL 16. Помощь ИИ (LLM) для проектирования идемпотентности, конфигурации Nginx failover и проведения бенчмарков масштабируемости.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Версии: Docker Desktop, Docker Compose v2, Python 3.12+.
|
||||
Базовые образы: nginx:1.25.4-alpine, postgres:16.2-alpine, redis:7.2.4-alpine, python:3.11.9-slim-bookworm.
|
||||
Prerequisites: установленные Git, Docker и Python.
|
||||
|
||||
1. Локальные секреты и конфигурация:
|
||||
Создать папку secrets/ и два файла:
|
||||
secrets/database_url со значением postgresql://appuser:apppassword@postgres:5432/messenger_db
|
||||
secrets/cache_url со значением redis://redis:6379/0
|
||||
Создать файл .env на основе .env.example.
|
||||
|
||||
2. Сборка и запуск всего стека:
|
||||
docker compose up -d --build
|
||||
|
||||
3. Ожидание готовности (healthcheck всех сервисов):
|
||||
docker compose ps
|
||||
(Все сервисы: load_balancer, api (2 реплики), postgres, redis находятся в статусе healthy)
|
||||
|
||||
4. Запуск тестов:
|
||||
# Публичный смоук-тест API
|
||||
python -X utf8 tests/smoke.py --base-url "http://localhost:8080"
|
||||
|
||||
# Тест отказа одной API-реплики (Failover)
|
||||
python -X utf8 tests/resilience.py --mode failover --action-script "scripts/stop-one.bat" --base-url "http://localhost:8080"
|
||||
|
||||
# Тест сохранности сессий и данных при перезапуске (Persistence)
|
||||
python -X utf8 tests/resilience.py --mode persistence --action-script "scripts/restart.bat" --base-url "http://localhost:8080"
|
||||
|
||||
# Собственные тесты уровня 4 (идемпотентность, ротация реплик X-Instance-Id)
|
||||
python -m pytest student-tests/test_lab3.py
|
||||
|
||||
# Воспроизводимый эксперимент уровня 5 (Трек 1: Масштабирование 1, 2, 4 реплик)
|
||||
python scripts/track1_scaling.py
|
||||
|
||||
5. Остановка и удаление:
|
||||
Безопасная остановка: docker compose stop
|
||||
Остановка с удалением учебных данных: docker compose down -v
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Схема процессов и балансировка:
|
||||
- Единая точка входа: Nginx 1.25 (порт 8080) балансирует трафик между масштабируемыми репликами API (порт 8000 внутри сети) по алгоритму Round-Robin. Sticky sessions отсутствуют; сессии распределены через общий Redis с персистентностью AOF.
|
||||
- Изоляция реплик: Контейнеры API не публикуют порты наружу хоста, исключая обход балансировщика. Каждая реплика генерирует свой стабильный UUID в заголовке X-Instance-Id.
|
||||
- Безотказное переключение (Failover): В Nginx настроена директива proxy_next_upstream error timeout http_502 http_503 http_504 non_idempotent с таймаутом соединения 2 секунды. При падении одной из реплик запрос прозрачно перенаправляется на выжившую реплику без прерывания обслуживания клиента (восстановление за 2.719 сек).
|
||||
- Однократные миграции: Исключена гонка реплик при старте — миграции применяются отдельным контейнером migrator строго до запуска сервиса api (depends_on: condition: service_completed_successfully).
|
||||
- Идемпотентность (Idempotency-Key):
|
||||
- Заголовок Idempotency-Key обязателен для POST сообщений (формат [A-Za-z0-9._:-]{1,128}, иначе 400).
|
||||
- Уникальность контролируется составным первичным ключом в таблице idempotency_keys (user_id, chat_id, key).
|
||||
- Тело запроса валидируется через SHA-256 хеш. При повторном запросе с тем же ключом и тем же телом возвращается статус 201 и ранее созданное сообщение. Попытка передать другое тело с тем же ключом возвращает 409 Conflict.
|
||||
- Лимиты ресурсов: В compose.yaml для каждого сервиса заданы строгие ограничения CPU и памяти (deploy.resources.limits).
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Публичный smoke | python -X utf8 tests/smoke.py | PASS: lab3 public API scenario | Вывод консоли |
|
||||
| Failover сценарий | python -X utf8 tests/resilience.py --mode failover | PASS (2 реплики обнаружены, восстановление за 2.719 сек) | scripts/stop-one.bat |
|
||||
| Persistence сценарий | python -X utf8 tests/resilience.py --mode persistence | PASS (сессии и сообщения сохранены после рестарта) | scripts/restart.bat |
|
||||
| Уровень 4: Тесты | python -m pytest student-tests/test_lab3.py | 3 passed (проверка 400/409 идемпотентности и балансировки) | student-tests/test_lab3.py |
|
||||
| Уровень 4: Лимиты | docker compose ps / inspect | Лимиты cpus/memory активны, API не публикует порты | compose.yaml |
|
||||
| Уровень 5: Трек 1 | python scripts/track1_scaling.py | Сравнение 1/2/4 реплик, плато, доказательство и улучшение | scripts/track1_scaling.py |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
## Эксперименты и отказы (Трек 1: Цена масштабирования)
|
||||
|
||||
## Эксперименты и отказы
|
||||
### 1. Серия 1: Фиксированный суммарный бюджет ресурсов (Итого: 1.0 CPU, 512MB RAM)
|
||||
Методика: Суммарный объем ресурсов API-слоя строго зафиксирован (1.0 CPU, 512MB RAM) и пропорционально нарезается между репликами с помощью `docker update`:
|
||||
- 1 реплика: 1.00 CPU, 512MB RAM
|
||||
- 2 реплики: по 0.50 CPU, 256MB RAM каждая
|
||||
- 4 реплики: по 0.25 CPU, 128MB RAM каждая
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
Исходные измерения (Raw Data):
|
||||
Реплики | CPU на реп. | RPS | p50 (ms) | p95 (ms) | p99 (ms) | Ошибки
|
||||
----------------------------------------------------------------------------------------
|
||||
1 | 1.00 | 126.1 | 64.0 | 77.2 | 94.5 | 0
|
||||
2 | 0.50 | 127.4 | 63.6 | 74.8 | 87.6 | 0
|
||||
4 | 0.25 | 131.5 | 61.1 | 72.1 | 84.8 | 0
|
||||
|
||||
График RPS (Серия 1: Фиксированный бюджет 1.0 CPU):
|
||||
1 реп. | ████████████████████████████ 126.1 RPS
|
||||
2 реп. | █████████████████████████████ 127.4 RPS
|
||||
4 реп. | ██████████████████████████████ 131.5 RPS
|
||||
|
||||
Вывод по Серии 1:
|
||||
При фиксированном суммарном бюджете деление 1 ядра на 4 микроквоты (по 0.25 CPU) дает незначительный прирост (+4.2% RPS) за счет обхода GIL Python 4 независимыми процессами, однако дальнейший рост жестко ограничен оверхедом планировщика ядра Linux (cgroups CPU quota throttling).
|
||||
|
||||
---
|
||||
|
||||
### 2. Серия 2: Масштабирование ресурсов (+0.5 CPU, 256MB на каждую реплику)
|
||||
Методика: Ресурсы выделяются пропорционально числу реплик (по 0.5 CPU и 256MB RAM на каждый контейнер api):
|
||||
- 1 реплика: суммарно 0.5 CPU, 256MB RAM
|
||||
- 2 реплики: суммарно 1.0 CPU, 512MB RAM
|
||||
- 4 реплики: суммарно 2.0 CPU, 1024MB RAM
|
||||
|
||||
Исходные измерения (Raw Data):
|
||||
Реплики | Всего CPU | RPS | p50 (ms) | p95 (ms) | p99 (ms) | Ошибки
|
||||
----------------------------------------------------------------------------------------
|
||||
1 | 0.5 | 142.7 | 56.6 | 68.2 | 72.8 | 0
|
||||
2 | 1.0 | 147.2 | 52.3 | 66.8 | 70.1 | 0
|
||||
4 | 2.0 | 145.5 | 55.0 | 67.5 | 70.7 | 0
|
||||
|
||||
График RPS (Серия 2: Масштабирование ресурсов):
|
||||
1 реп. | █████████████████████████████ 142.7 RPS
|
||||
2 реп. | ██████████████████████████████ 147.2 RPS
|
||||
4 реп. | █████████████████████████████ 145.5 RPS (Плато и спад)
|
||||
|
||||
---
|
||||
|
||||
### 3. Доказательство причины плато (Анализ телеметрии)
|
||||
При переходе с 2 на 4 реплики (с 1.0 до 2.0 CPU) производительность уперлась в плато и снизилась со 147.2 до 145.5 RPS.
|
||||
|
||||
Реальные метрики нагрузки контейнеров (`docker stats` во время 4 реплик):
|
||||
- `api-1`: CPU = 11.09%, Память = 46.05 MiB / 256 MiB
|
||||
- `api-2`: CPU = 11.54%, Память = 43.20 MiB / 256 MiB
|
||||
- `api-3`: CPU = 13.70%, Память = 42.27 MiB / 256 MiB
|
||||
- `api-4`: CPU = 13.65%, Память = 42.41 MiB / 256 MiB
|
||||
- `load_balancer` (Nginx): CPU = 3.02%, Память = 2.55 MiB / 128 MiB
|
||||
- `postgres`: CPU = 12.58%, Память = 77.73 MiB / 512 MiB
|
||||
- `redis`: CPU = 0.75%, Память = 11.30 MiB / 256 MiB
|
||||
|
||||
Доказательство:
|
||||
Ни один компонент не утилизирует CPU (загрузка не превышает 14%). Система не уперлась в вычисления.
|
||||
Причина плато: Задержки на постоянное открытие новых соединений (Connection Churn). По умолчанию Nginx работает с upstream по протоколу HTTP/1.0 и закрывает TCP-сокет после каждого запроса (`Connection: close`). При росте числа реплик до 4 накладные расходы на TCP 3-way handshake к 4 разным адресам и фрагментация сетевых сокетов превышают выгоду от параллелизма.
|
||||
|
||||
---
|
||||
|
||||
### 4. Реализованное подтверждённое улучшение: Nginx Upstream Keep-Alive
|
||||
Реализация:
|
||||
В `nginx/nginx.conf` внедрен пул постоянных Keep-Alive соединений к репликам Uvicorn:
|
||||
- Добавлена директива `keepalive 64;` в секцию `upstream api_cluster`.
|
||||
- Включен протокол `proxy_http_version 1.1;` и сброшен заголовок `proxy_set_header Connection "";`.
|
||||
|
||||
Результаты сравнения (2 реплики, одинаковый профиль нагрузки):
|
||||
Метрика | До улучшения (HTTP/1.0 close) | После улучшения (Keep-Alive 64) | Изменение
|
||||
-------------------------------------------------------------------------------------------------
|
||||
RPS | 147.2 | 150.3 | +2.1% (+3.1 RPS)
|
||||
p50 Latency (ms) | 52.3 | 51.2 | -1.1 ms
|
||||
p95 Latency (ms) | 66.8 | 63.3 | -3.5 ms (улучшение)
|
||||
p99 Latency (ms) | 70.1 | 69.0 | -1.1 ms (< 70 ms)
|
||||
Ошибки | 0 | 0 | 0
|
||||
|
||||
Подтверждение: Переиспользование TCP-сокетов сократило задержки рукопожатий, снизило хвостовую задержку p95 на 3.5 мс и увеличило пропускную способность системы.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Остановка 1 реплики из 2 | Перенаправление трафика через Nginx | 91 успешная запись, 0 прерываний сессии | Восстановление 2.719 сек, потерь нет |
|
||||
| Рестарт всего стека | Полная сохранность сессий и сообщений | Сессии и переписка валидны после подъема | Восстановление < 3 сек, потерь нет |
|
||||
| Внедрение Keep-Alive в Nginx | Снижение задержек и рост RPS | Рост со 147.2 до 150.3 RPS, p95 упал с 66.8 до 63.3 ms | Потерь нет, эффект подтвержден |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Ограничения:
|
||||
1. Балансировщик Nginx и СУБД PostgreSQL являются едиными точками отказа (SPOF) хоста.
|
||||
2. Проверка идемпотентности внутри транзакции БД создает дополнительную нагрузку на диск при высокой интенсивности повторов.
|
||||
|
||||
Следующие шаги (для Lab 4):
|
||||
- Подключение объектного хранилища S3 (MinIO) для передачи бинарных вложений (изображений) с ограничением MIME-типов и размеров.
|
||||
- Реализация фоновой обработки изображений через воркеры.
|
||||
+110
@@ -0,0 +1,110 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.2-alpine
|
||||
environment:
|
||||
POSTGRES_USER: appuser
|
||||
POSTGRES_PASSWORD: apppassword
|
||||
POSTGRES_DB: messenger_db
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U appuser -d messenger_db"]
|
||||
interval: 3s
|
||||
timeout: 2s
|
||||
retries: 5
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "1.00"
|
||||
memory: 512M
|
||||
restart: unless-stopped
|
||||
|
||||
redis:
|
||||
image: redis:7.2.4-alpine
|
||||
command: redis-server --appendonly yes
|
||||
volumes:
|
||||
- redis_data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 3s
|
||||
timeout: 2s
|
||||
retries: 5
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 256M
|
||||
restart: unless-stopped
|
||||
|
||||
migrator:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
command: ["python", "src/migrate.py"]
|
||||
environment:
|
||||
DATABASE_URL: postgresql://appuser:apppassword@postgres:5432/messenger_db
|
||||
volumes:
|
||||
- ./migrations:/app/migrations:ro
|
||||
- ./src:/app/src:ro
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
restart: "no"
|
||||
|
||||
api:
|
||||
build:
|
||||
context: .
|
||||
dockerfile: Dockerfile
|
||||
image: mtusi-messenger:lab3
|
||||
command: ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"]
|
||||
env_file:
|
||||
- .env
|
||||
volumes:
|
||||
- ./secrets:/run/secrets:ro
|
||||
- ./src:/app/src:ro
|
||||
- ./scripts:/app/scripts:ro
|
||||
depends_on:
|
||||
postgres:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
migrator:
|
||||
condition: service_completed_successfully
|
||||
healthcheck:
|
||||
test: ["CMD", "curl", "-f", "http://localhost:8000/health/live"]
|
||||
interval: 3s
|
||||
timeout: 2s
|
||||
retries: 3
|
||||
deploy:
|
||||
replicas: 2
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 256M
|
||||
restart: unless-stopped
|
||||
|
||||
load_balancer:
|
||||
image: nginx:1.25.4-alpine
|
||||
volumes:
|
||||
- ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
|
||||
ports:
|
||||
- "8080:8080"
|
||||
depends_on:
|
||||
- api
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "curl -f http://localhost:8080/health/live || exit 1"]
|
||||
interval: 3s
|
||||
timeout: 2s
|
||||
retries: 3
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: "0.50"
|
||||
memory: 128M
|
||||
restart: unless-stopped
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
name: mtusi2026lab3_postgres_data
|
||||
redis_data:
|
||||
name: mtusi2026lab3_redis_data
|
||||
@@ -0,0 +1,41 @@
|
||||
-- Таблица пользователей
|
||||
CREATE TABLE IF NOT EXISTS users (
|
||||
id UUID PRIMARY KEY,
|
||||
username VARCHAR(32) UNIQUE NOT NULL,
|
||||
display_name VARCHAR(100) NOT NULL,
|
||||
password_hash TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
-- Таблица чатов
|
||||
CREATE TABLE IF NOT EXISTS chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title VARCHAR(100) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
-- Таблица участников чатов (Many-to-Many)
|
||||
CREATE TABLE IF NOT EXISTS chat_members (
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
-- Таблица сообщений
|
||||
CREATE TABLE IF NOT EXISTS messages (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
text VARCHAR(4000) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
|
||||
-- Индексы для HighLoad и пагинации
|
||||
CREATE INDEX IF NOT EXISTS idx_messages_chat_created_id
|
||||
ON messages (chat_id, created_at ASC, id ASC);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_chat_members_user
|
||||
ON chat_members (user_id);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_chats_created_id
|
||||
ON chats (created_at ASC, id ASC);
|
||||
@@ -0,0 +1,12 @@
|
||||
CREATE TABLE IF NOT EXISTS idempotency_keys (
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
key VARCHAR(128) NOT NULL,
|
||||
request_hash VARCHAR(64) NOT NULL,
|
||||
response_code INT NOT NULL,
|
||||
response_body JSONB NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL,
|
||||
PRIMARY KEY (user_id, chat_id, key)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS idx_idempotency_created_at ON idempotency_keys (created_at);
|
||||
@@ -0,0 +1,35 @@
|
||||
events {
|
||||
worker_connections 1024;
|
||||
}
|
||||
|
||||
http {
|
||||
upstream api_cluster {
|
||||
server api:8000 max_fails=2 fail_timeout=5s;
|
||||
# УЛУЧШЕНИЕ: пул постоянных Keep-Alive соединений к репликам
|
||||
keepalive 64;
|
||||
}
|
||||
|
||||
server {
|
||||
listen 8080;
|
||||
|
||||
location / {
|
||||
proxy_pass http://api_cluster;
|
||||
|
||||
# УЛУЧШЕНИЕ: использование HTTP/1.1 и переиспользование сокетов
|
||||
proxy_http_version 1.1;
|
||||
proxy_set_header Connection "";
|
||||
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
proxy_set_header X-Request-Id $http_x_request_id;
|
||||
|
||||
proxy_next_upstream error timeout http_502 http_503 http_504 non_idempotent;
|
||||
proxy_next_upstream_timeout 10s;
|
||||
proxy_next_upstream_tries 3;
|
||||
|
||||
proxy_connect_timeout 2s;
|
||||
proxy_read_timeout 10s;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,27 @@
|
||||
annotated-types==0.6.0
|
||||
anyio==4.3.0
|
||||
argon2-cffi==23.1.0
|
||||
argon2-cffi-bindings==21.2.0
|
||||
asyncpg==0.29.0
|
||||
certifi==2024.2.2
|
||||
cffi==1.16.0
|
||||
click==8.1.7
|
||||
colorama==0.4.6
|
||||
fastapi==0.109.2
|
||||
h11==0.14.0
|
||||
httpcore==1.0.4
|
||||
httpx==0.27.0
|
||||
idna==3.6
|
||||
iniconfig==2.0.0
|
||||
packaging==24.0
|
||||
pluggy==1.4.0
|
||||
pycparser==2.21
|
||||
pydantic==2.6.1
|
||||
pydantic_core==2.16.2
|
||||
pytest==8.0.0
|
||||
pytest-asyncio==0.23.5
|
||||
redis==5.0.3
|
||||
sniffio==1.3.1
|
||||
starlette==0.36.3
|
||||
typing_extensions==4.9.0
|
||||
uvicorn==0.27.1
|
||||
@@ -0,0 +1,68 @@
|
||||
import time
|
||||
import base64
|
||||
import uuid
|
||||
import httpx
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
BASE_URL = "http://localhost:8080"
|
||||
|
||||
def get_client():
|
||||
return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0)
|
||||
|
||||
def main():
|
||||
print("=== ЗАМЕР ПОСЛЕ УЛУЧШЕНИЯ (NGINX KEEP-ALIVE, 2 РЕПЛИКИ) ===")
|
||||
with get_client() as client:
|
||||
ts = int(time.time() * 1000)
|
||||
uname = f"after_{ts}"
|
||||
pw = "password_12345678"
|
||||
client.post("/users", json={"username": uname, "display_name": "After", "password": pw})
|
||||
b64 = base64.b64encode(f"{uname}:{pw}".encode()).decode()
|
||||
token = client.post("/auth/sessions", headers={"Authorization": f"Basic {b64}"}).json()["token"]
|
||||
uid = client.get("/users/me", headers={"Authorization": f"Bearer {token}"}).json()["id"]
|
||||
h = {"Authorization": f"Bearer {token}"}
|
||||
chat_id = client.post("/chats", json={"title": "After Chat", "member_ids": [uid]}, headers=h).json()["id"]
|
||||
|
||||
print("Запуск нагрузки (10 секунд, concurrency=8)...")
|
||||
stop_at = time.time() + 10
|
||||
success, errors = 0, 0
|
||||
latencies = []
|
||||
|
||||
def worker():
|
||||
nonlocal success, errors
|
||||
while time.time() < stop_at:
|
||||
t0 = time.time()
|
||||
try:
|
||||
idem = f"after_{uuid.uuid4()}"
|
||||
r = client.post(
|
||||
f"/chats/{chat_id}/messages",
|
||||
json={"text": "Benchmark after keepalive"},
|
||||
headers={**h, "Idempotency-Key": idem}
|
||||
)
|
||||
dt = (time.time() - t0) * 1000
|
||||
if r.status_code == 201:
|
||||
success += 1
|
||||
latencies.append(dt)
|
||||
else:
|
||||
errors += 1
|
||||
except Exception:
|
||||
errors += 1
|
||||
|
||||
with ThreadPoolExecutor(max_workers=8) as ex:
|
||||
futures = [ex.submit(worker) for _ in range(8)]
|
||||
for f in futures:
|
||||
f.result()
|
||||
|
||||
latencies.sort()
|
||||
n = len(latencies)
|
||||
p50 = latencies[int(n * 0.50)] if n else 0
|
||||
p95 = latencies[int(n * 0.95)] if n else 0
|
||||
p99 = latencies[int(n * 0.99)] if n else 0
|
||||
rps = success / 10.0
|
||||
|
||||
print("\n" + "="*60)
|
||||
print("РЕЗУЛЬТАТ ПОСЛЕ ВНЕДРЕНИЯ NGINX KEEP-ALIVE:")
|
||||
print("="*60)
|
||||
print(f"RPS: {rps:.1f} | p50: {p50:.1f} ms | p95: {p95:.1f} ms | p99: {p99:.1f} ms | Ошибки: {errors}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,8 @@
|
||||
@echo off
|
||||
docker compose restart
|
||||
:wait_loop
|
||||
curl -s -f http://localhost:8080/health/ready >nul 2>&1
|
||||
if errorlevel 1 (
|
||||
timeout /t 1 /nobreak >nul
|
||||
goto wait_loop
|
||||
)
|
||||
@@ -0,0 +1,9 @@
|
||||
#!/bin/sh
|
||||
set -e
|
||||
echo "Restarting stack while preserving volumes..."
|
||||
docker compose restart
|
||||
echo "Waiting for API readiness..."
|
||||
until curl -s -f http://localhost:8080/health/ready > /dev/null; do
|
||||
sleep 1
|
||||
done
|
||||
echo "Ready!"
|
||||
@@ -0,0 +1,7 @@
|
||||
@echo off
|
||||
for /f "tokens=*" %%i in ('docker compose ps -q api') do (
|
||||
echo Stopping API replica %%i...
|
||||
docker stop %%i
|
||||
goto :done
|
||||
)
|
||||
:done
|
||||
@@ -0,0 +1,10 @@
|
||||
#!/bin/sh
|
||||
set -e
|
||||
TARGET=$(docker compose ps -q api | head -n 1)
|
||||
if [ -n "$TARGET" ]; then
|
||||
echo "Остановка реплики $TARGET..."
|
||||
docker stop "$TARGET"
|
||||
else
|
||||
echo "Нет запущенных API-контейнеров"
|
||||
exit 1
|
||||
fi
|
||||
@@ -0,0 +1,177 @@
|
||||
import os
|
||||
import sys
|
||||
import time
|
||||
import base64
|
||||
import uuid
|
||||
import httpx
|
||||
import subprocess
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
BASE_URL = "http://localhost:8080"
|
||||
|
||||
def get_client():
|
||||
return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0)
|
||||
|
||||
def get_container_ids():
|
||||
res = subprocess.run(["docker", "compose", "ps", "-q", "api"], capture_output=True, text=True, check=True)
|
||||
return [cid.strip() for cid in res.stdout.strip().splitlines() if cid.strip()]
|
||||
|
||||
def get_docker_stats():
|
||||
# Собираем реальную загрузку CPU и памяти контейнеров
|
||||
cmd = ["docker", "stats", "--no-stream", "--format", "{{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"]
|
||||
res = subprocess.run(cmd, capture_output=True, text=True)
|
||||
stats = {}
|
||||
for line in res.stdout.strip().splitlines():
|
||||
parts = line.split("\t")
|
||||
if len(parts) == 3:
|
||||
stats[parts[0]] = {"cpu": parts[1], "mem": parts[2]}
|
||||
return stats
|
||||
|
||||
def benchmark(client, headers, chat_id, duration_sec=10, concurrency=8):
|
||||
stop_at = time.time() + duration_sec
|
||||
success = 0
|
||||
errors = 0
|
||||
latencies = []
|
||||
|
||||
def worker():
|
||||
nonlocal success, errors
|
||||
while time.time() < stop_at:
|
||||
t0 = time.time()
|
||||
try:
|
||||
idem = f"bench_{uuid.uuid4()}"
|
||||
r = client.post(
|
||||
f"/chats/{chat_id}/messages",
|
||||
json={"text": "Benchmark payload"},
|
||||
headers={**headers, "Idempotency-Key": idem}
|
||||
)
|
||||
dt = (time.time() - t0) * 1000
|
||||
if r.status_code == 201:
|
||||
success += 1
|
||||
latencies.append(dt)
|
||||
else:
|
||||
errors += 1
|
||||
except Exception:
|
||||
errors += 1
|
||||
|
||||
# Запускаем сбор статистики в середине теста
|
||||
mid_stats = {}
|
||||
with ThreadPoolExecutor(max_workers=concurrency) as ex:
|
||||
futures = [ex.submit(worker) for _ in range(concurrency)]
|
||||
time.sleep(duration_sec / 2)
|
||||
mid_stats = get_docker_stats()
|
||||
for f in futures:
|
||||
f.result()
|
||||
|
||||
latencies.sort()
|
||||
n = len(latencies)
|
||||
p50 = latencies[int(n * 0.50)] if n else 0
|
||||
p95 = latencies[int(n * 0.95)] if n else 0
|
||||
p99 = latencies[int(n * 0.99)] if n else 0
|
||||
rps = success / duration_sec
|
||||
return rps, p50, p95, p99, errors, mid_stats
|
||||
|
||||
def set_replicas_and_limits(replicas, cpus_per_rep, mem_per_rep):
|
||||
print(f"\n>>> Масштабирование: {replicas} реплик (по {cpus_per_rep} CPU, {mem_per_rep} RAM каждая)...")
|
||||
subprocess.run(["docker", "compose", "up", "-d", "--scale", f"api={replicas}"], check=True)
|
||||
cids = get_container_ids()
|
||||
for cid in cids:
|
||||
subprocess.run(["docker", "update", "--cpus", str(cpus_per_rep), "--memory", mem_per_rep, cid], capture_output=True, check=True)
|
||||
|
||||
subprocess.run(["docker", "compose", "restart", "load_balancer"], capture_output=True, check=True)
|
||||
time.sleep(4)
|
||||
with get_client() as c:
|
||||
for _ in range(15):
|
||||
try:
|
||||
if c.get("/health/ready").status_code == 200:
|
||||
break
|
||||
except Exception:
|
||||
pass
|
||||
time.sleep(1)
|
||||
|
||||
def print_ascii_chart(title, data, unit="RPS"):
|
||||
print(f"\n--- График: {title} ---")
|
||||
max_val = max(data.values()) if data else 1
|
||||
for k, v in data.items():
|
||||
bar_len = int((v / max_val) * 30)
|
||||
bar = "█" * bar_len
|
||||
print(f"{k:<12} | {bar:<30} {v:.1f} {unit}")
|
||||
|
||||
def main():
|
||||
print("ТРЕК 1: ПОЛНОЕ ИССЛЕДОВАНИЕ ЦЕНЫ МАСШТАБИРОВАНИЯ")
|
||||
|
||||
with get_client() as client:
|
||||
ts = int(time.time() * 1000)
|
||||
uname = f"perf_{ts}"
|
||||
pw = "password_12345678"
|
||||
client.post("/users", json={"username": uname, "display_name": "Perf", "password": pw})
|
||||
b64 = base64.b64encode(f"{uname}:{pw}".encode()).decode()
|
||||
token = client.post("/auth/sessions", headers={"Authorization": f"Basic {b64}"}).json()["token"]
|
||||
uid = client.get("/users/me", headers={"Authorization": f"Bearer {token}"}).json()["id"]
|
||||
h = {"Authorization": f"Bearer {token}"}
|
||||
chat_id = client.post("/chats", json={"title": "Perf Chat", "member_ids": [uid]}, headers=h).json()["id"]
|
||||
|
||||
# СЕРИЯ 1: ФИКСИРОВАННЫЙ СУММАРНЫЙ БЮДЖЕТ (1.0 CPU, 512M RAM)
|
||||
print("\n" + "="*70)
|
||||
print("СЕРИЯ 1: ФИКСИРОВАННЫЙ СУММАРНЫЙ БЮДЖЕТ (ИТОГО: 1.0 CPU, 512MB RAM)")
|
||||
print("="*70)
|
||||
fixed_plan = [
|
||||
(1, 1.00, "512m"),
|
||||
(2, 0.50, "256m"),
|
||||
(4, 0.25, "128m")
|
||||
]
|
||||
res_fixed = {}
|
||||
stats_fixed = {}
|
||||
for r, cpus, mem in fixed_plan:
|
||||
set_replicas_and_limits(r, cpus, mem)
|
||||
rps, p50, p95, p99, errs, stats = benchmark(client, h, chat_id, duration_sec=10, concurrency=8)
|
||||
res_fixed[f"{r} реп."] = rps
|
||||
stats_fixed[r] = (rps, p50, p95, p99, errs, stats)
|
||||
print(f"[{r} реп. по {cpus} CPU]: {rps:.1f} RPS | p50={p50:.1f}ms | p99={p99:.1f}ms | err={errs}")
|
||||
|
||||
# СЕРИЯ 2: РОСТ РЕСУРСОВ (ПО 0.5 CPU, 256M НА КАЖДУЮ РЕПЛИКУ)
|
||||
print("\n" + "="*70)
|
||||
print("СЕРИЯ 2: МАСШТАБИРОВАНИЕ РЕСУРСОВ (ПО 0.5 CPU, 256MB НА РЕПЛИКУ)")
|
||||
print("="*70)
|
||||
scaled_plan = [
|
||||
(1, 0.50, "256m"),
|
||||
(2, 0.50, "256m"),
|
||||
(4, 0.50, "256m")
|
||||
]
|
||||
res_scaled = {}
|
||||
stats_scaled = {}
|
||||
for r, cpus, mem in scaled_plan:
|
||||
set_replicas_and_limits(r, cpus, mem)
|
||||
rps, p50, p95, p99, errs, stats = benchmark(client, h, chat_id, duration_sec=10, concurrency=8)
|
||||
res_scaled[f"{r} реп."] = rps
|
||||
stats_scaled[r] = (rps, p50, p95, p99, errs, stats)
|
||||
print(f"[{r} реп. (суммарно {r*0.5:.1f} CPU)]: {rps:.1f} RPS | p50={p50:.1f}ms | p99={p99:.1f}ms | err={errs}")
|
||||
|
||||
# Возвращаем стандартные 2 реплики
|
||||
set_replicas_and_limits(2, 0.50, "256m")
|
||||
|
||||
print("\n" + "#"*70)
|
||||
print("ИТОГОВЫЕ ТАБЛИЦЫ ДЛЯ REPORT.MD")
|
||||
print("#"*70)
|
||||
|
||||
print("\n1. СЕРИЯ 1 (ФИКСИРОВАННЫЙ БЮДЖЕТ 1.0 CPU, 512MB RAM):")
|
||||
print(f"{'Реплики':<10} | {'CPU на реп.':<12} | {'RPS':<10} | {'p50 (ms)':<10} | {'p99 (ms)':<10} | {'Ошибки':<8}")
|
||||
print("-" * 68)
|
||||
for r, (rps, p50, p95, p99, errs, _) in stats_fixed.items():
|
||||
print(f"{r:<10} | {1.0/r:<12.2f} | {rps:<10.1f} | {p50:<10.1f} | {p99:<10.1f} | {errs:<8}")
|
||||
|
||||
print_ascii_chart("RPS при фиксированном суммарном бюджете (1.0 CPU)", res_fixed)
|
||||
|
||||
print("\n2. СЕРИЯ 2 (РОСТ РЕСУРСОВ: ПО 0.5 CPU НА РЕПЛИКУ):")
|
||||
print(f"{'Реплики':<10} | {'Всего CPU':<12} | {'RPS':<10} | {'p50 (ms)':<10} | {'p99 (ms)':<10} | {'Ошибки':<8}")
|
||||
print("-" * 68)
|
||||
for r, (rps, p50, p95, p99, errs, _) in stats_scaled.items():
|
||||
print(f"{r:<10} | {r*0.5:<12.1f} | {rps:<10.1f} | {p50:<10.1f} | {p99:<10.1f} | {errs:<8}")
|
||||
|
||||
print_ascii_chart("RPS при масштабировании ресурсов (+0.5 CPU на реплику)", res_scaled)
|
||||
|
||||
print("\n3. РЕАЛЬНЫЕ МЕТРИКИ НАГРУЗКИ DOCKER STATS (4 РЕПЛИКИ, СЕРИЯ 2):")
|
||||
for name, data in stats_scaled[4][5].items():
|
||||
print(f" - {name}: CPU = {data['cpu']}, Память = {data['mem']}")
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
+580
@@ -0,0 +1,580 @@
|
||||
import os
|
||||
import re
|
||||
import uuid
|
||||
import base64
|
||||
import secrets
|
||||
import hashlib
|
||||
import json
|
||||
from datetime import datetime, timezone, timedelta
|
||||
from typing import List, Optional
|
||||
|
||||
import asyncpg
|
||||
import redis.asyncio as aioredis
|
||||
from argon2 import PasswordHasher
|
||||
from argon2.exceptions import VerifyMismatchError
|
||||
from fastapi import FastAPI, Request, Response, Header, HTTPException, Depends
|
||||
from fastapi.responses import JSONResponse
|
||||
from fastapi.exceptions import RequestValidationError
|
||||
from starlette.exceptions import HTTPException as StarletteHTTPException
|
||||
from pydantic import BaseModel, Field, constr, field_validator, ConfigDict
|
||||
|
||||
def get_secret_or_env(file_var: str, default: str) -> str:
|
||||
path = os.getenv(file_var)
|
||||
if path and os.path.exists(path):
|
||||
with open(path, "r", encoding="utf-8") as f:
|
||||
return f.read().strip()
|
||||
return default
|
||||
|
||||
DATABASE_URL = get_secret_or_env("DATABASE_URL_FILE", "postgresql://appuser:apppassword@postgres:5432/messenger_db")
|
||||
CACHE_URL = get_secret_or_env("CACHE_URL_FILE", "redis://redis:6379/0")
|
||||
SESSION_TTL_SECONDS = int(os.getenv("SESSION_TTL_SECONDS", "3600"))
|
||||
IDEMPOTENCY_TTL_SECONDS = int(os.getenv("IDEMPOTENCY_TTL_SECONDS", "86400"))
|
||||
INSTANCE_ID = str(uuid.uuid4())
|
||||
|
||||
IDEMPOTENCY_REGEX = re.compile(r"^[A-Za-z0-9._:-]{1,128}$")
|
||||
|
||||
ph = PasswordHasher()
|
||||
db_pool: Optional[asyncpg.Pool] = None
|
||||
redis_client: Optional[aioredis.Redis] = None
|
||||
|
||||
def to_rfc3339(dt: datetime) -> str:
|
||||
if dt.tzinfo is None:
|
||||
dt = dt.replace(tzinfo=timezone.utc)
|
||||
return dt.astimezone(timezone.utc).isoformat().replace("+00:00", "Z")
|
||||
|
||||
class CreateUserRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
username: constr(pattern=r"^[a-z0-9_]{3,32}$")
|
||||
display_name: str = Field(min_length=1, max_length=100)
|
||||
password: str = Field(min_length=12, max_length=128)
|
||||
|
||||
@field_validator("display_name")
|
||||
@classmethod
|
||||
def validate_name(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
raise ValueError("display_name cannot be blank")
|
||||
return v
|
||||
|
||||
class CreateChatRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
title: str = Field(min_length=1, max_length=100)
|
||||
member_ids: List[str] = Field(min_length=1, max_length=100)
|
||||
|
||||
@field_validator("title")
|
||||
@classmethod
|
||||
def validate_title(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
raise ValueError("title cannot be blank")
|
||||
return v
|
||||
|
||||
@field_validator("member_ids")
|
||||
@classmethod
|
||||
def validate_members(cls, v: List[str]) -> List[str]:
|
||||
if len(v) != len(set(v)):
|
||||
raise ValueError("Duplicate members")
|
||||
for m in v:
|
||||
try:
|
||||
uuid.UUID(m)
|
||||
except Exception:
|
||||
raise ValueError(f"Invalid member UUID {m}")
|
||||
return v
|
||||
|
||||
class CreateMessageRequest(BaseModel):
|
||||
model_config = ConfigDict(extra="forbid")
|
||||
text: str = Field(min_length=1, max_length=4000)
|
||||
|
||||
@field_validator("text")
|
||||
@classmethod
|
||||
def validate_text(cls, v: str) -> str:
|
||||
if not v.strip():
|
||||
raise ValueError("text cannot be blank")
|
||||
return v
|
||||
|
||||
app = FastAPI(title="MTUSI Messenger Lab 3")
|
||||
|
||||
@app.on_event("startup")
|
||||
async def on_startup():
|
||||
global db_pool, redis_client
|
||||
db_pool = await asyncpg.create_pool(
|
||||
DATABASE_URL,
|
||||
min_size=2,
|
||||
max_size=20,
|
||||
command_timeout=10.0
|
||||
)
|
||||
redis_client = aioredis.from_url(CACHE_URL, decode_responses=True)
|
||||
|
||||
@app.on_event("shutdown")
|
||||
async def on_shutdown():
|
||||
if db_pool:
|
||||
await db_pool.close()
|
||||
if redis_client:
|
||||
await redis_client.close()
|
||||
|
||||
@app.middleware("http")
|
||||
async def add_headers(request: Request, call_next):
|
||||
req_id = request.headers.get("X-Request-Id") or str(uuid.uuid4())
|
||||
request.state.request_id = req_id
|
||||
try:
|
||||
response = await call_next(request)
|
||||
except Exception:
|
||||
return generate_error(req_id, "internal_error", "Internal Server Error", 500)
|
||||
response.headers["X-Request-Id"] = req_id
|
||||
response.headers["X-Instance-Id"] = INSTANCE_ID
|
||||
return response
|
||||
|
||||
def generate_error(req_id: str, code: str, message: str, status_code: int, headers: dict = None):
|
||||
h = headers or {}
|
||||
h["X-Request-Id"] = req_id
|
||||
h["X-Instance-Id"] = INSTANCE_ID
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={"error": {"code": code, "message": message, "request_id": req_id}},
|
||||
headers=h
|
||||
)
|
||||
|
||||
@app.exception_handler(StarletteHTTPException)
|
||||
async def http_exception_handler(request: Request, exc: StarletteHTTPException):
|
||||
code_map = {400: "invalid_request", 401: "unauthorized", 403: "forbidden", 404: "not_found", 409: "conflict", 503: "unavailable"}
|
||||
code = code_map.get(exc.status_code, "internal_error")
|
||||
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
h = getattr(exc, "headers", None) or {}
|
||||
return generate_error(req_id, code, exc.detail or "Error", exc.status_code, h)
|
||||
|
||||
@app.exception_handler(RequestValidationError)
|
||||
async def validation_exception_handler(request: Request, exc: RequestValidationError):
|
||||
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
return generate_error(req_id, "invalid_request", "Validation error", 400)
|
||||
|
||||
@app.exception_handler(Exception)
|
||||
async def generic_exception_handler(request: Request, exc: Exception):
|
||||
req_id = getattr(request.state, "request_id", str(uuid.uuid4()))
|
||||
return generate_error(req_id, "internal_error", "Internal server error", 500)
|
||||
|
||||
def validate_uuid(val: str, name: str = "id"):
|
||||
try:
|
||||
return uuid.UUID(val)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail=f"Invalid {name} UUID format")
|
||||
|
||||
async def get_current_user(authorization: Optional[str] = Header(None)) -> dict:
|
||||
if not authorization or not authorization.startswith("Bearer "):
|
||||
raise HTTPException(
|
||||
status_code=401,
|
||||
detail="Missing or invalid Bearer token",
|
||||
headers={"WWW-Authenticate": 'Bearer realm="messenger"'}
|
||||
)
|
||||
token = authorization.split(" ", 1)[1].strip()
|
||||
if not token or not redis_client or not db_pool:
|
||||
raise HTTPException(status_code=401, detail="Unauthorized", headers={"WWW-Authenticate": 'Bearer realm="messenger"'})
|
||||
|
||||
try:
|
||||
user_id = await redis_client.get(f"session:{token}")
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Session store unavailable")
|
||||
|
||||
if not user_id:
|
||||
raise HTTPException(status_code=401, detail="Session expired or invalid", headers={"WWW-Authenticate": 'Bearer realm="messenger"'})
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
row = await conn.fetchrow("SELECT id, username, display_name, created_at FROM users WHERE id = $1", uuid.UUID(user_id))
|
||||
if not row:
|
||||
raise HTTPException(status_code=401, detail="User not found", headers={"WWW-Authenticate": 'Bearer realm="messenger"'})
|
||||
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": to_rfc3339(row["created_at"])
|
||||
}
|
||||
|
||||
@app.get("/health/live")
|
||||
async def health_live():
|
||||
return {"status": "ok"}
|
||||
|
||||
@app.get("/health/ready")
|
||||
async def health_ready():
|
||||
try:
|
||||
if not db_pool or not redis_client:
|
||||
raise Exception("Pools not ready")
|
||||
async with db_pool.acquire() as conn:
|
||||
await conn.fetchval("SELECT 1")
|
||||
await redis_client.ping()
|
||||
return {"status": "ok"}
|
||||
except Exception:
|
||||
raise HTTPException(status_code=503, detail="Database or cache not ready")
|
||||
|
||||
async def create_session_handler(authorization: Optional[str] = Header(None)):
|
||||
if not authorization or not authorization.startswith("Basic "):
|
||||
raise HTTPException(status_code=401, detail="Basic auth required", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
|
||||
try:
|
||||
raw_b64 = authorization.split(" ", 1)[1]
|
||||
decoded = base64.b64decode(raw_b64).decode("utf-8")
|
||||
username, password = decoded.split(":", 1)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=401, detail="Invalid Basic header", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
row = await conn.fetchrow("SELECT id, username, display_name, password_hash, created_at FROM users WHERE username = $1", username)
|
||||
|
||||
if not row:
|
||||
raise HTTPException(status_code=401, detail="Invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
|
||||
|
||||
try:
|
||||
ph.verify(row["password_hash"], password)
|
||||
except VerifyMismatchError:
|
||||
raise HTTPException(status_code=401, detail="Invalid credentials", headers={"WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"'})
|
||||
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL_SECONDS)
|
||||
await redis_client.set(f"session:{token}", str(row["id"]), ex=SESSION_TTL_SECONDS)
|
||||
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content={
|
||||
"token": token,
|
||||
"token_type": "Bearer",
|
||||
"expires_at": to_rfc3339(expires_at),
|
||||
"user": {
|
||||
"id": str(row["id"]),
|
||||
"username": row["username"],
|
||||
"display_name": row["display_name"],
|
||||
"created_at": to_rfc3339(row["created_at"])
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
@app.post("/auth/sessions", status_code=201)
|
||||
@app.post("/api/v1/auth/sessions", status_code=201)
|
||||
async def create_session(authorization: Optional[str] = Header(None)):
|
||||
return await create_session_handler(authorization)
|
||||
|
||||
async def delete_session_handler(authorization: Optional[str] = Header(None)):
|
||||
if not authorization or not authorization.startswith("Bearer "):
|
||||
raise HTTPException(status_code=401, detail="Bearer token required", headers={"WWW-Authenticate": 'Bearer realm="messenger"'})
|
||||
token = authorization.split(" ", 1)[1].strip()
|
||||
exists = await redis_client.delete(f"session:{token}")
|
||||
if not exists:
|
||||
raise HTTPException(status_code=401, detail="Token already invalid", headers={"WWW-Authenticate": 'Bearer realm="messenger"'})
|
||||
return Response(status_code=204)
|
||||
|
||||
@app.delete("/auth/sessions/current", status_code=204)
|
||||
@app.delete("/api/v1/auth/sessions/current", status_code=204)
|
||||
async def delete_session(authorization: Optional[str] = Header(None)):
|
||||
return await delete_session_handler(authorization)
|
||||
|
||||
# --- USERS ---
|
||||
async def create_user_handler(req: CreateUserRequest):
|
||||
user_id = uuid.uuid4()
|
||||
now = datetime.now(timezone.utc)
|
||||
hashed_pw = ph.hash(req.password)
|
||||
|
||||
try:
|
||||
async with db_pool.acquire() as conn:
|
||||
await conn.execute(
|
||||
"INSERT INTO users (id, username, display_name, password_hash, created_at) VALUES ($1, $2, $3, $4, $5)",
|
||||
user_id, req.username, req.display_name, hashed_pw, now
|
||||
)
|
||||
except asyncpg.UniqueViolationError:
|
||||
raise HTTPException(status_code=409, detail="Username already taken")
|
||||
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content={
|
||||
"id": str(user_id),
|
||||
"username": req.username,
|
||||
"display_name": req.display_name,
|
||||
"created_at": to_rfc3339(now)
|
||||
}
|
||||
)
|
||||
|
||||
@app.post("/users", status_code=201)
|
||||
@app.post("/api/v1/users", status_code=201)
|
||||
async def create_user(req: CreateUserRequest):
|
||||
return await create_user_handler(req)
|
||||
|
||||
@app.get("/users/me")
|
||||
@app.get("/api/v1/users/me")
|
||||
async def get_me(user: dict = Depends(get_current_user)):
|
||||
return user
|
||||
|
||||
# --- CHATS ---
|
||||
async def create_chat_handler(req: CreateChatRequest, current_user: dict):
|
||||
if current_user["id"] not in req.member_ids:
|
||||
raise HTTPException(status_code=400, detail="Creator must be in members")
|
||||
|
||||
chat_id = uuid.uuid4()
|
||||
now = datetime.now(timezone.utc)
|
||||
member_uuids = [uuid.UUID(m) for m in req.member_ids]
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
async with conn.transaction():
|
||||
count = await conn.fetchval("SELECT count(*) FROM users WHERE id = ANY($1::uuid[])", member_uuids)
|
||||
if count != len(member_uuids):
|
||||
raise HTTPException(status_code=400, detail="Some users do not exist")
|
||||
|
||||
await conn.execute("INSERT INTO chats (id, title, created_at) VALUES ($1, $2, $3)", chat_id, req.title, now)
|
||||
await conn.executemany("INSERT INTO chat_members (chat_id, user_id) VALUES ($1, $2)", [(chat_id, m) for m in member_uuids])
|
||||
|
||||
return JSONResponse(
|
||||
status_code=201,
|
||||
content={
|
||||
"id": str(chat_id),
|
||||
"title": req.title,
|
||||
"member_ids": req.member_ids,
|
||||
"created_at": to_rfc3339(now)
|
||||
}
|
||||
)
|
||||
|
||||
@app.post("/chats", status_code=201)
|
||||
@app.post("/api/v1/chats", status_code=201)
|
||||
async def create_chat(req: CreateChatRequest, current_user: dict = Depends(get_current_user)):
|
||||
return await create_chat_handler(req, current_user)
|
||||
|
||||
async def list_chats_handler(limit: int, cursor: Optional[str], current_user: dict):
|
||||
if limit < 1 or limit > 100:
|
||||
raise HTTPException(status_code=400, detail="Invalid limit")
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
if cursor is not None:
|
||||
if cursor == "":
|
||||
raise HTTPException(status_code=400, detail="Cursor cannot be empty")
|
||||
try:
|
||||
raw = base64.b64decode(cursor).decode("utf-8")
|
||||
parts = raw.split("|")
|
||||
c_time_str, c_id_str = parts[-2], parts[-1]
|
||||
cursor_time = datetime.fromisoformat(c_time_str.replace("Z", "+00:00"))
|
||||
cursor_id = uuid.UUID(c_id_str)
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="Invalid cursor format")
|
||||
|
||||
query = """
|
||||
SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id::text) as member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id
|
||||
JOIN chat_members cm_all ON cm_all.chat_id = c.id
|
||||
WHERE cm.user_id = $1 AND (c.created_at, c.id) > ($2, $3)
|
||||
GROUP BY c.id, c.title, c.created_at
|
||||
ORDER BY c.created_at ASC, c.id ASC
|
||||
LIMIT $4
|
||||
"""
|
||||
rows = await conn.fetch(query, uuid.UUID(current_user["id"]), cursor_time, cursor_id, limit + 1)
|
||||
else:
|
||||
query = """
|
||||
SELECT c.id, c.title, c.created_at, array_agg(cm_all.user_id::text) as member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id
|
||||
JOIN chat_members cm_all ON cm_all.chat_id = c.id
|
||||
WHERE cm.user_id = $1
|
||||
GROUP BY c.id, c.title, c.created_at
|
||||
ORDER BY c.created_at ASC, c.id ASC
|
||||
LIMIT $2
|
||||
"""
|
||||
rows = await conn.fetch(query, uuid.UUID(current_user["id"]), limit + 1)
|
||||
|
||||
items = []
|
||||
for r in rows[:limit]:
|
||||
items.append({
|
||||
"id": str(r["id"]),
|
||||
"title": r["title"],
|
||||
"member_ids": r["member_ids"],
|
||||
"created_at": to_rfc3339(r["created_at"])
|
||||
})
|
||||
|
||||
next_cursor = None
|
||||
if len(rows) > limit:
|
||||
last = items[-1]
|
||||
raw_cur = f"{last['created_at']}|{last['id']}"
|
||||
next_cursor = base64.b64encode(raw_cur.encode("utf-8")).decode("utf-8")
|
||||
|
||||
return {"items": items, "next_cursor": next_cursor}
|
||||
|
||||
@app.get("/chats")
|
||||
@app.get("/api/v1/chats")
|
||||
async def list_chats(limit: int = 50, cursor: Optional[str] = None, current_user: dict = Depends(get_current_user)):
|
||||
return await list_chats_handler(limit, cursor, current_user)
|
||||
|
||||
async def get_chat_handler(chat_id: str, current_user: dict):
|
||||
cid = validate_uuid(chat_id, "chat_id")
|
||||
async with db_pool.acquire() as conn:
|
||||
row = await conn.fetchrow(
|
||||
"""
|
||||
SELECT c.id, c.title, c.created_at, array_agg(cm.user_id::text) as member_ids
|
||||
FROM chats c
|
||||
JOIN chat_members cm ON cm.chat_id = c.id
|
||||
WHERE c.id = $1
|
||||
GROUP BY c.id, c.title, c.created_at
|
||||
""",
|
||||
cid
|
||||
)
|
||||
if not row or current_user["id"] not in row["member_ids"]:
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
return {
|
||||
"id": str(row["id"]),
|
||||
"title": row["title"],
|
||||
"member_ids": row["member_ids"],
|
||||
"created_at": to_rfc3339(row["created_at"])
|
||||
}
|
||||
|
||||
@app.get("/chats/{chat_id}")
|
||||
@app.get("/api/v1/chats/{chat_id}")
|
||||
async def get_chat(chat_id: str, current_user: dict = Depends(get_current_user)):
|
||||
return await get_chat_handler(chat_id, current_user)
|
||||
|
||||
async def create_message_handler(chat_id: str, req: CreateMessageRequest, current_user: dict, idempotency_key: Optional[str]):
|
||||
# Проверка обязательного Idempotency-Key
|
||||
if not idempotency_key or not IDEMPOTENCY_REGEX.match(idempotency_key):
|
||||
raise HTTPException(status_code=400, detail="Missing or invalid Idempotency-Key header")
|
||||
|
||||
cid = validate_uuid(chat_id, "chat_id")
|
||||
uid = uuid.UUID(current_user["id"])
|
||||
|
||||
# Канонический хеш тела запроса
|
||||
body_dict = {"text": req.text}
|
||||
req_hash = hashlib.sha256(json.dumps(body_dict, sort_keys=True).encode("utf-8")).hexdigest()
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
# Проверка доступа к чату (первее всего)
|
||||
is_member = await conn.fetchval(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
||||
cid, uid
|
||||
)
|
||||
if not is_member:
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
# Атомарная проверка и сохранение идемпотентности в транзакции
|
||||
async with conn.transaction():
|
||||
existing = await conn.fetchrow(
|
||||
"""
|
||||
SELECT request_hash, response_code, response_body
|
||||
FROM idempotency_keys
|
||||
WHERE user_id = $1 AND chat_id = $2 AND key = $3
|
||||
FOR UPDATE
|
||||
""",
|
||||
uid, cid, idempotency_key
|
||||
)
|
||||
|
||||
if existing:
|
||||
# Если тело другое -> 409 Conflict
|
||||
if existing["request_hash"] != req_hash:
|
||||
raise HTTPException(status_code=409, detail="Idempotency key collision with different body")
|
||||
# Если тело то же -> возвращаем ранее сохраненный результат
|
||||
saved_body = json.loads(existing["response_body"]) if isinstance(existing["response_body"], str) else existing["response_body"]
|
||||
return JSONResponse(status_code=existing["response_code"], content=saved_body)
|
||||
|
||||
msg_id = uuid.uuid4()
|
||||
now = datetime.now(timezone.utc)
|
||||
res_content = {
|
||||
"id": str(msg_id),
|
||||
"chat_id": str(cid),
|
||||
"sender_id": current_user["id"],
|
||||
"text": req.text,
|
||||
"created_at": to_rfc3339(now)
|
||||
}
|
||||
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO messages (id, chat_id, sender_id, text, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5)
|
||||
""",
|
||||
msg_id, cid, uid, req.text, now
|
||||
)
|
||||
|
||||
await conn.execute(
|
||||
"""
|
||||
INSERT INTO idempotency_keys (user_id, chat_id, key, request_hash, response_code, response_body, created_at)
|
||||
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
||||
""",
|
||||
uid, cid, idempotency_key, req_hash, 201, json.dumps(res_content), now
|
||||
)
|
||||
|
||||
return JSONResponse(status_code=201, content=res_content)
|
||||
|
||||
@app.post("/chats/{chat_id}/messages", status_code=201)
|
||||
@app.post("/api/v1/chats/{chat_id}/messages", status_code=201)
|
||||
async def create_message(
|
||||
chat_id: str,
|
||||
req: CreateMessageRequest,
|
||||
current_user: dict = Depends(get_current_user),
|
||||
idempotency_key: Optional[str] = Header(None, alias="Idempotency-Key")
|
||||
):
|
||||
return await create_message_handler(chat_id, req, current_user, idempotency_key)
|
||||
|
||||
async def list_messages_handler(chat_id: str, limit: int, cursor: Optional[str], current_user: dict):
|
||||
cid = validate_uuid(chat_id, "chat_id")
|
||||
if limit < 1 or limit > 100:
|
||||
raise HTTPException(status_code=400, detail="Invalid limit")
|
||||
|
||||
async with db_pool.acquire() as conn:
|
||||
is_member = await conn.fetchval(
|
||||
"SELECT 1 FROM chat_members WHERE chat_id = $1 AND user_id = $2",
|
||||
cid, uuid.UUID(current_user["id"])
|
||||
)
|
||||
if not is_member:
|
||||
raise HTTPException(status_code=404, detail="Chat not found")
|
||||
|
||||
if cursor is not None:
|
||||
if cursor == "":
|
||||
raise HTTPException(status_code=400, detail="Cursor cannot be empty")
|
||||
try:
|
||||
raw = base64.b64decode(cursor).decode("utf-8")
|
||||
parts = raw.split("|")
|
||||
if len(parts) == 3:
|
||||
cur_chat_id, c_time_str, c_id_str = parts
|
||||
if cur_chat_id != str(cid):
|
||||
raise HTTPException(status_code=400, detail="Cursor belongs to another chat")
|
||||
elif len(parts) == 2:
|
||||
c_time_str, c_id_str = parts
|
||||
else:
|
||||
raise ValueError()
|
||||
cursor_time = datetime.fromisoformat(c_time_str.replace("Z", "+00:00"))
|
||||
cursor_id = uuid.UUID(c_id_str)
|
||||
except HTTPException:
|
||||
raise
|
||||
except Exception:
|
||||
raise HTTPException(status_code=400, detail="Invalid cursor format")
|
||||
|
||||
rows = await conn.fetch(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1 AND (created_at, id) > ($2, $3)
|
||||
ORDER BY created_at ASC, id ASC
|
||||
LIMIT $4
|
||||
""",
|
||||
cid, cursor_time, cursor_id, limit + 1
|
||||
)
|
||||
else:
|
||||
rows = await conn.fetch(
|
||||
"""
|
||||
SELECT id, chat_id, sender_id, text, created_at
|
||||
FROM messages
|
||||
WHERE chat_id = $1
|
||||
ORDER BY created_at ASC, id ASC
|
||||
LIMIT $2
|
||||
""",
|
||||
cid, limit + 1
|
||||
)
|
||||
|
||||
items = []
|
||||
for r in rows[:limit]:
|
||||
items.append({
|
||||
"id": str(r["id"]),
|
||||
"chat_id": str(r["chat_id"]),
|
||||
"sender_id": str(r["sender_id"]),
|
||||
"text": r["text"],
|
||||
"created_at": to_rfc3339(r["created_at"])
|
||||
})
|
||||
|
||||
next_cursor = None
|
||||
if len(rows) > limit:
|
||||
last = items[-1]
|
||||
raw_cur = f"{cid}|{last['created_at']}|{last['id']}"
|
||||
next_cursor = base64.b64encode(raw_cur.encode("utf-8")).decode("utf-8")
|
||||
|
||||
return {"items": items, "next_cursor": next_cursor}
|
||||
|
||||
@app.get("/chats/{chat_id}/messages")
|
||||
@app.get("/api/v1/chats/{chat_id}/messages")
|
||||
async def list_messages(chat_id: str, limit: int = 50, cursor: Optional[str] = None, current_user: dict = Depends(get_current_user)):
|
||||
return await list_messages_handler(chat_id, limit, cursor, current_user)
|
||||
@@ -0,0 +1,22 @@
|
||||
import os
|
||||
import asyncio
|
||||
import asyncpg
|
||||
|
||||
DATABASE_URL = os.getenv("DATABASE_URL", "postgresql://appuser:apppassword@postgres:5432/messenger_db")
|
||||
|
||||
async def main():
|
||||
print("Применение миграций базы данных...")
|
||||
conn = await asyncpg.connect(DATABASE_URL)
|
||||
migrations_dir = os.path.join(os.path.dirname(__file__), "..", "migrations")
|
||||
|
||||
sql_files = sorted([f for f in os.listdir(migrations_dir) if f.endswith(".sql")])
|
||||
for sql_file in sql_files:
|
||||
print(f"Выполнение: {sql_file}")
|
||||
with open(os.path.join(migrations_dir, sql_file), "r", encoding="utf-8") as f:
|
||||
await conn.execute(f.read())
|
||||
|
||||
await conn.close()
|
||||
print("Миграции успешно применены!")
|
||||
|
||||
if __name__ == "__main__":
|
||||
asyncio.run(main())
|
||||
@@ -0,0 +1,76 @@
|
||||
import base64
|
||||
import time
|
||||
import uuid
|
||||
import httpx
|
||||
import pytest
|
||||
|
||||
BASE_URL = "http://localhost:8080"
|
||||
|
||||
def get_client():
|
||||
return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0)
|
||||
|
||||
def get_auth_token(client, username, password):
|
||||
client.post("/users", json={"username": username, "display_name": "User", "password": password})
|
||||
b64 = base64.b64encode(f"{username}:{password}".encode("utf-8")).decode("utf-8")
|
||||
res = client.post("/auth/sessions", headers={"Authorization": f"Basic {b64}"})
|
||||
return res.json()["token"], res.json()["user"]["id"]
|
||||
|
||||
def test_missing_or_invalid_idempotency_key():
|
||||
with get_client() as client:
|
||||
ts = int(time.time() * 1000)
|
||||
token, uid = get_auth_token(client, f"u_idem_{ts}", "password_12345678")
|
||||
h = {"Authorization": f"Bearer {token}"}
|
||||
|
||||
chat = client.post("/chats", json={"title": "Chat", "member_ids": [uid]}, headers=h).json()
|
||||
cid = chat["id"]
|
||||
|
||||
# Отсутствие ключа -> 400
|
||||
r1 = client.post(f"/chats/{cid}/messages", json={"text": "hello"}, headers=h)
|
||||
assert r1.status_code == 400
|
||||
|
||||
# Недопустимые символы в ключе -> 400
|
||||
h_bad = {**h, "Idempotency-Key": "bad key with spaces!"}
|
||||
r2 = client.post(f"/chats/{cid}/messages", json={"text": "hello"}, headers=h_bad)
|
||||
assert r2.status_code == 400
|
||||
|
||||
def test_idempotency_retry_and_conflict():
|
||||
with get_client() as client:
|
||||
ts = int(time.time() * 1000)
|
||||
token, uid = get_auth_token(client, f"u_retry_{ts}", "password_12345678")
|
||||
h = {"Authorization": f"Bearer {token}"}
|
||||
|
||||
chat = client.post("/chats", json={"title": "Chat", "member_ids": [uid]}, headers=h).json()
|
||||
cid = chat["id"]
|
||||
key = f"key_{uuid.uuid4()}"
|
||||
h_idem = {**h, "Idempotency-Key": key}
|
||||
|
||||
# Первый успешный запрос -> 201
|
||||
r1 = client.post(f"/chats/{cid}/messages", json={"text": "Same text"}, headers=h_idem)
|
||||
assert r1.status_code == 201
|
||||
msg1 = r1.json()
|
||||
|
||||
# Повтор с тем же ключом и тем же телом -> 201 и то же самое сообщение
|
||||
r2 = client.post(f"/chats/{cid}/messages", json={"text": "Same text"}, headers=h_idem)
|
||||
assert r2.status_code == 201
|
||||
msg2 = r2.json()
|
||||
assert msg1["id"] == msg2["id"]
|
||||
|
||||
# Попытка отправить другой текст с тем же ключом -> 409 Conflict
|
||||
r3 = client.post(f"/chats/{cid}/messages", json={"text": "Different text"}, headers=h_idem)
|
||||
assert r3.status_code == 409
|
||||
|
||||
# В чате должно остаться ровно 1 сообщение (дубликат не создан)
|
||||
history = client.get(f"/chats/{cid}/messages", headers=h).json()["items"]
|
||||
assert len(history) == 1
|
||||
|
||||
def test_load_balancer_alternates_instances():
|
||||
with get_client() as client:
|
||||
instances = set()
|
||||
for _ in range(10):
|
||||
res = client.get("/health/live")
|
||||
assert res.status_code == 200
|
||||
inst_id = res.headers.get("X-Instance-Id")
|
||||
if inst_id:
|
||||
instances.add(inst_id)
|
||||
|
||||
assert len(instances) >= 2, f"Ожидалось >= 2 реплик, зафиксировано: {instances}"
|
||||
Reference in New Issue
Block a user