From 04be9e0311e9bc6ff3fe5671317a694953863da2 Mon Sep 17 00:00:00 2001 From: paflove Date: Fri, 6 Nov 2026 14:48:35 +0300 Subject: [PATCH] add fix --- REPORT.md | 105 +++++++++++++++++++++++++------- nginx/nginx.conf | 9 ++- scripts/measure_after.py | 68 +++++++++++++++++++++ scripts/track1_scaling.py | 122 ++++++++++++++++++++++++++++++-------- 4 files changed, 256 insertions(+), 48 deletions(-) create mode 100644 scripts/measure_after.py diff --git a/REPORT.md b/REPORT.md index 6e4155ff..d9fc0a38 100644 --- a/REPORT.md +++ b/REPORT.md @@ -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 | Потерь нет, эффект подтвержден | ## Ограничения и следующие шаги diff --git a/nginx/nginx.conf b/nginx/nginx.conf index 7f4faa9d..3505d6d3 100644 --- a/nginx/nginx.conf +++ b/nginx/nginx.conf @@ -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; diff --git a/scripts/measure_after.py b/scripts/measure_after.py new file mode 100644 index 00000000..d9894cf0 --- /dev/null +++ b/scripts/measure_after.py @@ -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() \ No newline at end of file diff --git a/scripts/track1_scaling.py b/scripts/track1_scaling.py index 81d30d7d..d133b744 100644 --- a/scripts/track1_scaling.py +++ b/scripts/track1_scaling.py @@ -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() \ No newline at end of file