forked from mtusi2026/mtusi2026lab3
Compare commits
2
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2bbe48bb7b | ||
|
|
631a852746 |
@@ -1,37 +1,66 @@
|
||||
# Отчёт — лабораторная 3
|
||||
# Отчёт — Лабораторная 3 (Балансировка и отказ API-реплики)
|
||||
|
||||
- Автор, группа: TODO
|
||||
- Целевая оценка; выбранный трек 5, если нужен: TODO
|
||||
- Commit/PR: TODO после публикации
|
||||
- Использованные источники, библиотеки и помощь ИИ: TODO
|
||||
- **Автор, группа:** Захарова Ксения Алексеевна, БВТ2302
|
||||
- **Целевая оценка:** 5 (выбран Трек 1: Цена масштабирования)
|
||||
- **Commit/PR:** [ссылка на MR]
|
||||
- **Использованные источники:** Материалы курса, документация Nginx, Docker Compose, PostgreSQL.
|
||||
|
||||
## Запуск из чистого clone
|
||||
## 1. Запуск из чистого clone
|
||||
|
||||
TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных.
|
||||
```bash
|
||||
git clone <URL>
|
||||
cd mtusi2026lab3
|
||||
cp .env.example .env
|
||||
docker compose --env-file .env up -d --build --scale api=2
|
||||
```
|
||||
|
||||
## Архитектура и решения
|
||||
## 2. Архитектура
|
||||
|
||||
TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации.
|
||||
- **Nginx (LB):** единая точка входа, слушает порт 8080, распределяет запросы по upstream.
|
||||
- **API:** Python-сервер. Запущено 2+ реплики. В ответах отдают `X-Instance-Id`.
|
||||
- **PostgreSQL:** общая БД (volumes).
|
||||
- **Redis:** общее хранилище сессий с TTL.
|
||||
|
||||
## Доказательства критериев
|
||||
## 3. Доказательства критериев (Уровень 3 и 4)
|
||||
|
||||
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
|
||||
| --- | --- | --- | --- |
|
||||
| Публичный smoke | make test | TODO | TODO |
|
||||
| Остальные пункты уровня 3 | TODO | TODO | TODO |
|
||||
| Все пункты уровня 4, если заявлен | TODO | TODO | TODO |
|
||||
| Выбранный трек 5, если заявлен | TODO | TODO | TODO |
|
||||
| Критерий | Команда/сценарий | Результат | Файл |
|
||||
|---|---|---|---|
|
||||
| ≥2 реплик за LB, одна сессия | `1..4` \| `Invoke-WebRequest` | Заголовки `X-Instance-Id` чередуются (4 разных ID). | `evidence/01_instances.txt` |
|
||||
| Общая идемпотентность | `POST /messages` (2 раза с одним ключом) | Оба ответа вернули один и тот же ID сообщения (дубля нет). | `evidence/02_idempotency.txt` |
|
||||
| Отказ реплики (Failover) | `stop-one.bat` | Убит 1 контейнер из 4. LB вернул HTTP 200 OK. | `evidence/03_failover.txt` |
|
||||
| Сохранность при рестарте | `docker compose restart` | Токен из памяти клиента прочитал сообщения после рестарта. | `evidence/04_persistence.txt` |
|
||||
| Публичный smoke | `make test PYTHON=python` | `PASS: lab3 public API scenario` | Логи консоли |
|
||||
|
||||
TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены.
|
||||
## 4. Эксперимент: Трек 1 (Цена масштабирования)
|
||||
|
||||
## Эксперименты и отказы
|
||||
**Гипотеза:** При увеличении числа реплик RPS будет расти до тех пор, пока не будет достигнута точка насыщения (saturation point). Поскольку база данных и балансировщик остаются в единственном экземпляре, рост производительности начнет замедляться при добавлении реплик.
|
||||
|
||||
TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения.
|
||||
### Методика
|
||||
|
||||
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
|
||||
| --- | --- | --- | --- |
|
||||
| TODO | TODO | TODO | TODO |
|
||||
- **Среда:** локальный Docker Desktop (Windows).
|
||||
- **Лимиты:** каждой реплике API выделено 0.5 CPU и 256 MB RAM.
|
||||
- **Профиль нагрузки:** `tests/load.py --duration 15 --concurrency 20`.
|
||||
- **Повторы:** тест запускался 3 раза для 1, 2 и 4 реплик API (БД и Nginx всегда в 1 экземпляре).
|
||||
|
||||
## Ограничения и следующие шаги
|
||||
### Результаты
|
||||
|
||||
TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза.
|
||||
Источник: `evidence/05_track1_metrics.txt`.
|
||||
|
||||
| Кол-во реплик API | RPS (успешные) | p95 (латентность) | Ошибки |
|
||||
|---:|---:|---:|---:|
|
||||
| 1 | 59.0 | 698.7 мс | 12 |
|
||||
| 2 | 133.9 | 361.0 мс | 2 |
|
||||
| 4 | 210.5 | 271.1 мс | 0 |
|
||||
|
||||
### Анализ результатов
|
||||
|
||||
- При переходе с 1 на 2 реплики RPS вырос в 2.26 раза, а p95 снизилась примерно в 1.93 раза. Это согласуется с тем, что Nginx распределяет нагрузку между репликами.
|
||||
- При переходе с 2 на 4 реплики RPS вырос в 1.57 раза, а не в 2 раза. Это указывает на замедление отдачи от масштабирования и возможное приближение к точке насыщения.
|
||||
- Возможные узкие места: PostgreSQL (в том числе ограничения пула соединений `ThreadedConnectionPool` на 20 соединений), накладные расходы Nginx или ограничения локальной дисковой подсистемы при записи WAL. По приведённым измерениям нельзя однозначно установить конкретное узкое место — для этого нужны отдельные метрики БД, Nginx и хоста.
|
||||
- **Ошибки:** при 1 реплике возникло 12 ошибок (таймауты из-за очереди к пулу, согласно наблюдениям); при 4 репликах ошибок не было.
|
||||
|
||||
### Ограничения эксперимента
|
||||
|
||||
- Тест запускался на одном физическом хосте (Docker Desktop), поэтому конкуренция за CPU/RAM происходила внутри одной ОС.
|
||||
- Nginx и PostgreSQL не масштабировались и оставались в одном экземпляре; их ресурсы использовались всеми репликами API.
|
||||
- Результаты характеризуют только данную локальную конфигурацию и профиль нагрузки; их нельзя напрямую переносить на production-среду.
|
||||
|
||||
@@ -0,0 +1,444 @@
|
||||
#!/usr/bin/env python3
|
||||
import base64
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import secrets
|
||||
import signal
|
||||
import sys
|
||||
import threading
|
||||
import time
|
||||
import traceback
|
||||
import uuid
|
||||
import hashlib
|
||||
import bcrypt
|
||||
import psycopg2
|
||||
import psycopg2.pool
|
||||
import redis
|
||||
from datetime import datetime, timezone, timedelta
|
||||
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
||||
from urllib.parse import urlparse, parse_qs
|
||||
|
||||
HOST = os.environ.get("APP_HOST", "0.0.0.0")
|
||||
PORT = int(os.environ.get("APP_PORT", "8080"))
|
||||
SESSION_TTL = int(os.environ.get("SESSION_TTL_SECONDS", 3600))
|
||||
# Уникальный ID инстанса для балансировки
|
||||
INSTANCE_ID = str(uuid.uuid4())[:8]
|
||||
|
||||
db_pool = psycopg2.pool.ThreadedConnectionPool(
|
||||
1, 20,
|
||||
host=os.environ.get("DB_HOST", "localhost"),
|
||||
user=os.environ.get("DB_USER", "postgres"),
|
||||
password=os.environ.get("DB_PASSWORD", "secret"),
|
||||
dbname=os.environ.get("DB_NAME", "messenger")
|
||||
)
|
||||
|
||||
redis_client = redis.Redis(
|
||||
host=os.environ.get("REDIS_HOST", "localhost"),
|
||||
port=6379,
|
||||
decode_responses=True
|
||||
)
|
||||
|
||||
class APIError(Exception):
|
||||
def __init__(self, status, code, message):
|
||||
self.status = status
|
||||
self.code = code
|
||||
self.message = message
|
||||
|
||||
def format_dt(dt_obj):
|
||||
return dt_obj.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
|
||||
|
||||
def parse_limit(query):
|
||||
if "limit" not in query:
|
||||
return 50
|
||||
values = query["limit"]
|
||||
if len(values) != 1:
|
||||
raise APIError(400, "invalid_request", "Invalid limit")
|
||||
try:
|
||||
limit = int(values[0])
|
||||
except ValueError:
|
||||
raise APIError(400, "invalid_request", "limit must be an integer")
|
||||
if limit < 1 or limit > 100:
|
||||
raise APIError(400, "invalid_request", "limit must be 1..100")
|
||||
return limit
|
||||
|
||||
def encode_cursor(resource_type, resource_id, item):
|
||||
payload = {"r": resource_type, "id": resource_id, "ts": item["created_at"], "iid": item["id"]}
|
||||
raw = json.dumps(payload, separators=(",", ":")).encode("utf-8")
|
||||
return base64.urlsafe_b64encode(raw).decode("ascii").rstrip("=")
|
||||
|
||||
def decode_cursor(cursor, resource_type, resource_id):
|
||||
try:
|
||||
padding = "=" * (-len(cursor) % 4)
|
||||
raw = base64.urlsafe_b64decode(cursor + padding)
|
||||
payload = json.loads(raw.decode("utf-8"))
|
||||
if payload.get("r") != resource_type or payload.get("id") != resource_id:
|
||||
raise ValueError()
|
||||
return payload["ts"], payload["iid"]
|
||||
except Exception:
|
||||
raise APIError(400, "invalid_request", "Invalid cursor")
|
||||
|
||||
def read_json(handler):
|
||||
length = handler.headers.get("Content-Length")
|
||||
if not length: raise APIError(400, "invalid_request", "Missing body")
|
||||
raw = handler.rfile.read(int(length))
|
||||
try: return json.loads(raw.decode("utf-8"))
|
||||
except Exception: raise APIError(400, "invalid_request", "Malformed JSON")
|
||||
|
||||
def get_user_by_token(handler):
|
||||
auth = handler.headers.get("Authorization")
|
||||
if not auth or not auth.startswith("Bearer "):
|
||||
raise APIError(401, "unauthorized", "Missing Bearer token")
|
||||
token = auth.split(" ")[1]
|
||||
|
||||
user_id = redis_client.get(f"session:{token}")
|
||||
if not user_id:
|
||||
raise APIError(401, "unauthorized", "Invalid or expired token")
|
||||
|
||||
conn = db_pool.getconn()
|
||||
try:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute("SELECT id, username, display_name, created_at FROM users WHERE id = %s", (user_id,))
|
||||
row = cur.fetchone()
|
||||
if not row: raise APIError(401, "unauthorized", "User not found")
|
||||
return {
|
||||
"id": str(row[0]), "username": row[1], "display_name": row[2],
|
||||
"created_at": format_dt(row[3])
|
||||
}
|
||||
finally:
|
||||
db_pool.putconn(conn)
|
||||
|
||||
class Handler(BaseHTTPRequestHandler):
|
||||
protocol_version = "HTTP/1.1"
|
||||
server_version = "MessengerLab3/3.0"
|
||||
|
||||
def do_GET(self): self.handle_request("GET")
|
||||
def do_POST(self): self.handle_request("POST")
|
||||
def do_DELETE(self): self.handle_request("DELETE")
|
||||
|
||||
def handle_request(self, method):
|
||||
request_id = str(uuid.uuid4())
|
||||
self._status = None
|
||||
try:
|
||||
parsed = urlparse(self.path)
|
||||
path = parsed.path
|
||||
query = parse_qs(parsed.query, keep_blank_values=False)
|
||||
|
||||
if method == "GET" and path == "/health/live":
|
||||
return self.send_json(200, {"status": "ok"}, request_id)
|
||||
if method == "GET" and path == "/health/ready":
|
||||
try:
|
||||
conn = db_pool.getconn()
|
||||
with conn.cursor() as cur: cur.execute("SELECT 1")
|
||||
db_pool.putconn(conn)
|
||||
return self.send_json(200, {"status": "ok"}, request_id)
|
||||
except Exception:
|
||||
raise APIError(503, "unavailable", "DB not ready")
|
||||
|
||||
if method == "POST" and path == "/api/v1/users": return self.create_user(request_id)
|
||||
if method == "POST" and path == "/api/v1/auth/sessions": return self.create_session(request_id)
|
||||
if method == "DELETE" and path == "/api/v1/auth/sessions/current": return self.delete_session(request_id)
|
||||
if method == "GET" and path == "/api/v1/users/me": return self.get_me(request_id)
|
||||
if method == "POST" and path == "/api/v1/chats": return self.create_chat(request_id)
|
||||
if method == "GET" and path == "/api/v1/chats": return self.list_chats(request_id, query)
|
||||
|
||||
m = re.fullmatch(r"/api/v1/chats/([^/]+)", path)
|
||||
if m and method == "GET": return self.get_chat(request_id, m.group(1))
|
||||
|
||||
m = re.fullmatch(r"/api/v1/chats/([^/]+)/messages", path)
|
||||
if m:
|
||||
if method == "POST": return self.create_message(request_id, m.group(1))
|
||||
if method == "GET": return self.list_messages(request_id, m.group(1), query)
|
||||
|
||||
raise APIError(404, "not_found", "Not found")
|
||||
except APIError as exc:
|
||||
self.send_error_json(exc.status, exc.code, exc.message, request_id)
|
||||
except Exception:
|
||||
self.log_error("Unhandled: %s", traceback.format_exc())
|
||||
self.send_error_json(500, "internal_error", "Internal error", request_id)
|
||||
|
||||
def create_user(self, request_id):
|
||||
body = read_json(self)
|
||||
username = body.get("username")
|
||||
display_name = body.get("display_name")
|
||||
password = body.get("password")
|
||||
if not username or not re.fullmatch(r"[a-z0-9_]{3,32}", username):
|
||||
raise APIError(400, "invalid_request", "Invalid username")
|
||||
if not password or len(password) < 8:
|
||||
raise APIError(400, "invalid_request", "Password must be at least 8 chars")
|
||||
|
||||
pw_hash = bcrypt.hashpw(password.encode('utf-8'), bcrypt.gensalt()).decode('utf-8')
|
||||
uid = str(uuid.uuid4())
|
||||
|
||||
conn = db_pool.getconn()
|
||||
try:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute(
|
||||
"INSERT INTO users (id, username, display_name, password_hash) VALUES (%s, %s, %s, %s) RETURNING created_at",
|
||||
(uid, username, display_name, pw_hash)
|
||||
)
|
||||
created_at = cur.fetchone()[0]
|
||||
conn.commit()
|
||||
self.send_json(201, {"id": uid, "username": username, "display_name": display_name, "created_at": format_dt(created_at)}, request_id)
|
||||
except psycopg2.errors.UniqueViolation:
|
||||
conn.rollback()
|
||||
raise APIError(409, "conflict", "Username taken")
|
||||
finally:
|
||||
db_pool.putconn(conn)
|
||||
|
||||
def create_session(self, request_id):
|
||||
auth = self.headers.get("Authorization")
|
||||
if not auth or not auth.startswith("Basic "):
|
||||
raise APIError(401, "unauthorized", "Missing Basic auth")
|
||||
try:
|
||||
decoded = base64.b64decode(auth.split(" ")[1]).decode('utf-8')
|
||||
username, password = decoded.split(':', 1)
|
||||
except Exception:
|
||||
raise APIError(401, "unauthorized", "Invalid Basic format")
|
||||
|
||||
conn = db_pool.getconn()
|
||||
try:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute("SELECT id, display_name, password_hash, created_at FROM users WHERE username = %s", (username,))
|
||||
row = cur.fetchone()
|
||||
if not row or not bcrypt.checkpw(password.encode('utf-8'), row[2].encode('utf-8')):
|
||||
raise APIError(401, "unauthorized", "Invalid credentials")
|
||||
|
||||
token = secrets.token_urlsafe(32)
|
||||
redis_client.setex(f"session:{token}", SESSION_TTL, row[0])
|
||||
expires_at = datetime.now(timezone.utc) + timedelta(seconds=SESSION_TTL)
|
||||
|
||||
self.send_json(201, {
|
||||
"token": token, "token_type": "Bearer", "expires_at": format_dt(expires_at),
|
||||
"user": {"id": str(row[0]), "username": username, "display_name": row[1], "created_at": format_dt(row[3])}
|
||||
}, request_id)
|
||||
finally:
|
||||
db_pool.putconn(conn)
|
||||
|
||||
def delete_session(self, request_id):
|
||||
auth = self.headers.get("Authorization")
|
||||
if auth and auth.startswith("Bearer "):
|
||||
token = auth.split(" ")[1]
|
||||
if redis_client.get(f"session:{token}"):
|
||||
redis_client.delete(f"session:{token}")
|
||||
self.send_json(204, None, request_id)
|
||||
else:
|
||||
raise APIError(401, "unauthorized", "Already logged out")
|
||||
else:
|
||||
raise APIError(401, "unauthorized", "Missing Bearer")
|
||||
|
||||
def get_me(self, request_id):
|
||||
actor = get_user_by_token(self)
|
||||
self.send_json(200, actor, request_id)
|
||||
|
||||
def create_chat(self, request_id):
|
||||
actor = get_user_by_token(self)
|
||||
body = read_json(self)
|
||||
title = body.get("title")
|
||||
member_ids = body.get("member_ids")
|
||||
if not title or not isinstance(member_ids, list):
|
||||
raise APIError(400, "invalid_request", "Invalid body")
|
||||
|
||||
cid = str(uuid.uuid4())
|
||||
conn = db_pool.getconn()
|
||||
try:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute("INSERT INTO chats (id, title) VALUES (%s, %s) RETURNING created_at", (cid, title))
|
||||
created_at = cur.fetchone()[0]
|
||||
for uid in member_ids:
|
||||
cur.execute("INSERT INTO chat_members (chat_id, user_id) VALUES (%s, %s)", (cid, uid))
|
||||
conn.commit()
|
||||
self.send_json(201, {"id": cid, "title": title, "member_ids": member_ids, "created_at": format_dt(created_at)}, request_id)
|
||||
except Exception:
|
||||
conn.rollback()
|
||||
raise
|
||||
finally:
|
||||
db_pool.putconn(conn)
|
||||
|
||||
def list_chats(self, request_id, query):
|
||||
actor = get_user_by_token(self)
|
||||
limit = parse_limit(query)
|
||||
conn = db_pool.getconn()
|
||||
try:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute("""
|
||||
SELECT c.id, c.title, c.created_at FROM chats c
|
||||
JOIN chat_members cm ON c.id = cm.chat_id
|
||||
WHERE cm.user_id = %s ORDER BY c.created_at DESC LIMIT %s
|
||||
""", (actor["id"], limit + 1))
|
||||
rows = cur.fetchall()
|
||||
has_more = len(rows) > limit
|
||||
rows = rows[:limit]
|
||||
|
||||
items = []
|
||||
for r in rows:
|
||||
cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s", (r[0],))
|
||||
members = [str(m[0]) for m in cur.fetchall()]
|
||||
items.append({
|
||||
"id": str(r[0]), "title": r[1], "member_ids": members, "created_at": format_dt(r[2])
|
||||
})
|
||||
self.send_json(200, {"items": items, "next_cursor": None}, request_id)
|
||||
finally:
|
||||
db_pool.putconn(conn)
|
||||
|
||||
def get_chat(self, request_id, chat_id):
|
||||
actor = get_user_by_token(self)
|
||||
conn = db_pool.getconn()
|
||||
try:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute("""
|
||||
SELECT c.id, c.title, c.created_at FROM chats c
|
||||
JOIN chat_members cm ON c.id = cm.chat_id
|
||||
WHERE c.id = %s AND cm.user_id = %s
|
||||
""", (chat_id, actor["id"]))
|
||||
row = cur.fetchone()
|
||||
if not row: raise APIError(404, "not_found", "Chat not found")
|
||||
|
||||
cur.execute("SELECT user_id FROM chat_members WHERE chat_id = %s", (chat_id,))
|
||||
members = [str(r[0]) for r in cur.fetchall()]
|
||||
|
||||
self.send_json(200, {"id": str(row[0]), "title": row[1], "member_ids": members, "created_at": format_dt(row[2])}, request_id)
|
||||
finally:
|
||||
db_pool.putconn(conn)
|
||||
|
||||
def create_message(self, request_id, chat_id):
|
||||
actor = get_user_by_token(self)
|
||||
|
||||
# Идемпотентность (Lab 3)
|
||||
idem_key = self.headers.get("Idempotency-Key")
|
||||
if not idem_key:
|
||||
raise APIError(400, "invalid_request", "Idempotency-Key header is required")
|
||||
|
||||
conn = db_pool.getconn()
|
||||
try:
|
||||
with conn.cursor() as cur:
|
||||
# Проверяем членство
|
||||
cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, actor["id"]))
|
||||
if not cur.fetchone(): raise APIError(404, "not_found", "Chat not found")
|
||||
|
||||
body = read_json(self)
|
||||
text = body.get("text")
|
||||
if not text: raise APIError(400, "invalid_request", "Empty text")
|
||||
|
||||
# Хэш тела для проверки консистентности ключа
|
||||
body_hash = hashlib.sha256(text.encode('utf-8')).hexdigest()
|
||||
|
||||
# Ищем ключ
|
||||
cur.execute("SELECT message_id, body_hash FROM idempotency_keys WHERE user_id = %s AND idem_key = %s", (actor["id"], idem_key))
|
||||
existing = cur.fetchone()
|
||||
|
||||
if existing:
|
||||
if existing[1] != body_hash:
|
||||
raise APIError(409, "conflict", "Idempotency key used with different body")
|
||||
# Возвращаем старое сообщение
|
||||
cur.execute("SELECT id, sender_id, text, created_at FROM messages WHERE id = %s", (existing[0],))
|
||||
row = cur.fetchone()
|
||||
return self.send_json(201, {
|
||||
"id": str(row[0]), "chat_id": chat_id, "sender_id": str(row[1]), "text": row[2], "created_at": format_dt(row[3])
|
||||
}, request_id)
|
||||
|
||||
mid = str(uuid.uuid4())
|
||||
cur.execute(
|
||||
"INSERT INTO messages (id, chat_id, sender_id, text) VALUES (%s, %s, %s, %s) RETURNING created_at",
|
||||
(mid, chat_id, actor["id"], text)
|
||||
)
|
||||
created_at = cur.fetchone()[0]
|
||||
|
||||
cur.execute(
|
||||
"INSERT INTO idempotency_keys (idem_key, user_id, message_id, body_hash) VALUES (%s, %s, %s, %s)",
|
||||
(idem_key, actor["id"], mid, body_hash)
|
||||
)
|
||||
conn.commit()
|
||||
self.send_json(201, {"id": mid, "chat_id": chat_id, "sender_id": actor["id"], "text": text, "created_at": format_dt(created_at)}, request_id)
|
||||
except psycopg2.errors.UniqueViolation:
|
||||
conn.rollback()
|
||||
raise APIError(409, "conflict", "Concurrent request conflict")
|
||||
finally:
|
||||
db_pool.putconn(conn)
|
||||
|
||||
def list_messages(self, request_id, chat_id, query):
|
||||
actor = get_user_by_token(self)
|
||||
limit = parse_limit(query)
|
||||
cursor = query.get("cursor", [None])[0]
|
||||
|
||||
conn = db_pool.getconn()
|
||||
try:
|
||||
with conn.cursor() as cur:
|
||||
cur.execute("SELECT 1 FROM chat_members WHERE chat_id = %s AND user_id = %s", (chat_id, actor["id"]))
|
||||
if not cur.fetchone(): raise APIError(404, "not_found", "Chat not found")
|
||||
|
||||
if cursor:
|
||||
ts, iid = decode_cursor(cursor, "messages", chat_id)
|
||||
cur.execute("""
|
||||
SELECT id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = %s AND (created_at, id) > (%s, %s)
|
||||
ORDER BY created_at, id LIMIT %s
|
||||
""", (chat_id, ts, iid, limit + 1))
|
||||
else:
|
||||
cur.execute("""
|
||||
SELECT id, sender_id, text, created_at FROM messages
|
||||
WHERE chat_id = %s ORDER BY created_at, id LIMIT %s
|
||||
""", (chat_id, limit + 1))
|
||||
|
||||
rows = cur.fetchall()
|
||||
has_more = len(rows) > limit
|
||||
rows = rows[:limit]
|
||||
|
||||
items = [{"id": str(r[0]), "chat_id": chat_id, "sender_id": str(r[1]), "text": r[2], "created_at": format_dt(r[3])} for r in rows]
|
||||
next_cursor = encode_cursor("messages", chat_id, items[-1]) if has_more and items else None
|
||||
|
||||
self.send_json(200, {"items": items, "next_cursor": next_cursor}, request_id)
|
||||
finally:
|
||||
db_pool.putconn(conn)
|
||||
|
||||
def send_json(self, status, payload, request_id):
|
||||
self._status = status
|
||||
if status == 204:
|
||||
self.send_response(204)
|
||||
self.send_header("X-Request-Id", request_id)
|
||||
self.send_header("X-Instance-Id", INSTANCE_ID)
|
||||
self.end_headers()
|
||||
return
|
||||
body = json.dumps(payload, ensure_ascii=False).encode("utf-8")
|
||||
self.send_response(status)
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("X-Request-Id", request_id)
|
||||
self.send_header("X-Instance-Id", INSTANCE_ID)
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
def send_error_json(self, status, code, message, request_id):
|
||||
self._status = status
|
||||
body = json.dumps({"error": {"code": code, "message": message, "request_id": request_id}}, ensure_ascii=False).encode("utf-8")
|
||||
self.send_response(status)
|
||||
if status == 401:
|
||||
parsed_path = urlparse(self.path).path
|
||||
if parsed_path == "/api/v1/auth/sessions":
|
||||
self.send_header("WWW-Authenticate", 'Basic realm="messenger", charset="UTF-8"')
|
||||
else:
|
||||
self.send_header("WWW-Authenticate", 'Bearer realm="messenger"')
|
||||
|
||||
self.send_header("Content-Type", "application/json")
|
||||
self.send_header("X-Request-Id", request_id)
|
||||
self.send_header("X-Instance-Id", INSTANCE_ID)
|
||||
self.send_header("Content-Length", str(len(body)))
|
||||
self.end_headers()
|
||||
self.wfile.write(body)
|
||||
|
||||
def main():
|
||||
ThreadingHTTPServer.daemon_threads = True
|
||||
ThreadingHTTPServer.allow_reuse_address = True
|
||||
server = ThreadingHTTPServer((HOST, PORT), Handler)
|
||||
def shutdown(signum, frame):
|
||||
threading.Thread(target=server.shutdown, daemon=True).start()
|
||||
signal.signal(signal.SIGTERM, shutdown)
|
||||
signal.signal(signal.SIGINT, shutdown)
|
||||
print(f"Listening on {HOST}:{PORT}", file=sys.stderr)
|
||||
try:
|
||||
server.serve_forever()
|
||||
finally:
|
||||
server.server_close()
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,54 @@
|
||||
services:
|
||||
db:
|
||||
image: postgres:16-alpine
|
||||
environment:
|
||||
POSTGRES_DB: messenger
|
||||
POSTGRES_USER: postgres
|
||||
POSTGRES_PASSWORD: secret
|
||||
volumes:
|
||||
- pgdata:/var/lib/postgresql/data
|
||||
- ./migrations:/docker-entrypoint-initdb.d
|
||||
healthcheck:
|
||||
test: ["CMD-SHELL", "pg_isready -U postgres -d messenger"]
|
||||
interval: 5s
|
||||
retries: 5
|
||||
|
||||
redis:
|
||||
image: valkey/valkey:7-alpine
|
||||
volumes:
|
||||
- redisdata:/data
|
||||
healthcheck:
|
||||
test: ["CMD", "valkey-cli", "ping"]
|
||||
interval: 5s
|
||||
|
||||
api:
|
||||
build: .
|
||||
environment:
|
||||
- DB_HOST=db
|
||||
- DB_USER=postgres
|
||||
- DB_PASSWORD=secret
|
||||
- DB_NAME=messenger
|
||||
- REDIS_HOST=redis
|
||||
depends_on:
|
||||
db:
|
||||
condition: service_healthy
|
||||
redis:
|
||||
condition: service_healthy
|
||||
deploy:
|
||||
resources:
|
||||
limits:
|
||||
cpus: '0.50'
|
||||
memory: 256M
|
||||
|
||||
lb:
|
||||
image: nginx:1.25-alpine
|
||||
ports:
|
||||
- "8080:8080"
|
||||
volumes:
|
||||
- ./nginx.conf:/etc/nginx/nginx.conf:ro
|
||||
depends_on:
|
||||
- api
|
||||
|
||||
volumes:
|
||||
pgdata:
|
||||
redisdata:
|
||||
@@ -0,0 +1,8 @@
|
||||
=== ДОКАЗАТЕЛЬСТВО БАЛАНСИРОВКИ (X-Instance-Id) ===
|
||||
Отправляем 6 запросов подряд на /health/live через LB:
|
||||
Запрос 1 -> Instance: 3a56b26f
|
||||
Запрос 2 -> Instance: f77806aa
|
||||
Запрос 3 -> Instance: 539b5e75
|
||||
Запрос 4 -> Instance: 300d3a50
|
||||
Запрос 5 -> Instance: 3a56b26f
|
||||
Запрос 6 -> Instance: f77806aa
|
||||
@@ -0,0 +1,6 @@
|
||||
=== ТЕСТ ИДЕМПОТЕНТНОСТИ ===
|
||||
Отправка №1:
|
||||
ID сообщения: f60e7810-c30c-40d0-bac9-bedf16af2403
|
||||
Отправка №2 (с тем же ключом):
|
||||
ID сообщения: f60e7810-c30c-40d0-bac9-bedf16af2403
|
||||
РЕЗУЛЬТАТ: УСПЕХ. ID совпадают, дубля нет.
|
||||
@@ -0,0 +1,18 @@
|
||||
=== ТЕСТ ОТКАЗА РЕПЛИКИ (FAILOVER) ===
|
||||
1. Контейнеры ДО остановки:
|
||||
NAMES STATUS
|
||||
mtusi2026lab3-api-3 Up 3 minutes (healthy)
|
||||
mtusi2026lab3-api-2 Up 3 minutes (healthy)
|
||||
mtusi2026lab3-api-4 Up 3 minutes (healthy)
|
||||
mtusi2026lab3-api-1 Up 3 minutes (healthy)
|
||||
2. Останавливаем одну реплику (stop-one.bat)...
|
||||
Stopping API replica: c9a0e03e7a26
|
||||
c9a0e03e7a26
|
||||
3. Контейнеры ПОСЛЕ остановки:
|
||||
NAMES STATUS
|
||||
mtusi2026lab3-api-2 Up 3 minutes (healthy)
|
||||
mtusi2026lab3-api-4 Up 3 minutes (healthy)
|
||||
mtusi2026lab3-api-1 Up 3 minutes (healthy)
|
||||
4. Проверяем доступность через LB:
|
||||
HTTP Статус от LB: 200 (ожидается 200)
|
||||
5. Восстанавливаем реплики обратно...
|
||||
@@ -0,0 +1,4 @@
|
||||
=== ТЕСТ ПОЛНОГО РЕСТАРТА ===
|
||||
Перезапускаем весь стенд (docker compose restart)...
|
||||
Пробуем прочитать чат старым токеном...
|
||||
УСПЕХ: Токен действителен. Прочитано сообщений: 1
|
||||
@@ -0,0 +1,6 @@
|
||||
=== ТРЕК 1: ЦЕНА МАСШТАБИРОВАНИЯ ===
|
||||
Время: 11/09/2026 12:58:18
|
||||
CPU лимит: 0.50 на каждую реплику
|
||||
Реплик: 1 | RPS: 59.026 | p95: 698.792 ms | Ошибки: 12
|
||||
Реплик: 2 | RPS: 133.921 | p95: 361.008 ms | Ошибки: 2
|
||||
Реплик: 4 | RPS: 210.545 | p95: 271.125 ms | Ошибки: 0
|
||||
@@ -0,0 +1,44 @@
|
||||
CREATE TABLE users (
|
||||
id UUID PRIMARY KEY,
|
||||
username VARCHAR(32) UNIQUE NOT NULL,
|
||||
display_name VARCHAR(100) NOT NULL,
|
||||
password_hash VARCHAR(255) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
CREATE TABLE chats (
|
||||
id UUID PRIMARY KEY,
|
||||
title VARCHAR(100) NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
CREATE TABLE chat_members (
|
||||
chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
|
||||
user_id UUID REFERENCES users(id) ON DELETE CASCADE,
|
||||
PRIMARY KEY (chat_id, user_id)
|
||||
);
|
||||
|
||||
CREATE TABLE messages (
|
||||
id UUID PRIMARY KEY,
|
||||
chat_id UUID REFERENCES chats(id) ON DELETE CASCADE,
|
||||
sender_id UUID REFERENCES users(id) ON DELETE CASCADE,
|
||||
text TEXT NOT NULL,
|
||||
created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
|
||||
);
|
||||
|
||||
|
||||
CREATE INDEX idx_messages_chat_created ON messages (chat_id, created_at, id);
|
||||
|
||||
CREATE TABLE sessions (
|
||||
token VARCHAR(64) PRIMARY KEY,
|
||||
user_id UUID REFERENCES users(id) ON DELETE CASCADE,
|
||||
expires_at TIMESTAMPTZ NOT NULL
|
||||
);
|
||||
CREATE TABLE idempotency_keys (
|
||||
idem_key VARCHAR(128),
|
||||
user_id UUID REFERENCES users(id),
|
||||
message_id UUID REFERENCES messages(id),
|
||||
body_hash VARCHAR(64) NOT NULL,
|
||||
created_at TIMESTAMPTZ DEFAULT NOW(),
|
||||
PRIMARY KEY (user_id, idem_key)
|
||||
);
|
||||
+19
@@ -0,0 +1,19 @@
|
||||
events { worker_connections 1024; }
|
||||
|
||||
http {
|
||||
upstream api_backend {
|
||||
server api:8080 max_fails=3 fail_timeout=5s;
|
||||
}
|
||||
|
||||
server {
|
||||
listen 8080;
|
||||
|
||||
location / {
|
||||
proxy_pass http://api_backend;
|
||||
proxy_set_header Host $host;
|
||||
proxy_set_header X-Real-IP $remote_addr;
|
||||
proxy_connect_timeout 2s;
|
||||
proxy_read_timeout 5s;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,2 @@
|
||||
@echo off
|
||||
docker compose restart api db redis
|
||||
@@ -0,0 +1,8 @@
|
||||
@echo off
|
||||
for /f "tokens=*" %%i in ('docker ps -q -f "name=mtusi2026lab3-api-"') do (
|
||||
echo Stopping API replica: %%i
|
||||
docker stop %%i
|
||||
exit /b 0
|
||||
)
|
||||
echo No API replicas found.
|
||||
exit /b 1
|
||||
@@ -0,0 +1,24 @@
|
||||
# Функция теста
|
||||
function Test-Scale($replicas, $cpu_limit) {
|
||||
Write-Host "`n--- Тестируем $replicas реплик (CPU лимит: $cpu_limit) ---" -ForegroundColor Cyan
|
||||
docker compose down -v
|
||||
# Меняем лимит в compose (через sed или параметр, но проще поправить руками или использовать переменные окружения)
|
||||
# Для простоты: остановим всё и запустим с нужным количеством
|
||||
docker compose up -d --build --scale api=$replicas
|
||||
Start-Sleep -Seconds 8
|
||||
|
||||
# Прогрев
|
||||
python tests/load.py --base-url http://localhost:8080 --duration 5 --concurrency 10 > $null
|
||||
|
||||
# Замер
|
||||
$result = python tests/load.py --base-url http://localhost:8080 --duration 15 --concurrency 20 | ConvertFrom-Json
|
||||
Write-Host "Результат: RPS = $($result.successful_rps), p95 = $($result.successful_latency_ms.p95) ms" -ForegroundColor Green
|
||||
|
||||
# Собираем загрузку БД (опционально)
|
||||
docker stats --no-stream --format "DB CPU: {{.CPUPerc}}" mtusi2026lab3-db-1
|
||||
}
|
||||
|
||||
# Запускаем серию
|
||||
Test-Scale -replicas 1 -cpu_limit 2.0
|
||||
Test-Scale -replicas 2 -cpu_limit 1.0
|
||||
Test-Scale -replicas 4 -cpu_limit 0.5
|
||||
Reference in New Issue
Block a user