diff --git a/REPORT.md b/REPORT.md index c2679005..20b6b4c7 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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 +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-среду. diff --git a/app.py b/app.py new file mode 100644 index 00000000..57fd0bb2 --- /dev/null +++ b/app.py @@ -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() \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 00000000..7dbfcce0 --- /dev/null +++ b/docker-compose.yml @@ -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: \ No newline at end of file diff --git a/evidence/01_instances.txt b/evidence/01_instances.txt new file mode 100644 index 00000000..eefa00ef --- /dev/null +++ b/evidence/01_instances.txt @@ -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 diff --git a/evidence/02_idempotency.txt b/evidence/02_idempotency.txt new file mode 100644 index 00000000..a6d7185c --- /dev/null +++ b/evidence/02_idempotency.txt @@ -0,0 +1,6 @@ +=== ТЕСТ ИДЕМПОТЕНТНОСТИ === +Отправка №1: +ID сообщения: f60e7810-c30c-40d0-bac9-bedf16af2403 +Отправка №2 (с тем же ключом): +ID сообщения: f60e7810-c30c-40d0-bac9-bedf16af2403 +РЕЗУЛЬТАТ: УСПЕХ. ID совпадают, дубля нет. diff --git a/evidence/03_failover.txt b/evidence/03_failover.txt new file mode 100644 index 00000000..424e5bf3 --- /dev/null +++ b/evidence/03_failover.txt @@ -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. Восстанавливаем реплики обратно... diff --git a/evidence/04_persistence.txt b/evidence/04_persistence.txt new file mode 100644 index 00000000..bf78167c --- /dev/null +++ b/evidence/04_persistence.txt @@ -0,0 +1,4 @@ +=== ТЕСТ ПОЛНОГО РЕСТАРТА === +Перезапускаем весь стенд (docker compose restart)... +Пробуем прочитать чат старым токеном... +УСПЕХ: Токен действителен. Прочитано сообщений: 1 diff --git a/evidence/05_track1_metrics.txt b/evidence/05_track1_metrics.txt new file mode 100644 index 00000000..50821b4c --- /dev/null +++ b/evidence/05_track1_metrics.txt @@ -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 diff --git a/migrations/001_init.sql b/migrations/001_init.sql new file mode 100644 index 00000000..89c4000b --- /dev/null +++ b/migrations/001_init.sql @@ -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) +); \ No newline at end of file diff --git a/nginx.conf b/nginx.conf new file mode 100644 index 00000000..cb3d1261 --- /dev/null +++ b/nginx.conf @@ -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; + } + } +} \ No newline at end of file diff --git a/scripts/restart.bat b/scripts/restart.bat new file mode 100644 index 00000000..ae7f413e --- /dev/null +++ b/scripts/restart.bat @@ -0,0 +1,2 @@ +@echo off +docker compose restart api db redis \ No newline at end of file diff --git a/scripts/stop-one.bat b/scripts/stop-one.bat new file mode 100644 index 00000000..c20cd34f --- /dev/null +++ b/scripts/stop-one.bat @@ -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 \ No newline at end of file diff --git a/scripts/track1.ps1 b/scripts/track1.ps1 new file mode 100644 index 00000000..009f9c9c --- /dev/null +++ b/scripts/track1.ps1 @@ -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 \ No newline at end of file