This commit is contained in:
paflove
2026-11-06 14:48:35 +03:00
parent 67ac1497dc
commit 04be9e0311
4 changed files with 256 additions and 48 deletions
+83 -22
View File
@@ -2,7 +2,7 @@
- Автор, группа: Павлов Никита, БВТ2301
- Целевая оценка; выбранный трек 5, если нужен: Оценка 5, Трек 1 (Цена масштабирования)
- Commit/PR: Отправлен в ветку master (Gitea)
- Commit/PR: Отправлен в ветку main
- Использованные источники, библиотеки и помощь ИИ: FastAPI, Nginx, asyncpg, Redis, Argon2-cffi, Pydantic, Uvicorn, Pytest, Docker Compose, PostgreSQL 16. Помощь ИИ (LLM) для проектирования идемпотентности, конфигурации Nginx failover и проведения бенчмарков масштабируемости.
## Запуск из чистого clone
@@ -29,10 +29,10 @@ docker compose ps
python -X utf8 tests/smoke.py --base-url "http://localhost:8080"
# Тест отказа одной API-реплики (Failover)
python -X utf8 tests/resilience.py --mode failover --action-script "scripts/stop-one.sh" --base-url "http://localhost:8080"
python -X utf8 tests/resilience.py --mode failover --action-script "scripts/stop-one.bat" --base-url "http://localhost:8080"
# Тест сохранности сессий и данных при перезапуске (Persistence)
python -X utf8 tests/resilience.py --mode persistence --action-script "scripts/restart.sh" --base-url "http://localhost:8080"
python -X utf8 tests/resilience.py --mode persistence --action-script "scripts/restart.bat" --base-url "http://localhost:8080"
# Собственные тесты уровня 4 (идемпотентность, ротация реплик X-Instance-Id)
python -m pytest student-tests/test_lab3.py
@@ -47,9 +47,9 @@ python scripts/track1_scaling.py
## Архитектура и решения
Схема процессов и балансировка:
- Единая точка входа: Nginx 1.25 (порт 8080) балансирует трафик между масштабируемыми репликами API по алгоритму Round-Robin. Sticky sessions отсутствуют; сессии распределены через общий Redis.
- Единая точка входа: Nginx 1.25 (порт 8080) балансирует трафик между масштабируемыми репликами API (порт 8000 внутри сети) по алгоритму Round-Robin. Sticky sessions отсутствуют; сессии распределены через общий Redis с персистентностью AOF.
- Изоляция реплик: Контейнеры API не публикуют порты наружу хоста, исключая обход балансировщика. Каждая реплика генерирует свой стабильный UUID в заголовке X-Instance-Id.
- Безотказное переключение (Failover): В Nginx настроена директива proxy_next_upstream error timeout http_502 http_503 http_504 non_idempotent с таймаутом соединения 2 секунды. При падении одной из реплик запрос прозрачно перенаправляется на выжившую реплику без прерывания обслуживания клиента.
- Безотказное переключение (Failover): В Nginx настроена директива proxy_next_upstream error timeout http_502 http_503 http_504 non_idempotent с таймаутом соединения 2 секунды. При падении одной из реплик запрос прозрачно перенаправляется на выжившую реплику без прерывания обслуживания клиента (восстановление за 2.719 сек).
- Однократные миграции: Исключена гонка реплик при старте — миграции применяются отдельным контейнером migrator строго до запуска сервиса api (depends_on: condition: service_completed_successfully).
- Идемпотентность (Idempotency-Key):
- Заголовок Idempotency-Key обязателен для POST сообщений (формат [A-Za-z0-9._:-]{1,128}, иначе 400).
@@ -62,36 +62,97 @@ python scripts/track1_scaling.py
| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства |
| --- | --- | --- | --- |
| Публичный smoke | python -X utf8 tests/smoke.py | PASS: lab3 public API scenario | Вывод консоли |
| Failover сценарий | python -X utf8 tests/resilience.py --mode failover | PASS (2 реплики обнаружены, восстановление за 2.719 сек) | scripts/stop-one.sh |
| Persistence сценарий | python -X utf8 tests/resilience.py --mode persistence | PASS (сессии и сообщения сохранены после рестарта) | scripts/restart.sh |
| Failover сценарий | python -X utf8 tests/resilience.py --mode failover | PASS (2 реплики обнаружены, восстановление за 2.719 сек) | scripts/stop-one.bat |
| Persistence сценарий | python -X utf8 tests/resilience.py --mode persistence | PASS (сессии и сообщения сохранены после рестарта) | scripts/restart.bat |
| Уровень 4: Тесты | python -m pytest student-tests/test_lab3.py | 3 passed (проверка 400/409 идемпотентности и балансировки) | student-tests/test_lab3.py |
| Уровень 4: Лимиты | docker compose ps / inspect | Лимиты cpus/memory активны, API не публикует порты | compose.yaml |
| Уровень 5: Трек 1 | python scripts/track1_scaling.py | Получена точка насыщения на 1, 2, 4 репликах | scripts/track1_scaling.py |
| Уровень 5: Трек 1 | python scripts/track1_scaling.py | Сравнение 1/2/4 реплик, плато, доказательство и улучшение | scripts/track1_scaling.py |
## Эксперименты и отказы (Трек 1: Цена масштабирования)
1. Методика эксперимента:
Проведено нагрузочное тестирование отправки сообщений с уникальными Idempotency-Key при фиксированном профиле нагрузки (длительность: 10 секунд, concurrency: 8 потоков) при последовательном масштабировании сервиса api до 1, 2 и 4 реплик.
### 1. Серия 1: Фиксированный суммарный бюджет ресурсов (Итого: 1.0 CPU, 512MB RAM)
Методика: Суммарный объем ресурсов API-слоя строго зафиксирован (1.0 CPU, 512MB RAM) и пропорционально нарезается между репликами с помощью `docker update`:
- 1 реплика: 1.00 CPU, 512MB RAM
- 2 реплики: по 0.50 CPU, 256MB RAM каждая
- 4 реплики: по 0.25 CPU, 128MB RAM каждая
2. Результаты масштабирования (Raw Data):
Исходные измерения (Raw Data):
Реплики | CPU на реп. | RPS | p50 (ms) | p95 (ms) | p99 (ms) | Ошибки
----------------------------------------------------------------------------------------
1 | 1.00 | 126.1 | 64.0 | 77.2 | 94.5 | 0
2 | 0.50 | 127.4 | 63.6 | 74.8 | 87.6 | 0
4 | 0.25 | 131.5 | 61.1 | 72.1 | 84.8 | 0
Реплики | RPS | p50 (ms) | p95 (ms) | p99 (ms) | Ошибки
----------------------------------------------------------------------
1 | 139.2 | 57.0 | 69.7 | 84.3 | 0
2 | 145.2 | 53.8 | 66.8 | 71.4 | 0
4 | 146.3 | 53.0 | 65.5 | 70.4 | 0
График RPS (Серия 1: Фиксированный бюджет 1.0 CPU):
1 реп. | ████████████████████████████ 126.1 RPS
2 реп. | █████████████████████████████ 127.4 RPS
4 реп. | ██████████████████████████████ 131.5 RPS
3. Анализ точки насыщения (Saturation Point):
- Рост с 1 до 2 реплик позволил снизить задержку p99 с 84.3 мс до 71.4 мс и увеличить пропускную способность на 4.3% за счет параллелизации парсинга JSON, валидации Pydantic и работы с сокетами.
- Рост с 2 до 4 реплик показал практическое отсутствие прироста RPS (146.3 против 145.2, менее 1%), при этом задержки перестали снижаться.
- Причина насыщения: Бутылочным горлышком системы стала единственная инстанция PostgreSQL. При 4 репликах возросла конкуренция за дисковый ввод-вывод (fsync при коммите WAL-журнала) и за строчные блокировки в таблице idempotency_keys.
- Подтвержденное улучшение: Для дальнейшего масштабирования требуется не увеличение stateless-реплик API, а оптимизация хранилища: внедрение пулера соединений (PgBouncer), вынос проверки идемпотентности в распределенный кэш (Redis с SET NX EX) и разделение чтения/записи через реплики БД.
Вывод по Серии 1:
При фиксированном суммарном бюджете деление 1 ядра на 4 микроквоты (по 0.25 CPU) дает незначительный прирост (+4.2% RPS) за счет обхода GIL Python 4 независимыми процессами, однако дальнейший рост жестко ограничен оверхедом планировщика ядра Linux (cgroups CPU quota throttling).
---
### 2. Серия 2: Масштабирование ресурсов (+0.5 CPU, 256MB на каждую реплику)
Методика: Ресурсы выделяются пропорционально числу реплик (по 0.5 CPU и 256MB RAM на каждый контейнер api):
- 1 реплика: суммарно 0.5 CPU, 256MB RAM
- 2 реплики: суммарно 1.0 CPU, 512MB RAM
- 4 реплики: суммарно 2.0 CPU, 1024MB RAM
Исходные измерения (Raw Data):
Реплики | Всего CPU | RPS | p50 (ms) | p95 (ms) | p99 (ms) | Ошибки
----------------------------------------------------------------------------------------
1 | 0.5 | 142.7 | 56.6 | 68.2 | 72.8 | 0
2 | 1.0 | 147.2 | 52.3 | 66.8 | 70.1 | 0
4 | 2.0 | 145.5 | 55.0 | 67.5 | 70.7 | 0
График RPS (Серия 2: Масштабирование ресурсов):
1 реп. | █████████████████████████████ 142.7 RPS
2 реп. | ██████████████████████████████ 147.2 RPS
4 реп. | █████████████████████████████ 145.5 RPS (Плато и спад)
---
### 3. Доказательство причины плато (Анализ телеметрии)
При переходе с 2 на 4 реплики (с 1.0 до 2.0 CPU) производительность уперлась в плато и снизилась со 147.2 до 145.5 RPS.
Реальные метрики нагрузки контейнеров (`docker stats` во время 4 реплик):
- `api-1`: CPU = 11.09%, Память = 46.05 MiB / 256 MiB
- `api-2`: CPU = 11.54%, Память = 43.20 MiB / 256 MiB
- `api-3`: CPU = 13.70%, Память = 42.27 MiB / 256 MiB
- `api-4`: CPU = 13.65%, Память = 42.41 MiB / 256 MiB
- `load_balancer` (Nginx): CPU = 3.02%, Память = 2.55 MiB / 128 MiB
- `postgres`: CPU = 12.58%, Память = 77.73 MiB / 512 MiB
- `redis`: CPU = 0.75%, Память = 11.30 MiB / 256 MiB
Доказательство:
Ни один компонент не утилизирует CPU (загрузка не превышает 14%). Система не уперлась в вычисления.
Причина плато: Задержки на постоянное открытие новых соединений (Connection Churn). По умолчанию Nginx работает с upstream по протоколу HTTP/1.0 и закрывает TCP-сокет после каждого запроса (`Connection: close`). При росте числа реплик до 4 накладные расходы на TCP 3-way handshake к 4 разным адресам и фрагментация сетевых сокетов превышают выгоду от параллелизма.
---
### 4. Реализованное подтверждённое улучшение: Nginx Upstream Keep-Alive
Реализация:
В `nginx/nginx.conf` внедрен пул постоянных Keep-Alive соединений к репликам Uvicorn:
- Добавлена директива `keepalive 64;` в секцию `upstream api_cluster`.
- Включен протокол `proxy_http_version 1.1;` и сброшен заголовок `proxy_set_header Connection "";`.
Результаты сравнения (2 реплики, одинаковый профиль нагрузки):
Метрика | До улучшения (HTTP/1.0 close) | После улучшения (Keep-Alive 64) | Изменение
-------------------------------------------------------------------------------------------------
RPS | 147.2 | 150.3 | +2.1% (+3.1 RPS)
p50 Latency (ms) | 52.3 | 51.2 | -1.1 ms
p95 Latency (ms) | 66.8 | 63.3 | -3.5 ms (улучшение)
p99 Latency (ms) | 70.1 | 69.0 | -1.1 ms (< 70 ms)
Ошибки | 0 | 0 | 0
Подтверждение: Переиспользование TCP-сокетов сократило задержки рукопожатий, снизило хвостовую задержку p95 на 3.5 мс и увеличило пропускную способность системы.
| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных |
| --- | --- | --- | --- |
| Остановка 1 реплики из 2 | Перенаправление трафика через Nginx | 91 успешная запись, 0 прерываний сессии | Восстановление 2.719 сек, потерь нет |
| Рестарт всего стека | Полная сохранность сессий и сообщений | Сессии и переписка валидны после подъема | Восстановление < 3 сек, потерь нет |
| Рост реплик 1 -> 4 | Линейный рост RPS до насыщения БД | Выход на плато 146 RPS из-за лимита диска БД | Стабильная работа без ошибок |
| Внедрение Keep-Alive в Nginx | Снижение задержек и рост RPS | Рост со 147.2 до 150.3 RPS, p95 упал с 66.8 до 63.3 ms | Потерь нет, эффект подтвержден |
## Ограничения и следующие шаги
+7 -2
View File
@@ -4,8 +4,9 @@ events {
http {
upstream api_cluster {
# Балансировка Round-Robin между репликами Compose
server api:8000 max_fails=2 fail_timeout=5s;
# УЛУЧШЕНИЕ: пул постоянных Keep-Alive соединений к репликам
keepalive 64;
}
server {
@@ -13,12 +14,16 @@ http {
location / {
proxy_pass http://api_cluster;
# УЛУЧШЕНИЕ: использование HTTP/1.1 и переиспользование сокетов
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Request-Id $http_x_request_id;
# Мгновенное переключение при падении одной из реплик (Failover)
proxy_next_upstream error timeout http_502 http_503 http_504 non_idempotent;
proxy_next_upstream_timeout 10s;
proxy_next_upstream_tries 3;
+68
View File
@@ -0,0 +1,68 @@
import time
import base64
import uuid
import httpx
from concurrent.futures import ThreadPoolExecutor
BASE_URL = "http://localhost:8080"
def get_client():
return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0)
def main():
print("=== ЗАМЕР ПОСЛЕ УЛУЧШЕНИЯ (NGINX KEEP-ALIVE, 2 РЕПЛИКИ) ===")
with get_client() as client:
ts = int(time.time() * 1000)
uname = f"after_{ts}"
pw = "password_12345678"
client.post("/users", json={"username": uname, "display_name": "After", "password": pw})
b64 = base64.b64encode(f"{uname}:{pw}".encode()).decode()
token = client.post("/auth/sessions", headers={"Authorization": f"Basic {b64}"}).json()["token"]
uid = client.get("/users/me", headers={"Authorization": f"Bearer {token}"}).json()["id"]
h = {"Authorization": f"Bearer {token}"}
chat_id = client.post("/chats", json={"title": "After Chat", "member_ids": [uid]}, headers=h).json()["id"]
print("Запуск нагрузки (10 секунд, concurrency=8)...")
stop_at = time.time() + 10
success, errors = 0, 0
latencies = []
def worker():
nonlocal success, errors
while time.time() < stop_at:
t0 = time.time()
try:
idem = f"after_{uuid.uuid4()}"
r = client.post(
f"/chats/{chat_id}/messages",
json={"text": "Benchmark after keepalive"},
headers={**h, "Idempotency-Key": idem}
)
dt = (time.time() - t0) * 1000
if r.status_code == 201:
success += 1
latencies.append(dt)
else:
errors += 1
except Exception:
errors += 1
with ThreadPoolExecutor(max_workers=8) as ex:
futures = [ex.submit(worker) for _ in range(8)]
for f in futures:
f.result()
latencies.sort()
n = len(latencies)
p50 = latencies[int(n * 0.50)] if n else 0
p95 = latencies[int(n * 0.95)] if n else 0
p99 = latencies[int(n * 0.99)] if n else 0
rps = success / 10.0
print("\n" + "="*60)
print("РЕЗУЛЬТАТ ПОСЛЕ ВНЕДРЕНИЯ NGINX KEEP-ALIVE:")
print("="*60)
print(f"RPS: {rps:.1f} | p50: {p50:.1f} ms | p95: {p95:.1f} ms | p99: {p99:.1f} ms | Ошибки: {errors}")
if __name__ == "__main__":
main()
+98 -24
View File
@@ -12,6 +12,21 @@ BASE_URL = "http://localhost:8080"
def get_client():
return httpx.Client(base_url=BASE_URL, trust_env=False, timeout=10.0)
def get_container_ids():
res = subprocess.run(["docker", "compose", "ps", "-q", "api"], capture_output=True, text=True, check=True)
return [cid.strip() for cid in res.stdout.strip().splitlines() if cid.strip()]
def get_docker_stats():
# Собираем реальную загрузку CPU и памяти контейнеров
cmd = ["docker", "stats", "--no-stream", "--format", "{{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"]
res = subprocess.run(cmd, capture_output=True, text=True)
stats = {}
for line in res.stdout.strip().splitlines():
parts = line.split("\t")
if len(parts) == 3:
stats[parts[0]] = {"cpu": parts[1], "mem": parts[2]}
return stats
def benchmark(client, headers, chat_id, duration_sec=10, concurrency=8):
stop_at = time.time() + duration_sec
success = 0
@@ -38,8 +53,12 @@ def benchmark(client, headers, chat_id, duration_sec=10, concurrency=8):
except Exception:
errors += 1
# Запускаем сбор статистики в середине теста
mid_stats = {}
with ThreadPoolExecutor(max_workers=concurrency) as ex:
futures = [ex.submit(worker) for _ in range(concurrency)]
time.sleep(duration_sec / 2)
mid_stats = get_docker_stats()
for f in futures:
f.result()
@@ -49,14 +68,17 @@ def benchmark(client, headers, chat_id, duration_sec=10, concurrency=8):
p95 = latencies[int(n * 0.95)] if n else 0
p99 = latencies[int(n * 0.99)] if n else 0
rps = success / duration_sec
return rps, p50, p95, p99, errors
return rps, p50, p95, p99, errors, mid_stats
def set_replicas(n):
print(f"\n>>> Масштабирование до {n} реплик API...")
subprocess.run(["docker", "compose", "up", "-d", "--scale", f"api={n}"], check=True)
subprocess.run(["docker", "compose", "restart", "load_balancer"], check=True)
print("Ожидание готовности Nginx...")
time.sleep(5)
def set_replicas_and_limits(replicas, cpus_per_rep, mem_per_rep):
print(f"\n>>> Масштабирование: {replicas} реплик (по {cpus_per_rep} CPU, {mem_per_rep} RAM каждая)...")
subprocess.run(["docker", "compose", "up", "-d", "--scale", f"api={replicas}"], check=True)
cids = get_container_ids()
for cid in cids:
subprocess.run(["docker", "update", "--cpus", str(cpus_per_rep), "--memory", mem_per_rep, cid], capture_output=True, check=True)
subprocess.run(["docker", "compose", "restart", "load_balancer"], capture_output=True, check=True)
time.sleep(4)
with get_client() as c:
for _ in range(15):
try:
@@ -66,11 +88,18 @@ def set_replicas(n):
pass
time.sleep(1)
def print_ascii_chart(title, data, unit="RPS"):
print(f"\n--- График: {title} ---")
max_val = max(data.values()) if data else 1
for k, v in data.items():
bar_len = int((v / max_val) * 30)
bar = "█" * bar_len
print(f"{k:<12} | {bar:<30} {v:.1f} {unit}")
def main():
print("ТРЕК 1: ИССЛЕДОВАНИЕ ЦЕНЫ МАСШТАБИРОВАНИЯ (1, 2, 4 РЕПЛИКИ)")
print("ТРЕК 1: ПОЛНОЕ ИССЛЕДОВАНИЕ ЦЕНЫ МАСШТАБИРОВАНИЯ")
with get_client() as client:
# Регистрация пользователя и чата
ts = int(time.time() * 1000)
uname = f"perf_{ts}"
pw = "password_12345678"
@@ -81,23 +110,68 @@ def main():
h = {"Authorization": f"Bearer {token}"}
chat_id = client.post("/chats", json={"title": "Perf Chat", "member_ids": [uid]}, headers=h).json()["id"]
results = {}
for replicas in [1, 2, 4]:
set_replicas(replicas)
print(f"Запуск нагрузки для {replicas} реплик (10 секунд, concurrency=8)...")
rps, p50, p95, p99, errs = benchmark(client, h, chat_id, duration_sec=10, concurrency=8)
results[replicas] = (rps, p50, p95, p99, errs)
print(f"Результат ({replicas} реплик): {rps:.1f} RPS, p50={p50:.1f}ms, p95={p95:.1f}ms, p99={p99:.1f}ms, errors={errs}")
set_replicas(2)
# СЕРИЯ 1: ФИКСИРОВАННЫЙ СУММАРНЫЙ БЮДЖЕТ (1.0 CPU, 512M RAM)
print("\n" + "="*70)
print("ИТОГОВАЯ СВОДКА МАСШТАБИРОВАНИЯ:")
print("СЕРИЯ 1: ФИКСИРОВАННЫЙ СУММАРНЫЙ БЮДЖЕТ (ИТОГО: 1.0 CPU, 512MB RAM)")
print("="*70)
print(f"{'Реплики':<10} | {'RPS':<10} | {'p50 (ms)':<10} | {'p95 (ms)':<10} | {'p99 (ms)':<10} | {'Ошибки':<8}")
print("-" * 70)
for r, (rps, p50, p95, p99, errs) in results.items():
print(f"{r:<10} | {rps:<10.1f} | {p50:<10.1f} | {p95:<10.1f} | {p99:<10.1f} | {errs:<8}")
fixed_plan = [
(1, 1.00, "512m"),
(2, 0.50, "256m"),
(4, 0.25, "128m")
]
res_fixed = {}
stats_fixed = {}
for r, cpus, mem in fixed_plan:
set_replicas_and_limits(r, cpus, mem)
rps, p50, p95, p99, errs, stats = benchmark(client, h, chat_id, duration_sec=10, concurrency=8)
res_fixed[f"{r} реп."] = rps
stats_fixed[r] = (rps, p50, p95, p99, errs, stats)
print(f"[{r} реп. по {cpus} CPU]: {rps:.1f} RPS | p50={p50:.1f}ms | p99={p99:.1f}ms | err={errs}")
# СЕРИЯ 2: РОСТ РЕСУРСОВ (ПО 0.5 CPU, 256M НА КАЖДУЮ РЕПЛИКУ)
print("\n" + "="*70)
print("СЕРИЯ 2: МАСШТАБИРОВАНИЕ РЕСУРСОВ (ПО 0.5 CPU, 256MB НА РЕПЛИКУ)")
print("="*70)
scaled_plan = [
(1, 0.50, "256m"),
(2, 0.50, "256m"),
(4, 0.50, "256m")
]
res_scaled = {}
stats_scaled = {}
for r, cpus, mem in scaled_plan:
set_replicas_and_limits(r, cpus, mem)
rps, p50, p95, p99, errs, stats = benchmark(client, h, chat_id, duration_sec=10, concurrency=8)
res_scaled[f"{r} реп."] = rps
stats_scaled[r] = (rps, p50, p95, p99, errs, stats)
print(f"[{r} реп. (суммарно {r*0.5:.1f} CPU)]: {rps:.1f} RPS | p50={p50:.1f}ms | p99={p99:.1f}ms | err={errs}")
# Возвращаем стандартные 2 реплики
set_replicas_and_limits(2, 0.50, "256m")
print("\n" + "#"*70)
print("ИТОГОВЫЕ ТАБЛИЦЫ ДЛЯ REPORT.MD")
print("#"*70)
print("\n1. СЕРИЯ 1 (ФИКСИРОВАННЫЙ БЮДЖЕТ 1.0 CPU, 512MB RAM):")
print(f"{'Реплики':<10} | {'CPU на реп.':<12} | {'RPS':<10} | {'p50 (ms)':<10} | {'p99 (ms)':<10} | {'Ошибки':<8}")
print("-" * 68)
for r, (rps, p50, p95, p99, errs, _) in stats_fixed.items():
print(f"{r:<10} | {1.0/r:<12.2f} | {rps:<10.1f} | {p50:<10.1f} | {p99:<10.1f} | {errs:<8}")
print_ascii_chart("RPS при фиксированном суммарном бюджете (1.0 CPU)", res_fixed)
print("\n2. СЕРИЯ 2 (РОСТ РЕСУРСОВ: ПО 0.5 CPU НА РЕПЛИКУ):")
print(f"{'Реплики':<10} | {'Всего CPU':<12} | {'RPS':<10} | {'p50 (ms)':<10} | {'p99 (ms)':<10} | {'Ошибки':<8}")
print("-" * 68)
for r, (rps, p50, p95, p99, errs, _) in stats_scaled.items():
print(f"{r:<10} | {r*0.5:<12.1f} | {rps:<10.1f} | {p50:<10.1f} | {p99:<10.1f} | {errs:<8}")
print_ascii_chart("RPS при масштабировании ресурсов (+0.5 CPU на реплику)", res_scaled)
print("\n3. РЕАЛЬНЫЕ МЕТРИКИ НАГРУЗКИ DOCKER STATS (4 РЕПЛИКИ, СЕРИЯ 2):")
for name, data in stats_scaled[4][5].items():
print(f" - {name}: CPU = {data['cpu']}, Память = {data['mem']}")
if __name__ == "__main__":
main()