Author SHA1 Message Date
xenia01 2bbe48bb7b Обновить REPORT.md 2026-11-10 10:43:15 +03:00
xenia01 631a852746 lab3: complete lab with scaling track 1 and failover evidence 2026-11-09 13:19:21 +03:00
13 changed files with 690 additions and 24 deletions
+53 -24
View File
@@ -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-среду.
+444
View File
@@ -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()
+54
View File
@@ -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:
+8
View File
@@ -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
+6
View File
@@ -0,0 +1,6 @@
=== ТЕСТ ИДЕМПОТЕНТНОСТИ ===
Отправка №1:
ID сообщения: f60e7810-c30c-40d0-bac9-bedf16af2403
Отправка №2 (с тем же ключом):
ID сообщения: f60e7810-c30c-40d0-bac9-bedf16af2403
РЕЗУЛЬТАТ: УСПЕХ. ID совпадают, дубля нет.
+18
View File
@@ -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. Восстанавливаем реплики обратно...
+4
View File
@@ -0,0 +1,4 @@
=== ТЕСТ ПОЛНОГО РЕСТАРТА ===
Перезапускаем весь стенд (docker compose restart)...
Пробуем прочитать чат старым токеном...
УСПЕХ: Токен действителен. Прочитано сообщений: 1
+6
View File
@@ -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
+44
View File
@@ -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
View File
@@ -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;
}
}
}
+2
View File
@@ -0,0 +1,2 @@
@echo off
docker compose restart api db redis
+8
View File
@@ -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
+24
View File
@@ -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