forked from mtusi2026/mtusi2026lab3
add fix
This commit is contained in:
@@ -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
@@ -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;
|
||||
|
||||
@@ -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
@@ -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()
|
||||
Reference in New Issue
Block a user