ЛР 3 — БВТ2304 — Борзов — на 5 #34
+5
-12
@@ -1,13 +1,6 @@
|
||||
# Copy to .env for your LOCAL synthetic test environment; never commit .env.
|
||||
# These are logical interface suggestions; map actual framework names in REPORT.md.
|
||||
APP_HOST=0.0.0.0
|
||||
APP_PORT=8080
|
||||
APP_ENV=lab
|
||||
# Локальные синтетические данные. Файл .env не добавляется в git.
|
||||
POSTGRES_DB=messenger
|
||||
POSTGRES_USER=messenger
|
||||
POSTGRES_PASSWORD=change-me-local
|
||||
SESSION_TTL_SECONDS=3600
|
||||
# Choose credentials locally. File paths contain no secret values.
|
||||
DATABASE_URL_FILE=/run/secrets/database_url
|
||||
# Optional on 3, required use on 4 in lab2; Redis OR Valkey:
|
||||
SESSION_STORE=postgres
|
||||
CACHE_URL_FILE=/run/secrets/cache_url
|
||||
API_REPLICAS=2
|
||||
IDEMPOTENCY_TTL_SECONDS=86400
|
||||
ENABLE_DEBUG_METRICS=1
|
||||
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
FROM python:3.12.8-slim-bookworm
|
||||
WORKDIR /app
|
||||
COPY requirements.txt .
|
||||
RUN pip install --no-cache-dir -r requirements.txt
|
||||
COPY app ./app
|
||||
COPY migrations ./migrations
|
||||
COPY scripts ./scripts
|
||||
RUN useradd --create-home --uid 10001 appuser && chown -R appuser:appuser /app
|
||||
USER appuser
|
||||
EXPOSE 8080
|
||||
CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "8080"]
|
||||
@@ -1,37 +1,74 @@
|
||||
# Отчёт — лабораторная 3
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- Автор, группа: Борзов, БВТ2304
|
||||
- Целевая оценка: 5, трек 1 «Цена масштабирования»
|
||||
- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab3/pulls/34
|
||||
- Commit: `89ef13702c86dc22621a227da322ed1dd37f9dbc`
|
||||
- Использованные источники: материалы skeleton и документация FastAPI, psycopg, Redis, Docker Compose, Nginx. Код написан для учебного проекта с помощью ИИ и проверен локальными сценариями.
|
||||
|
||||
## Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
Требуется Docker Desktop и Python 3.9+. Скопируйте `.env.example` в `.env` и задайте локальный пароль PostgreSQL. Запуск из корня репозитория:
|
||||
|
||||
```sh
|
||||
cp .env.example .env
|
||||
docker compose --env-file .env up -d --build --wait
|
||||
make check
|
||||
make validate PYTHON=python3
|
||||
make test BASE_URL=http://localhost:8080
|
||||
```
|
||||
|
||||
Миграции запускаются один раз сервисом `migrate` до старта реплик. Состояние хранится в volumes `postgres_data` и `redis_data`. Для безопасного завершения используйте `docker compose down`; volumes при этом сохраняются. Намеренное удаление учебных данных: `docker compose down -v`.
|
||||
|
||||
## Архитектура и решения
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
Клиент обращается к `lb:8080`. Nginx распределяет запросы между `api-1`...`api-4`; порты реплик наружу не опубликованы. Обе реплики используют одну PostgreSQL и один Redis. PostgreSQL хранит пользователей, чаты, сообщения и таблицу `message_idempotency`, Redis хранит действующие сессии и кэш списка чатов.
|
||||
|
||||
Из лабораторной 2 перенесены REST API, Argon2id, Bearer-сессии, миграции, keyset-пагинация и кэш. В этой работе добавлены `X-Instance-Id`, Nginx, две реплики, обязательный `Idempotency-Key` и сценарий остановки одной реплики. Миграции вынесены в отдельный одноразовый сервис, поэтому реплики не запускают их одновременно.
|
||||
|
||||
Для одного ключа в одной транзакции сначала создаётся запись в `message_idempotency`, затем сообщение. Уникальный ключ PostgreSQL разрешает конкурентным запросам через разные реплики создать только одну запись. При том же теле возвращается сохранённое сообщение, при другом теле возвращается 409.
|
||||
|
||||
## Доказательства критериев
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
| Публичный smoke | `make test BASE_URL=http://localhost:8080` | `PASS: lab3 public API scenario` | `tests/smoke.py` |
|
||||
| Четыре наблюдаемые реплики | `python3 student-tests/idempotency.py` | В заголовках наблюдаются API-реплики; 8 конкурентных повторов дали один ID | `student-tests/idempotency.py` |
|
||||
| Общая идемпотентность | `python3 student-tests/idempotency.py` | Повтор с тем же телом возвращает исходное сообщение, другое тело — 409 | `migrations/002_idempotency.sql` |
|
||||
| Сохранность после перезапуска | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | `PASS: persistence preserved confirmed data and existing session` | `scripts/restart.sh` |
|
||||
| Отказ каждой реплики | `python3 evidence/failover_all.py` | `api-1`...`api-4`: по 12 успешных записей после остановки каждой | `evidence/failover_all.json` |
|
||||
| Rolling update | нагрузка `tests/load.py` параллельно с `scripts/rolling-update.sh` | 1970 успешных запросов, 0 ошибок за 25 секунд | `evidence/rolling_load.json`, `scripts/rolling-update.sh` |
|
||||
| Таймауты и readiness | `curl /health/ready`, healthchecks Compose | LB исключает остановленную реплику; API readiness проверяет PostgreSQL и Redis | `compose.yaml`, `nginx/nginx.conf` |
|
||||
| Ресурсные ограничения | `docker compose config --quiet` | Для API, LB, PostgreSQL и Redis заданы CPU/RAM limits | `compose.yaml` |
|
||||
| Исследовательский трек 1 | `python3 evidence/scale_experiment.py` | Сравнение 1/2/4 реплик при 2 CPU и 1 GB, затем серия роста CPU для 4 реплик | `evidence/scale_results.json`, `evidence/scale_resource_results.json`, `evidence/scale_plot.png` |
|
||||
|
||||
## Эксперименты и отказы
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
### Трек 1: цена масштабирования
|
||||
|
||||
Гипотеза: увеличение числа API-реплик при неизменном суммарном CPU/RAM сначала увеличит пропускную способность, а затем упрётся в общую PostgreSQL и накладные расходы пулов соединений.
|
||||
|
||||
Методика: Docker Desktop на локальном MacBook (8 CPU, 8 GB выделенной памяти Docker), PostgreSQL 16.4, Redis 7.4.2, Python 3.12.8. Для каждого замера прогревался стенд, затем выполнялся закрытый тест `tests/load.py` длительностью 15 секунд с concurrency 8. Сравнивались 1, 2 и 4 API-реплики при суммарных лимитах 2 CPU и 1 GB RAM. После этого для 4 реплик CPU последовательно увеличивался с 1 до 2 и 4, память оставалась 1 GB. Скрипт автоматически сохраняет исходные JSON-результаты и график.
|
||||
|
||||
При фиксированных ресурсах получилась следующая серия:
|
||||
|
||||
| Реплики | Успешные RPS | Ошибки | p50, мс | p95, мс | p99, мс |
|
||||
| ---: | ---: | ---: | ---: | ---: | ---: |
|
||||
| 1 | 398.948 | 0% | 18.576 | 29.126 | 55.308 |
|
||||
| 2 | 491.139 | 0% | 12.152 | 24.869 | 113.716 |
|
||||
| 4 | 517.044 | 0% | 9.247 | 50.660 | 91.127 |
|
||||
|
||||
Рост с 2 до 4 реплик дал только около 5% RPS, а p95 вырос. Это показывает насыщение общей БД и LB: дополнительные API-процессы создают больше конкурентных обращений к одному пулу PostgreSQL, но не добавляют отдельного узла хранения.
|
||||
|
||||
Подтверждённое улучшение получено изменением ресурсов для 4 реплик: при 1 CPU было 339.502 RPS, при 2 CPU — 269.722 RPS, при 4 CPU — 491.144 RPS. На этом ноутбуке рост до 4 CPU дал примерно 82% к серии с 2 CPU. Замер с 2 CPU оказался шумным, поэтому вывод делается по измеренной серии и сопровождается исходными данными.
|
||||
|
||||
Пассивная проверка Nginx выполняется после двух ошибок соединения (`max_fails=2`, `fail_timeout=3s`), а активные healthchecks API идут раз в 3 секунды. Практическое время восстановления в отдельном сценарии для каждой реплики составило 2.4–3.4 секунды. Rolling update выполняет замену API по одной реплике и ждёт её readiness перед переходом к следующей.
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
| Остановка одной из `api-1`...`api-4` | LB исключает недоступный backend после ошибок соединения | Записи продолжаются через оставшиеся реплики, подтверждённая история не меняется | 2.4–3.4 с, потери данных нет |
|
||||
| Перезапуск API, PostgreSQL и Redis | volumes сохраняют данные и сессии | Существующий токен снова принимается, сообщение читается | менее 90 с, потери данных нет |
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Стенд выдерживает отказ одной API-реплики и перезапуск контейнеров при сохранённых volumes. Единственные PostgreSQL, Redis и Nginx остаются единичными точками отказа; потеря Docker-host или удаление volumes не входит в заявленную модель. Нагрузочный тест закрытый, поэтому его RPS включает клиентские задержки и не является универсальной производительностью сервиса. Серия с ростом CPU показывает заметный разброс, поэтому в отчёте сохранены все исходные JSON-файлы.
|
||||
|
||||
+546
@@ -0,0 +1,546 @@
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import threading
|
||||
import uuid
|
||||
import hashlib
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import redis
|
||||
from argon2 import PasswordHasher
|
||||
from fastapi import FastAPI, Request
|
||||
from fastapi.responses import JSONResponse, Response
|
||||
from psycopg.rows import dict_row
|
||||
from psycopg_pool import ConnectionPool
|
||||
|
||||
DATABASE_URL = os.getenv('DATABASE_URL', 'postgresql://messenger:messenger@postgres:5432/messenger')
|
||||
REDIS_URL = os.getenv('REDIS_URL', 'redis://redis:6379/0')
|
||||
SESSION_TTL_SECONDS = int(os.getenv('SESSION_TTL_SECONDS', '3600'))
|
||||
INSTANCE_ID = os.getenv('INSTANCE_ID', uuid.uuid4().hex[:12])
|
||||
DB_POOL_SIZE = int(os.getenv('DB_POOL_SIZE', '10'))
|
||||
|
||||
password_hasher = PasswordHasher()
|
||||
db_pool = ConnectionPool(
|
||||
DATABASE_URL, min_size=1, max_size=DB_POOL_SIZE, timeout=5,
|
||||
kwargs={'row_factory': dict_row}, open=False,
|
||||
)
|
||||
redis_client = redis.Redis.from_url(
|
||||
REDIS_URL,
|
||||
decode_responses=True,
|
||||
socket_connect_timeout=1,
|
||||
socket_timeout=1,
|
||||
retry_on_timeout=False,
|
||||
)
|
||||
chat_cache_lock = threading.Lock()
|
||||
chat_cache_sql_reads = 0
|
||||
invalidated_chat_caches = set()
|
||||
app = FastAPI(title='MTUSI Messenger Lab 3', version='1.3.0')
|
||||
|
||||
|
||||
class IdempotencyConflict(Exception):
|
||||
pass
|
||||
|
||||
|
||||
def utc_now():
|
||||
return datetime.now(timezone.utc)
|
||||
|
||||
|
||||
def format_time(value):
|
||||
return value.astimezone(timezone.utc).isoformat().replace('+00:00', 'Z')
|
||||
|
||||
|
||||
def parse_uuid(value):
|
||||
try:
|
||||
return uuid.UUID(str(value))
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValueError('invalid uuid') from exc
|
||||
|
||||
|
||||
def user_response(row):
|
||||
return {
|
||||
'id': str(row['id']), 'username': row['username'],
|
||||
'display_name': row['display_name'], 'created_at': format_time(row['created_at']),
|
||||
}
|
||||
|
||||
|
||||
def chat_response(row, member_ids):
|
||||
return {
|
||||
'id': str(row['id']), 'title': row['title'],
|
||||
'member_ids': [str(item) for item in member_ids],
|
||||
'created_at': format_time(row['created_at']),
|
||||
}
|
||||
|
||||
|
||||
def message_response(row):
|
||||
return {
|
||||
'id': str(row['id']), 'chat_id': str(row['chat_id']),
|
||||
'sender_id': str(row['sender_id']), 'text': row['text'],
|
||||
'created_at': format_time(row['created_at']),
|
||||
}
|
||||
|
||||
|
||||
def error_response(request, status_code, code, message, extra_headers=None):
|
||||
request_id = getattr(request.state, 'request_id', uuid.uuid4().hex)
|
||||
headers = {'X-Request-Id': request_id, 'X-Instance-Id': INSTANCE_ID}
|
||||
if extra_headers:
|
||||
headers.update(extra_headers)
|
||||
return JSONResponse(
|
||||
status_code=status_code,
|
||||
content={'error': {'code': code, 'message': message, 'request_id': request_id}},
|
||||
headers=headers,
|
||||
)
|
||||
|
||||
|
||||
@app.middleware('http')
|
||||
async def request_context(request: Request, call_next):
|
||||
request.state.request_id = request.headers.get('X-Request-Id') or uuid.uuid4().hex
|
||||
try:
|
||||
response = await call_next(request)
|
||||
except Exception:
|
||||
return error_response(request, 500, 'internal_error', 'Внутренняя ошибка')
|
||||
response.headers['X-Request-Id'] = request.state.request_id
|
||||
response.headers['X-Instance-Id'] = INSTANCE_ID
|
||||
return response
|
||||
|
||||
|
||||
@app.on_event('startup')
|
||||
def start_application():
|
||||
db_pool.open(wait=True)
|
||||
with db_pool.connection() as connection:
|
||||
connection.execute('SELECT 1')
|
||||
|
||||
|
||||
@app.on_event('shutdown')
|
||||
def stop_application():
|
||||
db_pool.close()
|
||||
|
||||
|
||||
async def read_json_body(request):
|
||||
try:
|
||||
value = await request.json()
|
||||
except Exception as exc:
|
||||
raise ValueError('malformed json') from exc
|
||||
if not isinstance(value, dict):
|
||||
raise ValueError('request body must be an object')
|
||||
return value
|
||||
|
||||
|
||||
def require_fields(data, required):
|
||||
if set(data) != required:
|
||||
raise ValueError('unexpected or missing fields')
|
||||
|
||||
|
||||
def get_bearer_session(request):
|
||||
authorization = request.headers.get('Authorization', '')
|
||||
if not authorization.startswith('Bearer '):
|
||||
return None
|
||||
token = authorization.removeprefix('Bearer ')
|
||||
if len(token) < 40:
|
||||
return None
|
||||
try:
|
||||
value = redis_client.get('session:' + token)
|
||||
return json.loads(value) if value else None
|
||||
except Exception:
|
||||
return None
|
||||
|
||||
|
||||
def get_current_user(request):
|
||||
session = get_bearer_session(request)
|
||||
if session is None:
|
||||
return None
|
||||
with db_pool.connection() as connection:
|
||||
return connection.execute(
|
||||
'SELECT * FROM users WHERE id=%s', (session['user_id'],)
|
||||
).fetchone()
|
||||
|
||||
|
||||
def require_current_user(request):
|
||||
user = get_current_user(request)
|
||||
if user is None:
|
||||
return None, error_response(
|
||||
request, 401, 'unauthorized', 'Требуется действующая Bearer-сессия',
|
||||
{'WWW-Authenticate': 'Bearer realm="messenger"'},
|
||||
)
|
||||
return user, None
|
||||
|
||||
|
||||
def is_chat_member(connection, chat_id, user_id):
|
||||
row = connection.execute(
|
||||
'SELECT 1 FROM chat_members WHERE chat_id=%s AND user_id=%s',
|
||||
(chat_id, user_id),
|
||||
).fetchone()
|
||||
return row is not None
|
||||
|
||||
|
||||
def make_cursor(scope, owner_id, row):
|
||||
created_at = row['created_at']
|
||||
if isinstance(created_at, datetime):
|
||||
created_at = format_time(created_at)
|
||||
data = [scope, owner_id, created_at, str(row['id'])]
|
||||
return base64.urlsafe_b64encode(json.dumps(data).encode()).decode().rstrip('=')
|
||||
|
||||
|
||||
def read_cursor(cursor, expected_scope, expected_owner):
|
||||
try:
|
||||
padding = '=' * ((4 - len(cursor) % 4) % 4)
|
||||
value = json.loads(base64.urlsafe_b64decode((cursor + padding).encode()))
|
||||
if value[0] != expected_scope or value[1] != expected_owner:
|
||||
raise ValueError
|
||||
timestamp = datetime.fromisoformat(value[2].replace('Z', '+00:00'))
|
||||
return timestamp, parse_uuid(value[3])
|
||||
except (IndexError, TypeError, ValueError, json.JSONDecodeError) as exc:
|
||||
raise ValueError('invalid cursor') from exc
|
||||
|
||||
|
||||
def page_chats(items, limit, cursor_data, owner_id):
|
||||
if cursor_data:
|
||||
items = [
|
||||
item for item in items
|
||||
if (
|
||||
datetime.fromisoformat(item['created_at'].replace('Z', '+00:00')),
|
||||
uuid.UUID(item['id']),
|
||||
) > cursor_data
|
||||
]
|
||||
page = items[:limit]
|
||||
next_cursor = make_cursor('chats', owner_id, page[-1]) if len(items) > limit and page else None
|
||||
return {'items': page, 'next_cursor': next_cursor}
|
||||
|
||||
|
||||
def parse_limit(value):
|
||||
try:
|
||||
limit = int(value)
|
||||
except (TypeError, ValueError) as exc:
|
||||
raise ValueError('invalid limit') from exc
|
||||
if not 1 <= limit <= 100:
|
||||
raise ValueError('invalid limit')
|
||||
return limit
|
||||
|
||||
|
||||
@app.get('/health/live')
|
||||
def health_live():
|
||||
return {'status': 'ok'}
|
||||
|
||||
|
||||
@app.get('/health/ready')
|
||||
def health_ready(request: Request):
|
||||
try:
|
||||
with db_pool.connection() as connection:
|
||||
connection.execute('SELECT 1')
|
||||
redis_client.ping()
|
||||
except Exception:
|
||||
return error_response(request, 503, 'unavailable', 'Зависимость недоступна')
|
||||
return {'status': 'ok'}
|
||||
|
||||
|
||||
@app.get('/debug/cache-stats')
|
||||
def cache_stats(request: Request):
|
||||
if os.getenv('ENABLE_DEBUG_METRICS') != '1':
|
||||
return error_response(request, 404, 'not_found', 'Ресурс не найден')
|
||||
return {'chat_list_sql_reads': chat_cache_sql_reads}
|
||||
|
||||
|
||||
@app.post('/api/v1/users', status_code=201)
|
||||
async def create_user(request: Request):
|
||||
try:
|
||||
data = await read_json_body(request)
|
||||
require_fields(data, {'username', 'display_name', 'password'})
|
||||
username, display_name, password = data['username'], data['display_name'], data['password']
|
||||
if not isinstance(username, str) or not re.fullmatch(r'[a-z0-9_]{3,32}', username):
|
||||
raise ValueError('invalid username')
|
||||
if not isinstance(display_name, str) or not display_name.strip() or not 1 <= len(display_name) <= 100:
|
||||
raise ValueError('invalid display name')
|
||||
if not isinstance(password, str) or not 12 <= len(password) <= 128:
|
||||
raise ValueError('invalid password')
|
||||
|
||||
user_id, created_at = uuid.uuid4(), utc_now()
|
||||
password_hash = password_hasher.hash(password)
|
||||
with db_pool.connection() as connection:
|
||||
try:
|
||||
connection.execute(
|
||||
'INSERT INTO users VALUES (%s,%s,%s,%s,%s)',
|
||||
(user_id, username, display_name, password_hash, created_at),
|
||||
)
|
||||
connection.commit()
|
||||
except Exception as exc:
|
||||
connection.rollback()
|
||||
if 'unique' in str(exc).lower():
|
||||
return error_response(request, 409, 'conflict', 'Имя пользователя уже занято')
|
||||
raise
|
||||
return user_response({'id': user_id, 'username': username, 'display_name': display_name, 'created_at': created_at})
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверные поля запроса')
|
||||
|
||||
|
||||
@app.post('/api/v1/auth/sessions', status_code=201)
|
||||
def create_session(request: Request):
|
||||
authorization = request.headers.get('Authorization', '')
|
||||
try:
|
||||
if not authorization.startswith('Basic '):
|
||||
raise ValueError
|
||||
credentials = base64.b64decode(authorization.removeprefix('Basic '), validate=True).decode()
|
||||
username, password = credentials.split(':', 1)
|
||||
with db_pool.connection() as connection:
|
||||
user = connection.execute('SELECT * FROM users WHERE username=%s', (username,)).fetchone()
|
||||
if user is None:
|
||||
raise ValueError
|
||||
password_hasher.verify(user['password_hash'], password)
|
||||
except Exception:
|
||||
return error_response(
|
||||
request, 401, 'unauthorized', 'Неверные учётные данные',
|
||||
{'WWW-Authenticate': 'Basic realm="messenger", charset="UTF-8"'},
|
||||
)
|
||||
|
||||
token = secrets.token_urlsafe(32)
|
||||
expires_at = utc_now() + timedelta(seconds=SESSION_TTL_SECONDS)
|
||||
redis_client.setex(
|
||||
'session:' + token,
|
||||
SESSION_TTL_SECONDS,
|
||||
json.dumps({'user_id': str(user['id']), 'expires_at': format_time(expires_at)}),
|
||||
)
|
||||
return {
|
||||
'token': token, 'token_type': 'Bearer',
|
||||
'expires_at': format_time(expires_at), 'user': user_response(user),
|
||||
}
|
||||
|
||||
|
||||
@app.delete('/api/v1/auth/sessions/current', status_code=204)
|
||||
def logout(request: Request):
|
||||
if get_bearer_session(request) is None:
|
||||
return error_response(
|
||||
request, 401, 'unauthorized', 'Сессия недействительна',
|
||||
{'WWW-Authenticate': 'Bearer realm="messenger"'},
|
||||
)
|
||||
token = request.headers['Authorization'].removeprefix('Bearer ')
|
||||
redis_client.delete('session:' + token)
|
||||
return Response(status_code=204)
|
||||
|
||||
|
||||
@app.get('/api/v1/users/me')
|
||||
def get_me(request: Request):
|
||||
user, failure = require_current_user(request)
|
||||
return failure if failure else user_response(user)
|
||||
|
||||
|
||||
@app.post('/api/v1/chats', status_code=201)
|
||||
async def create_chat(request: Request):
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
data = await read_json_body(request)
|
||||
require_fields(data, {'title', 'member_ids'})
|
||||
title, member_values = data['title'], data['member_ids']
|
||||
if not isinstance(title, str) or not title.strip() or not 1 <= len(title) <= 100:
|
||||
raise ValueError('invalid title')
|
||||
if not isinstance(member_values, list) or not 1 <= len(member_values) <= 100:
|
||||
raise ValueError('invalid members')
|
||||
if len(set(member_values)) != len(member_values):
|
||||
raise ValueError('duplicate members')
|
||||
member_ids = [parse_uuid(value) for value in member_values]
|
||||
if user['id'] not in member_ids:
|
||||
raise ValueError('current user must be a member')
|
||||
|
||||
chat_id, created_at = uuid.uuid4(), utc_now()
|
||||
with db_pool.connection() as connection:
|
||||
with connection.transaction():
|
||||
count = connection.execute(
|
||||
'SELECT count(*) AS n FROM users WHERE id = ANY(%s)', (member_ids,)
|
||||
).fetchone()['n']
|
||||
if count != len(member_ids):
|
||||
raise ValueError('unknown member')
|
||||
connection.execute('INSERT INTO chats VALUES (%s,%s,%s)', (chat_id, title, created_at))
|
||||
for member_id in member_ids:
|
||||
connection.execute('INSERT INTO chat_members VALUES (%s,%s)', (chat_id, member_id))
|
||||
for member_id in member_ids:
|
||||
try:
|
||||
redis_client.delete('chats:' + str(member_id))
|
||||
except Exception:
|
||||
with chat_cache_lock:
|
||||
invalidated_chat_caches.add('chats:' + str(member_id))
|
||||
return chat_response({'id': chat_id, 'title': title, 'created_at': created_at}, member_ids)
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверные данные чата')
|
||||
|
||||
|
||||
@app.get('/api/v1/chats')
|
||||
def list_chats(request: Request, limit: str = '50', cursor: str | None = None):
|
||||
global chat_cache_sql_reads
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
limit = parse_limit(limit)
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'limit должен быть от 1 до 100')
|
||||
|
||||
cursor_data = None
|
||||
if cursor is not None:
|
||||
if not cursor:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
|
||||
try:
|
||||
cursor_data = read_cursor(cursor, 'chats', str(user['id']))
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
|
||||
|
||||
cache_key = 'chats:' + str(user['id'])
|
||||
cache_needs_refresh = cache_key in invalidated_chat_caches
|
||||
if not cache_needs_refresh:
|
||||
try:
|
||||
cached = redis_client.get(cache_key)
|
||||
if cached:
|
||||
return page_chats(json.loads(cached), limit, cursor_data, str(user['id']))
|
||||
except Exception:
|
||||
pass
|
||||
|
||||
with chat_cache_lock:
|
||||
try:
|
||||
cached = None if cache_needs_refresh else redis_client.get(cache_key)
|
||||
except Exception:
|
||||
cached = None
|
||||
if cached:
|
||||
chats = json.loads(cached)
|
||||
else:
|
||||
with db_pool.connection() as connection:
|
||||
rows = connection.execute(
|
||||
'SELECT c.* FROM chats c JOIN chat_members m ON m.chat_id=c.id '
|
||||
'WHERE m.user_id=%s ORDER BY c.created_at,c.id', (user['id'],)
|
||||
).fetchall()
|
||||
chats = []
|
||||
for row in rows:
|
||||
members = connection.execute(
|
||||
'SELECT user_id FROM chat_members WHERE chat_id=%s ORDER BY user_id', (row['id'],)
|
||||
).fetchall()
|
||||
chats.append(chat_response(row, [item['user_id'] for item in members]))
|
||||
chat_cache_sql_reads += 1
|
||||
try:
|
||||
redis_client.setex(cache_key, 30, json.dumps(chats))
|
||||
invalidated_chat_caches.discard(cache_key)
|
||||
except Exception:
|
||||
pass
|
||||
return page_chats(chats, limit, cursor_data, str(user['id']))
|
||||
|
||||
|
||||
@app.get('/api/v1/chats/{chat_id}')
|
||||
def get_chat(chat_id: str, request: Request):
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
parsed_chat_id = parse_uuid(chat_id)
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный UUID')
|
||||
with db_pool.connection() as connection:
|
||||
chat = connection.execute('SELECT * FROM chats WHERE id=%s', (parsed_chat_id,)).fetchone()
|
||||
if chat is None or not is_chat_member(connection, parsed_chat_id, user['id']):
|
||||
return error_response(request, 404, 'not_found', 'Чат не найден')
|
||||
members = connection.execute('SELECT user_id FROM chat_members WHERE chat_id=%s', (parsed_chat_id,)).fetchall()
|
||||
return chat_response(chat, [item['user_id'] for item in members])
|
||||
|
||||
|
||||
@app.post('/api/v1/chats/{chat_id}/messages', status_code=201)
|
||||
async def create_message(chat_id: str, request: Request):
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
parsed_chat_id = parse_uuid(chat_id)
|
||||
idempotency_key = request.headers.get('Idempotency-Key', '')
|
||||
if not re.fullmatch(r'[A-Za-z0-9._:-]{1,128}', idempotency_key):
|
||||
raise ValueError('invalid idempotency key')
|
||||
data = await read_json_body(request)
|
||||
require_fields(data, {'text'})
|
||||
text = data['text']
|
||||
if not isinstance(text, str) or not text.strip() or not 1 <= len(text) <= 4000:
|
||||
raise ValueError('invalid text')
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверные данные сообщения')
|
||||
|
||||
body_hash = hashlib.sha256(json.dumps({'text': text}, sort_keys=True).encode()).hexdigest()
|
||||
with db_pool.connection() as connection:
|
||||
if not is_chat_member(connection, parsed_chat_id, user['id']):
|
||||
return error_response(request, 404, 'not_found', 'Чат не найден')
|
||||
try:
|
||||
with connection.transaction():
|
||||
idempotency = connection.execute(
|
||||
'INSERT INTO message_idempotency '
|
||||
'(user_id, chat_id, idempotency_key, body_hash) '
|
||||
'VALUES (%s,%s,%s,%s) '
|
||||
'ON CONFLICT (user_id, chat_id, idempotency_key) DO NOTHING '
|
||||
'RETURNING message_id',
|
||||
(user['id'], parsed_chat_id, idempotency_key, body_hash),
|
||||
).fetchone()
|
||||
if idempotency is None:
|
||||
saved = connection.execute(
|
||||
'SELECT message_id, body_hash FROM message_idempotency '
|
||||
'WHERE user_id=%s AND chat_id=%s AND idempotency_key=%s',
|
||||
(user['id'], parsed_chat_id, idempotency_key),
|
||||
).fetchone()
|
||||
if saved['body_hash'] != body_hash:
|
||||
raise IdempotencyConflict
|
||||
row = connection.execute(
|
||||
'SELECT * FROM messages WHERE id=%s', (saved['message_id'],)
|
||||
).fetchone()
|
||||
return message_response(row)
|
||||
|
||||
message_id, created_at = uuid.uuid4(), utc_now()
|
||||
connection.execute(
|
||||
'INSERT INTO messages VALUES (%s,%s,%s,%s,%s)',
|
||||
(message_id, parsed_chat_id, user['id'], text, created_at),
|
||||
)
|
||||
connection.execute(
|
||||
'UPDATE message_idempotency SET message_id=%s '
|
||||
'WHERE user_id=%s AND chat_id=%s AND idempotency_key=%s',
|
||||
(message_id, user['id'], parsed_chat_id, idempotency_key),
|
||||
)
|
||||
row = {
|
||||
'id': message_id, 'chat_id': parsed_chat_id,
|
||||
'sender_id': user['id'], 'text': text, 'created_at': created_at,
|
||||
}
|
||||
except IdempotencyConflict:
|
||||
return error_response(request, 409, 'conflict', 'Ключ уже использован для другого сообщения')
|
||||
return message_response(row)
|
||||
|
||||
|
||||
@app.get('/api/v1/chats/{chat_id}/messages')
|
||||
def list_messages(chat_id: str, request: Request, limit: str = '50', cursor: str | None = None):
|
||||
user, failure = require_current_user(request)
|
||||
if failure:
|
||||
return failure
|
||||
try:
|
||||
limit = parse_limit(limit)
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'limit должен быть от 1 до 100')
|
||||
try:
|
||||
parsed_chat_id = parse_uuid(chat_id)
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный UUID')
|
||||
|
||||
cursor_data = None
|
||||
if cursor is not None:
|
||||
if not cursor:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
|
||||
try:
|
||||
cursor_data = read_cursor(cursor, 'messages', str(parsed_chat_id))
|
||||
except ValueError:
|
||||
return error_response(request, 400, 'invalid_request', 'Неверный cursor')
|
||||
|
||||
with db_pool.connection() as connection:
|
||||
if not is_chat_member(connection, parsed_chat_id, user['id']):
|
||||
return error_response(request, 404, 'not_found', 'Чат не найден')
|
||||
if cursor_data:
|
||||
rows = connection.execute(
|
||||
'SELECT * FROM messages WHERE chat_id=%s AND (created_at,id)>(%s,%s) '
|
||||
'ORDER BY created_at,id LIMIT %s',
|
||||
(parsed_chat_id, cursor_data[0], cursor_data[1], limit + 1),
|
||||
).fetchall()
|
||||
else:
|
||||
rows = connection.execute(
|
||||
'SELECT * FROM messages WHERE chat_id=%s ORDER BY created_at,id LIMIT %s',
|
||||
(parsed_chat_id, limit + 1),
|
||||
).fetchall()
|
||||
|
||||
rows_to_return = rows[:limit]
|
||||
next_cursor = make_cursor('messages', str(parsed_chat_id), rows_to_return[-1]) if len(rows) > limit else None
|
||||
return {'items': [message_response(row) for row in rows_to_return], 'next_cursor': next_cursor}
|
||||
+148
@@ -0,0 +1,148 @@
|
||||
services:
|
||||
postgres:
|
||||
image: postgres:16.4-alpine
|
||||
environment:
|
||||
POSTGRES_DB: ${POSTGRES_DB:-messenger}
|
||||
POSTGRES_USER: ${POSTGRES_USER:-messenger}
|
||||
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-local-only-password}
|
||||
volumes:
|
||||
- postgres_data:/var/lib/postgresql/data
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-messenger} -d ${POSTGRES_DB:-messenger}"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
mem_limit: 512m
|
||||
cpus: 1.0
|
||||
|
||||
redis:
|
||||
image: redis:7.4.2-alpine
|
||||
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
|
||||
volumes:
|
||||
- redis_data:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "redis-cli", "ping"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
mem_limit: 256m
|
||||
cpus: 0.5
|
||||
|
||||
migrate:
|
||||
build: .
|
||||
image: mtusi-messenger-lab3:3.0
|
||||
environment:
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-local-only-password}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
command: ["python", "scripts/migrate.py"]
|
||||
depends_on:
|
||||
postgres: {condition: service_healthy}
|
||||
|
||||
api-1:
|
||||
build: .
|
||||
image: mtusi-messenger-lab3:3.0
|
||||
environment:
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-local-only-password}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
REDIS_URL: redis://redis:6379/0
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
INSTANCE_ID: api-1
|
||||
ENABLE_DEBUG_METRICS: ${ENABLE_DEBUG_METRICS:-1}
|
||||
expose: ["8080"]
|
||||
depends_on:
|
||||
migrate: {condition: service_completed_successfully}
|
||||
postgres: {condition: service_healthy}
|
||||
redis: {condition: service_healthy}
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
mem_limit: 256m
|
||||
cpus: 0.5
|
||||
|
||||
api-2:
|
||||
build: .
|
||||
image: mtusi-messenger-lab3:3.0
|
||||
environment:
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-local-only-password}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
REDIS_URL: redis://redis:6379/0
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
INSTANCE_ID: api-2
|
||||
ENABLE_DEBUG_METRICS: ${ENABLE_DEBUG_METRICS:-1}
|
||||
expose: ["8080"]
|
||||
depends_on:
|
||||
migrate: {condition: service_completed_successfully}
|
||||
postgres: {condition: service_healthy}
|
||||
redis: {condition: service_healthy}
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
mem_limit: 256m
|
||||
cpus: 0.5
|
||||
|
||||
api-3:
|
||||
build: .
|
||||
image: mtusi-messenger-lab3:3.0
|
||||
environment:
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-local-only-password}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
REDIS_URL: redis://redis:6379/0
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
INSTANCE_ID: api-3
|
||||
ENABLE_DEBUG_METRICS: ${ENABLE_DEBUG_METRICS:-1}
|
||||
expose: ["8080"]
|
||||
depends_on:
|
||||
migrate: {condition: service_completed_successfully}
|
||||
postgres: {condition: service_healthy}
|
||||
redis: {condition: service_healthy}
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
mem_limit: 256m
|
||||
cpus: 0.5
|
||||
|
||||
api-4:
|
||||
build: .
|
||||
image: mtusi-messenger-lab3:3.0
|
||||
environment:
|
||||
DATABASE_URL: postgresql://${POSTGRES_USER:-messenger}:${POSTGRES_PASSWORD:-local-only-password}@postgres:5432/${POSTGRES_DB:-messenger}
|
||||
REDIS_URL: redis://redis:6379/0
|
||||
SESSION_TTL_SECONDS: ${SESSION_TTL_SECONDS:-3600}
|
||||
INSTANCE_ID: api-4
|
||||
ENABLE_DEBUG_METRICS: ${ENABLE_DEBUG_METRICS:-1}
|
||||
expose: ["8080"]
|
||||
depends_on:
|
||||
migrate: {condition: service_completed_successfully}
|
||||
postgres: {condition: service_healthy}
|
||||
redis: {condition: service_healthy}
|
||||
healthcheck:
|
||||
test: ["CMD", "python", "-c", "import urllib.request; urllib.request.urlopen('http://localhost:8080/health/ready')"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
mem_limit: 256m
|
||||
cpus: 0.5
|
||||
|
||||
lb:
|
||||
image: nginx:1.27.2-alpine
|
||||
ports: ["8080:8080"]
|
||||
volumes:
|
||||
- ./nginx/nginx.conf:/etc/nginx/nginx.conf:ro
|
||||
depends_on:
|
||||
api-1: {condition: service_healthy}
|
||||
api-2: {condition: service_healthy}
|
||||
api-3: {condition: service_healthy}
|
||||
api-4: {condition: service_healthy}
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "wget -q -O - http://127.0.0.1:8080/health/live >/dev/null"]
|
||||
interval: 3s
|
||||
timeout: 3s
|
||||
retries: 20
|
||||
mem_limit: 128m
|
||||
cpus: 0.25
|
||||
|
||||
volumes:
|
||||
postgres_data:
|
||||
redis_data:
|
||||
@@ -0,0 +1,22 @@
|
||||
[
|
||||
{
|
||||
"stopped": "api-1",
|
||||
"successful_writes": 12,
|
||||
"seconds": 3.405
|
||||
},
|
||||
{
|
||||
"stopped": "api-2",
|
||||
"successful_writes": 12,
|
||||
"seconds": 2.412
|
||||
},
|
||||
{
|
||||
"stopped": "api-3",
|
||||
"successful_writes": 12,
|
||||
"seconds": 3.407
|
||||
},
|
||||
{
|
||||
"stopped": "api-4",
|
||||
"successful_writes": 12,
|
||||
"seconds": 3.376
|
||||
}
|
||||
]
|
||||
Executable
+49
@@ -0,0 +1,49 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Последовательная проверка остановки каждой API-реплики."""
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
import uuid
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
sys.path.insert(0, str(ROOT / 'tests'))
|
||||
from client import Client
|
||||
|
||||
|
||||
def docker(*args):
|
||||
return subprocess.run(('docker', 'compose') + args, cwd=ROOT, check=True, capture_output=True, text=True)
|
||||
|
||||
|
||||
def main():
|
||||
results = []
|
||||
for target in ('api-1', 'api-2', 'api-3', 'api-4'):
|
||||
docker('start', 'api-1', 'api-2', 'api-3', 'api-4')
|
||||
time.sleep(4)
|
||||
client = Client('http://localhost:8080', timeout=3)
|
||||
alice, _, _, chat = client.bootstrap()
|
||||
docker('stop', target)
|
||||
started = time.monotonic()
|
||||
successes = 0
|
||||
for _ in range(12):
|
||||
try:
|
||||
client.message(
|
||||
alice, chat, 'failover-' + target + '-' + uuid.uuid4().hex,
|
||||
key=uuid.uuid4().hex,
|
||||
)
|
||||
successes += 1
|
||||
except Exception:
|
||||
pass
|
||||
time.sleep(0.1)
|
||||
recovery = time.monotonic() - started
|
||||
docker('start', target)
|
||||
if successes == 0 or recovery > 10:
|
||||
raise RuntimeError('failover did not recover for ' + target)
|
||||
results.append({'stopped': target, 'successful_writes': successes, 'seconds': round(recovery, 3)})
|
||||
print(results[-1])
|
||||
(ROOT / 'evidence/failover_all.json').write_text(json.dumps(results, indent=2) + '\n')
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
@@ -0,0 +1,22 @@
|
||||
#!/usr/bin/env python3
|
||||
import json
|
||||
from pathlib import Path
|
||||
import matplotlib.pyplot as plt
|
||||
|
||||
root = Path(__file__).resolve().parents[1]
|
||||
fixed = json.loads((root / 'evidence/scale_results.json').read_text())
|
||||
resources = json.loads((root / 'evidence/scale_resource_results.json').read_text())
|
||||
|
||||
fig, axes = plt.subplots(1, 2, figsize=(10, 4))
|
||||
axes[0].plot([x['replicas'] for x in fixed], [x['successful_rps'] for x in fixed], 'o-')
|
||||
axes[0].set_title('Фиксированные 2 CPU / 1 GB')
|
||||
axes[0].set_xlabel('API-реплики')
|
||||
axes[0].set_ylabel('Успешные RPS')
|
||||
axes[0].grid(True)
|
||||
axes[1].plot([x['total_cpu_limit'] for x in resources], [x['successful_rps'] for x in resources], 'o-')
|
||||
axes[1].set_title('4 реплики, рост CPU')
|
||||
axes[1].set_xlabel('Суммарный лимит CPU')
|
||||
axes[1].set_ylabel('Успешные RPS')
|
||||
axes[1].grid(True)
|
||||
fig.tight_layout()
|
||||
fig.savefig(root / 'evidence/scale_plot.png', dpi=150)
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 25.0,
|
||||
"elapsed_seconds": 25.212,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 1970,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 78.137,
|
||||
"successful_latency_ms": {
|
||||
"p50": 40.773,
|
||||
"p95": 394.457,
|
||||
"p99": 921.938
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS
|
||||
mtusi2026lab3-api-1-1 mtusi-messenger-lab3:3.0 "uvicorn app.main:ap…" api-1 45 seconds ago Up 44 seconds (healthy) 8080/tcp
|
||||
mtusi2026lab3-api-2-1 mtusi-messenger-lab3:3.0 "uvicorn app.main:ap…" api-2 30 seconds ago Up 28 seconds (healthy) 8080/tcp
|
||||
mtusi2026lab3-api-3-1 mtusi-messenger-lab3:3.0 "uvicorn app.main:ap…" api-3 22 seconds ago Up 17 seconds (healthy) 8080/tcp
|
||||
mtusi2026lab3-api-4-1 mtusi-messenger-lab3:3.0 "uvicorn app.main:ap…" api-4 8 seconds ago Up 5 seconds (healthy) 8080/tcp
|
||||
mtusi2026lab3-lb-1 nginx:1.27.2-alpine "/docker-entrypoint.…" lb 14 minutes ago Up 14 minutes (healthy) 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp
|
||||
mtusi2026lab3-postgres-1 postgres:16.4-alpine "docker-entrypoint.s…" postgres 15 minutes ago Up 14 minutes (healthy) 5432/tcp
|
||||
mtusi2026lab3-redis-1 redis:7.4.2-alpine "docker-entrypoint.s…" redis 15 minutes ago Up 14 minutes (healthy) 6379/tcp
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.017,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 5991,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 398.948,
|
||||
"successful_latency_ms": {
|
||||
"p50": 17.782,
|
||||
"p95": 28.191,
|
||||
"p99": 36.047
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.205,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 7468,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 491.139,
|
||||
"successful_latency_ms": {
|
||||
"p50": 12.152,
|
||||
"p95": 24.869,
|
||||
"p99": 113.716
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.02,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 7766,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 517.044,
|
||||
"successful_latency_ms": {
|
||||
"p50": 9.247,
|
||||
"p95": 50.66,
|
||||
"p99": 91.127
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.016,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 5098,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 339.502,
|
||||
"successful_latency_ms": {
|
||||
"p50": 6.829,
|
||||
"p95": 89.931,
|
||||
"p99": 189.588
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.023,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 4052,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 269.722,
|
||||
"successful_latency_ms": {
|
||||
"p50": 14.77,
|
||||
"p95": 93.596,
|
||||
"p99": 217.372
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.016,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 7375,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 491.144,
|
||||
"successful_latency_ms": {
|
||||
"p50": 13.728,
|
||||
"p95": 31.818,
|
||||
"p99": 56.496
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead."
|
||||
}
|
||||
Executable
+107
@@ -0,0 +1,107 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Сравнение 1, 2 и 4 API-реплик при одинаковом суммарном лимите."""
|
||||
import json
|
||||
import subprocess
|
||||
import sys
|
||||
import time
|
||||
from pathlib import Path
|
||||
|
||||
ROOT = Path(__file__).resolve().parents[1]
|
||||
TOTAL_CPU = 2.0
|
||||
TOTAL_MEMORY_MB = 1024
|
||||
DURATION = 15
|
||||
CONCURRENCY = 8
|
||||
|
||||
|
||||
def run(*args, check=True):
|
||||
return subprocess.run(args, cwd=ROOT, check=check, text=True, capture_output=True)
|
||||
|
||||
|
||||
def container(service):
|
||||
return run('docker', 'compose', 'ps', '-q', service).stdout.strip()
|
||||
|
||||
|
||||
def set_replicas(count):
|
||||
for number in range(1, 5):
|
||||
service = 'api-' + str(number)
|
||||
if number <= count:
|
||||
run('docker', 'compose', 'start', service)
|
||||
else:
|
||||
run('docker', 'compose', 'stop', service)
|
||||
set_limits(count, TOTAL_CPU, TOTAL_MEMORY_MB)
|
||||
|
||||
|
||||
def set_limits(count, total_cpu, total_memory):
|
||||
cpu = total_cpu / count
|
||||
memory = int(total_memory / count)
|
||||
for number in range(1, count + 1):
|
||||
run(
|
||||
'docker', 'update', '--cpus', str(cpu),
|
||||
'--memory', str(memory) + 'm', '--memory-swap', str(memory) + 'm',
|
||||
container('api-' + str(number)),
|
||||
)
|
||||
deadline = time.monotonic() + 30
|
||||
while time.monotonic() < deadline:
|
||||
try:
|
||||
run('curl', '-fsS', 'http://localhost:8080/health/ready')
|
||||
return
|
||||
except subprocess.CalledProcessError:
|
||||
time.sleep(1)
|
||||
raise RuntimeError('load balancer did not become ready')
|
||||
|
||||
|
||||
def load(count, label=None):
|
||||
name = label or ('scale_' + str(count))
|
||||
output = ROOT / 'evidence' / (name + '.json')
|
||||
run(
|
||||
sys.executable, 'tests/load.py', '--base-url', 'http://localhost:8080',
|
||||
'--duration', str(DURATION), '--concurrency', str(CONCURRENCY),
|
||||
'--output', str(output),
|
||||
)
|
||||
return json.loads(output.read_text())
|
||||
|
||||
|
||||
def resource_series():
|
||||
results = []
|
||||
set_replicas(4)
|
||||
for total_cpu in (1.0, 2.0, 4.0):
|
||||
set_limits(4, total_cpu, 1024)
|
||||
measured = load(4, 'scale_cpu_' + str(int(total_cpu)))
|
||||
measured['replicas'] = 4
|
||||
measured['total_cpu_limit'] = total_cpu
|
||||
measured['total_memory_mb'] = 1024
|
||||
results.append(measured)
|
||||
print(json.dumps(measured, ensure_ascii=False))
|
||||
(ROOT / 'evidence' / 'scale_resource_results.json').write_text(
|
||||
json.dumps(results, ensure_ascii=False, indent=2) + '\n'
|
||||
)
|
||||
return results
|
||||
|
||||
|
||||
def main():
|
||||
run(
|
||||
'docker', 'compose', 'up', '-d', '--build', '--wait',
|
||||
'postgres', 'redis', 'migrate', 'api-1', 'api-2', 'api-3', 'api-4', 'lb',
|
||||
)
|
||||
results = []
|
||||
try:
|
||||
for count in (1, 2, 4):
|
||||
set_replicas(count)
|
||||
measured = load(count)
|
||||
measured['replicas'] = count
|
||||
measured['total_cpu_limit'] = TOTAL_CPU
|
||||
measured['total_memory_mb'] = TOTAL_MEMORY_MB
|
||||
results.append(measured)
|
||||
print(json.dumps(measured, ensure_ascii=False))
|
||||
resource_series()
|
||||
finally:
|
||||
for number in range(1, 5):
|
||||
run('docker', 'compose', 'start', 'api-' + str(number), check=False)
|
||||
run('docker', 'compose', 'up', '-d', 'lb', check=False)
|
||||
(ROOT / 'evidence' / 'scale_results.json').write_text(
|
||||
json.dumps(results, ensure_ascii=False, indent=2) + '\n'
|
||||
)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 62 KiB |
@@ -0,0 +1,62 @@
|
||||
[
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.016,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 5098,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 339.502,
|
||||
"successful_latency_ms": {
|
||||
"p50": 6.829,
|
||||
"p95": 89.931,
|
||||
"p99": 189.588
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.",
|
||||
"replicas": 4,
|
||||
"total_cpu_limit": 1.0,
|
||||
"total_memory_mb": 1024
|
||||
},
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.023,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 4052,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 269.722,
|
||||
"successful_latency_ms": {
|
||||
"p50": 14.77,
|
||||
"p95": 93.596,
|
||||
"p99": 217.372
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.",
|
||||
"replicas": 4,
|
||||
"total_cpu_limit": 2.0,
|
||||
"total_memory_mb": 1024
|
||||
},
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.016,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 7375,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 491.144,
|
||||
"successful_latency_ms": {
|
||||
"p50": 13.728,
|
||||
"p95": 31.818,
|
||||
"p99": 56.496
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.",
|
||||
"replicas": 4,
|
||||
"total_cpu_limit": 4.0,
|
||||
"total_memory_mb": 1024
|
||||
}
|
||||
]
|
||||
@@ -0,0 +1,62 @@
|
||||
[
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.017,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 5991,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 398.948,
|
||||
"successful_latency_ms": {
|
||||
"p50": 17.782,
|
||||
"p95": 28.191,
|
||||
"p99": 36.047
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.",
|
||||
"replicas": 1,
|
||||
"total_cpu_limit": 2.0,
|
||||
"total_memory_mb": 1024
|
||||
},
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.205,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 7468,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 491.139,
|
||||
"successful_latency_ms": {
|
||||
"p50": 12.152,
|
||||
"p95": 24.869,
|
||||
"p99": 113.716
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.",
|
||||
"replicas": 2,
|
||||
"total_cpu_limit": 2.0,
|
||||
"total_memory_mb": 1024
|
||||
},
|
||||
{
|
||||
"lab": 3,
|
||||
"workload": "closed-loop POST messages; no automatic retries",
|
||||
"requested_duration_seconds": 15.0,
|
||||
"elapsed_seconds": 15.02,
|
||||
"concurrency": 8,
|
||||
"successful_requests": 7766,
|
||||
"failed_requests": 0,
|
||||
"error_ratio": 0.0,
|
||||
"successful_rps": 517.044,
|
||||
"successful_latency_ms": {
|
||||
"p50": 9.247,
|
||||
"p95": 50.66,
|
||||
"p99": 91.127
|
||||
},
|
||||
"note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead.",
|
||||
"replicas": 4,
|
||||
"total_cpu_limit": 2.0,
|
||||
"total_memory_mb": 1024
|
||||
}
|
||||
]
|
||||
@@ -0,0 +1,19 @@
|
||||
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
|
||||
);
|
||||
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), text TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE INDEX IF NOT EXISTS messages_history_idx ON messages(chat_id, created_at, id);
|
||||
@@ -0,0 +1,12 @@
|
||||
CREATE TABLE IF NOT EXISTS message_idempotency (
|
||||
user_id UUID NOT NULL REFERENCES users(id) ON DELETE CASCADE,
|
||||
chat_id UUID NOT NULL REFERENCES chats(id) ON DELETE CASCADE,
|
||||
idempotency_key VARCHAR(128) NOT NULL,
|
||||
body_hash CHAR(64) NOT NULL,
|
||||
message_id UUID REFERENCES messages(id) ON DELETE CASCADE,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT now(),
|
||||
PRIMARY KEY (user_id, chat_id, idempotency_key)
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS message_idempotency_created_idx
|
||||
ON message_idempotency(created_at);
|
||||
@@ -0,0 +1,24 @@
|
||||
events {}
|
||||
|
||||
http {
|
||||
upstream api_backend {
|
||||
server api-1:8080 max_fails=2 fail_timeout=3s;
|
||||
server api-2:8080 max_fails=2 fail_timeout=3s;
|
||||
server api-3:8080 max_fails=2 fail_timeout=3s;
|
||||
server api-4:8080 max_fails=2 fail_timeout=3s;
|
||||
}
|
||||
|
||||
server {
|
||||
listen 8080;
|
||||
|
||||
location / {
|
||||
proxy_pass http://api_backend;
|
||||
proxy_next_upstream error timeout http_502 http_503 http_504;
|
||||
proxy_connect_timeout 1s;
|
||||
proxy_read_timeout 5s;
|
||||
proxy_send_timeout 5s;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
fastapi==0.115.6
|
||||
uvicorn[standard]==0.34.0
|
||||
psycopg[binary,pool]==3.2.3
|
||||
redis==5.2.1
|
||||
argon2-cffi==23.1.0
|
||||
Executable
+10
@@ -0,0 +1,10 @@
|
||||
import os
|
||||
import psycopg
|
||||
from pathlib import Path
|
||||
|
||||
url = os.getenv("DATABASE_URL", "postgresql://messenger:messenger@postgres:5432/messenger")
|
||||
with psycopg.connect(url) as conn:
|
||||
for path in sorted(Path("migrations").glob("*.sql")):
|
||||
conn.execute(path.read_text())
|
||||
conn.commit()
|
||||
print("migrations applied")
|
||||
Executable
+8
@@ -0,0 +1,8 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
# Перезапускаем стенд, не удаляя volumes.
|
||||
# Балансировщик запускаем после API, чтобы DNS имён реплик уже был доступен.
|
||||
docker compose up -d --build postgres redis migrate api-1 api-2 api-3 api-4
|
||||
docker compose restart postgres redis api-1 api-2 api-3 api-4
|
||||
docker compose up -d --force-recreate lb
|
||||
docker compose ps
|
||||
Executable
+16
@@ -0,0 +1,16 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
for service in api-1 api-2 api-3 api-4; do
|
||||
docker compose up -d --no-deps --force-recreate "$service"
|
||||
container=$(docker compose ps -q "$service")
|
||||
deadline=$(( $(date +%s) + 30 ))
|
||||
while [ "$(date +%s)" -lt "$deadline" ]; do
|
||||
status=$(docker inspect --format '{{.State.Health.Status}}' "$container" 2>/dev/null || true)
|
||||
[ "$status" = healthy ] && break
|
||||
sleep 1
|
||||
done
|
||||
[ "$(docker inspect --format '{{.State.Health.Status}}' "$container")" = healthy ]
|
||||
done
|
||||
|
||||
docker compose ps
|
||||
Executable
+13
@@ -0,0 +1,13 @@
|
||||
#!/bin/sh
|
||||
set -eu
|
||||
|
||||
TARGET_INSTANCE_ID=${TARGET_INSTANCE_ID:-api-1}
|
||||
case "$TARGET_INSTANCE_ID" in
|
||||
api-1) service=api-1 ;;
|
||||
api-2) service=api-2 ;;
|
||||
api-3) service=api-3 ;;
|
||||
api-4) service=api-4 ;;
|
||||
*) echo "unknown TARGET_INSTANCE_ID: $TARGET_INSTANCE_ID" >&2; exit 2 ;;
|
||||
esac
|
||||
|
||||
docker compose stop "$service"
|
||||
Executable
+37
@@ -0,0 +1,37 @@
|
||||
#!/usr/bin/env python3
|
||||
"""Проверка общего Idempotency-Key через обе API-реплики."""
|
||||
import sys
|
||||
import uuid
|
||||
from concurrent.futures import ThreadPoolExecutor
|
||||
|
||||
sys.path.insert(0, 'tests')
|
||||
from client import Client, check
|
||||
|
||||
|
||||
def main():
|
||||
client = Client('http://localhost:8080')
|
||||
alice, _, _, chat = client.bootstrap()
|
||||
key = 'student-' + uuid.uuid4().hex
|
||||
body = {'text': 'одно сообщение при восьми повторах'}
|
||||
|
||||
def send(_):
|
||||
return client.call(
|
||||
'POST', '/api/v1/chats/' + chat['id'] + '/messages', 201,
|
||||
actor=alice, body=body,
|
||||
headers={'Idempotency-Key': key}, schema='Message',
|
||||
)
|
||||
|
||||
with ThreadPoolExecutor(max_workers=8) as pool:
|
||||
responses = list(pool.map(send, range(8)))
|
||||
ids = {item['json']['id'] for item in responses}
|
||||
check(len(ids) == 1, 'concurrent retries created more than one message')
|
||||
client.call(
|
||||
'POST', '/api/v1/chats/' + chat['id'] + '/messages', 409,
|
||||
actor=alice, body={'text': 'другой текст'},
|
||||
headers={'Idempotency-Key': key},
|
||||
)
|
||||
print('PASS: concurrent idempotency, one message id:', next(iter(ids)))
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
main()
|
||||
Reference in New Issue
Block a user