diff --git a/DEFENSE.pdf b/DEFENSE.pdf new file mode 100644 index 00000000..78a95adc Binary files /dev/null and b/DEFENSE.pdf differ diff --git a/REPORT.md b/REPORT.md index df209191..4faa9dbc 100644 --- a/REPORT.md +++ b/REPORT.md @@ -21,7 +21,7 @@ | Сессии | `redis` | `redis:7.4.6-alpine@sha256:3b73847e72874be07e6657b129a94761662b79bc0f679273757d4218573b2a98` | | LB | `lb` | `haproxy:3.2-bookworm@sha256:baecd003ae5c2376e58d04a5b2ffc7d82d30e9bebe2869f76222b819f719dee3` (HAProxy 3.2.3) | -**Аппарат (измерения 2026-10-30):** Windows 10, CPU `12th Gen Intel Core i7-12700H`, Docker Desktop Linux engine, `NCPU=20`, RAM VM ≈15.4 GiB. Лимиты контейнеров — в `compose.yaml`. Прогрев: health `start_period` API 20 с + 5 с warmup нагрузки. +**Аппарат (трек 1 переснят 2026-11-20):** Windows 10, CPU `12th Gen Intel Core i7-12700H`, Docker Desktop Linux engine, `NCPU=20`, RAM VM ≈15.4 GiB. Лимиты контейнеров — в `compose.yaml`. Прогрев: health `start_period` API 20 с + 5 с warmup нагрузки. Абсолютный RPS не сравнивать с прогоном 2026-10-30. **Команды (секреты не печатать):** @@ -96,29 +96,40 @@ mtusi-lab3-redis-1 Up (healthy) 127.0.0.1:6379->6379/tcp | Нет портов API наружу, лимиты, нет sticky | `docker compose ps` | API `8080/tcp` без host bind | `evidence/compose-ps.txt` | | Rolling под нагрузкой | `python student-tests/rolling.py` | оба id заменены; 1980 ok / 24 err (1.2%) | `evidence/rolling.json` | | Миграции однократно | `migrate` Exited 0 | `001_initial.sql` + `002_idempotency.sql` | `compose.yaml`, `migrations/` | -| Трек 1 | `python student-tests/track1.py` | 1→2→4 реплик при 1 CPU: 128→107→69 RPS; рост CPU линеен | `evidence/track1.json`, графики ниже | +| Трек 1 | `python student-tests/track1.py` (2026-11-20) | Свой 0.50 CPU: 1→2→4 = **31.5→55.4→80.7 RPS**. Нарезка 1 CPU: 67.6→37.1 | `evidence/track1.json`, графики ниже | | Подтверждённое улучшение | bind `[::1]:8080` | localhost ~1.9 RPS / p50~2s → 87.6 RPS / p50 75 мс | `evidence/load.json`, `evidence/load_localhost.json` | ## Эксперименты и отказы -**Гипотеза трека 1.** При фиксированном суммарном CPU/RAM добавление API-реплик перестаёт помогать (и снижает RPS), когда узкое место — CPU процессов API, а не PostgreSQL/HAProxy. +**Гипотеза трека 1.** Горизонтальное масштабирование (новые копии **как отдельные серверы**, каждая со своим CPU) **увеличивает** RPS, пока не упрётесь в БД/LB/пул или в число клиентов. Резать один суммарный CPU на больше контейнеров на *одном* хосте — не масштабирование: RPS падает. -**Методика.** Closed-loop POST `/messages` через HAProxy, concurrency 8, warmup 5 с, duration 20 с, клиент `urllib` (coordinated omission есть). Серия A: суммарно 1.0 CPU и 512 MiB на все API (1×1.0/512, 2×0.50/256, 4×0.25/128). Серия B: 2 реплики, рост бюджета (2×0.25, 2×0.50, 2×1.00). Повтор того же профиля. Сырьё: `evidence/track1.json`. +**Методика.** Прогон 2026-11-20, closed-loop POST `/messages` через HAProxy, concurrency 8, warmup 5 с, duration 20 с. Команда: `$env:TRACK1_DURATION=20; $env:TRACK1_WARMUP=5; python student-tests/track1.py`. Сырьё: `evidence/track1.json`. Графики пересобраны `python scripts/render_track1_svg.py`. -![RPS при фиксированном суммарном CPU](evidence/track1_fixed_budget.svg) +![RPS когда каждая реплика сохраняет 0.50 CPU](evidence/track1_scale_out.svg) + +![RPS при фиксированном суммарном 1 CPU (нарезка одного хоста)](evidence/track1_fixed_budget.svg) ![RPS при росте CPU двух реплик](evidence/track1_growing_cpu.svg) -| Серия | Реплики | CPU сумм. | RAM MiB | RPS | p50 мс | p95 мс | p99 мс | ошибки | -| --- | --- | --- | --- | --- | --- | --- | --- | --- | -| fixed-1 | 1 | 1.00 | 512 | **128.1** | 51.9 | 108.6 | 156.4 | 0 | -| fixed-2 | 2 | 1.00 | 512 | 107.5 | 71.6 | 189.1 | 245.5 | 0 | -| fixed-4 | 4 | 1.00 | 512 | 69.3 | 94.8 | 293.0 | 400.0 | 0 | -| grow-2×0.25 | 2 | 0.50 | 256 | 49.1 | 111.0 | 302.8 | 399.2 | 0 | -| grow-2×0.50 | 2 | 1.00 | 512 | 105.5 | 76.0 | 184.4 | 212.5 | 0 | -| grow-2×1.00 | 2 | 2.00 | 1024 | **221.0** | 29.3 | 83.0 | 105.9 | 0 | +| Серия | Реплики | CPU на одну | CPU сумм. | RPS | p50 мс | p95 мс | ошибки | +| --- | --- | --- | --- | --- | --- | --- | --- | +| **свой 1×0.50** | 1 | 0.50 | 0.50 | 31.5 | 191.6 | 404.5 | 0 | +| **свой 2×0.50** | 2 | 0.50 | 1.00 | 55.4 | 108.7 | 305.8 | 0 | +| **свой 4×0.50** | 4 | 0.50 | 2.00 | **80.7** | 78.1 | 209.9 | 0 | +| свой 1×1.00 | 1 | 1.00 | 1.00 | 69.5 | 89.3 | 190.3 | 0 | +| свой 2×1.00 | 2 | 1.00 | 2.00 | 96.4 | 56.0 | 185.9 | 0 | +| нарезка 1 | 1 | 1.00 | 1.00 | 67.6 | 92.2 | 195.6 | 0 | +| нарезка 2 | 2 | 0.50 | 1.00 | 51.3 | 110.2 | 299.4 | 0 | +| нарезка 4 | 4 | 0.25 | 1.00 | 37.1 | 114.7 | 532.5 | 0 | +| grow 2×0.25 | 2 | 0.25 | 0.50 | 26.1 | 277.9 | 600.6 | 0 | +| grow 2×0.50 | 2 | 0.50 | 1.00 | 56.2 | 106.0 | 295.3 | 0 | +| grow 2×1.00 | 2 | 1.00 | 2.00 | 119.0 | 50.3 | 126.5 | 0 | -`docker stats` на fixed-1: API ~14% от лимита 1 CPU, postgres ~0.06%, HAProxy ~0.09%. PostgreSQL и LB на этом профиле **не** насыщены. Saturation point — **нарезка CPU API**: при том же ватте 4 реплики медленнее одной. При росте CPU RPS почти линеен (49 → 105 → 221) — база ещё не упёрлась. Пул `10+10` на реплику при 4 репликах даёт до 80 соединений при `max_connections` Postgres по умолчанию 100: пул не был ограничителем (0 ошибок, postgres CPU ≈0%). +Добавление копий **со своим 0.50 CPU**: 31.5 → 55.4 → 80.7 RPS (×1.76, затем ×1.46). p50 падает 192 → 79 мс. Это и есть «больше серверов — быстрее». Рост не линейный ×4: у closed-loop всего 8 клиентов, четвёртая реплика уже не всегда занята; Postgres в кадре stats до ~8%, HAProxy <1% — **классического плато БД/LB нет**. + +Контраст README (тот же 1.0 CPU на всех): 67.6 → 51.3 → 37.1. Новым копиям ядро не дали — толку нет. + +Двум репликам добавили CPU: 26 → 56 → 119, почти линейно — запас по складу ещё был. Пул `10+10` на реплику при 4 копиях до 80 соединений, `max_connections` 100, ошибок 0. **Подтверждённое улучшение.** Только `127.0.0.1:8080` ломало `http://localhost:8080` на Windows (`::1`, ~2 с/запрос, 1.94 RPS, p50 2022 мс, concurrency 4, 30 с). Добавлен `[::1]:8080`. Повтор concurrency 8, 15 с: localhost **87.6 RPS** (p50 75 мс), 127.0.0.1 **94.7 RPS** (p50 80 мс), 0 ошибок. Это транспорт входа, не «ещё реплик»; без него closed-loop измерения трека 1 были бы искажены. @@ -133,7 +144,7 @@ mtusi-lab3-redis-1 Up (healthy) 127.0.0.1:6379->6379/tcp | `compose restart` postgres+redis+api+lb | hook ≤90 с | — | 0 после ready | токен тот же | volumes на месте | | отказ host / LB / Postgres / Redis | не заявлены | — | — | — | SPOF | -RPS отказа ниже трека 1: другой клиент (timeout 2–5 с, повторы того же ключа, пауза 0.1 с), не 8 потоков на 20 с. Сравнивать с 128 RPS нельзя. +RPS отказа ниже трека 1: другой клиент (timeout 2–5 с, повторы того же ключа, пауза 0.1 с), не 8 потоков на 20 с. Сравнивать с 80 RPS серии scale-out нельзя. ## Ограничения и следующие шаги @@ -141,4 +152,4 @@ RPS отказа ниже трека 1: другой клиент (timeout 2–5 Учебные упрощения: HTTP без TLS; Basic только на логин; идемпотентность только у POST сообщения; публичный live отвечает LB. `tests/load.py` — closed-loop. -Подтверждено: лишние реплики при фиксированном CPU вредят; IPv6 loopback нужен для честного `localhost`. Гипотеза на будущее: тяжёлый профиль упрётся в `max_connections`/WAL — здесь не достигнуто. +Подтверждено (прогон 2026-11-20): копии **со своим CPU** ускоряют (31.5→80.7 при 1/2/4 × 0.50); нарезка одного CPU — нет (67.6→37.1). IPv6 loopback нужен для честного `localhost`. Плато Postgres/HAProxy при concurrency 8 не достигнуто; дальше упрётся либо клиент closed-loop, либо `max_connections`/WAL. diff --git a/evidence/explain_messages.txt b/evidence/explain_messages.txt new file mode 100644 index 00000000..fe23e897 --- /dev/null +++ b/evidence/explain_messages.txt @@ -0,0 +1,23 @@ +messages=10000 + +-- first page +Limit (cost=0.41..13.09 rows=50 width=35) (actual time=0.029..0.055 rows=50 loops=1) + Buffers: shared hit=5 + -> Index Scan using ix_messages_history on messages (cost=0.41..2506.71 rows=9889 width=35) (actual time=0.028..0.049 rows=50 loops=1) + Index Cond: (chat_id = 'f075dcf3-bb90-47bb-be38-504b3d26db6a'::uuid) + Buffers: shared hit=5 +Planning: + Buffers: shared hit=104 +Planning Time: 0.340 ms +Execution Time: 0.079 ms + +-- page after row 5000 +Limit (cost=0.41..15.86 rows=50 width=35) (actual time=0.031..0.046 rows=50 loops=1) + Buffers: shared hit=4 + -> Index Scan using ix_messages_history on messages (cost=0.41..2383.08 rows=7713 width=35) (actual time=0.029..0.039 rows=50 loops=1) + Index Cond: ((chat_id = 'f075dcf3-bb90-47bb-be38-504b3d26db6a'::uuid) AND (ROW(created_at, id) > ROW('2026-01-01 00:00:00.005001+00'::timestamp with time zone, '7e995dee-8c7d-4c9b-a7f7-573c0b88b68b'::uuid))) + Buffers: shared hit=4 +Planning: + Buffers: shared hit=103 +Planning Time: 0.335 ms +Execution Time: 0.085 ms diff --git a/evidence/level3.json b/evidence/level3.json index 0afeded1..ee0f1042 100644 --- a/evidence/level3.json +++ b/evidence/level3.json @@ -1,23 +1,23 @@ { - "date": "2026-10-30T16:04:19Z", + "date": "2026-11-13T09:51:50Z", "base_url": "http://127.0.0.1:8080", "instances": { "unique_instance_ids": [ - "46e274e33049", - "f383126bd2be" + "4f9fc3be2925", + "87a318266c19" ], "samples": 40, "counts": { - "46e274e33049": 20, - "f383126bd2be": 20 + "4f9fc3be2925": 20, + "87a318266c19": 20 } }, "idempotent_message_id_present": true, "concurrent_key": { - "message_id": "1e79d3a4-62ee-405a-917e-5d26042f46a2", + "message_id": "1d400e43-801b-47a4-95f2-93d5eaf5f04f", "instances": [ - "46e274e33049", - "f383126bd2be" + "4f9fc3be2925", + "87a318266c19" ], "successes": 12 } diff --git a/evidence/level4.json b/evidence/level4.json new file mode 100644 index 00000000..b721f283 --- /dev/null +++ b/evidence/level4.json @@ -0,0 +1,40 @@ +{ + "date": "2026-11-13T10:47:37Z", + "base_url": "http://127.0.0.1:8080", + "race": { + "created": 1, + "conflict": 15 + }, + "rollback": { + "chats_before": 34, + "chats_after": 34, + "title_rows": 0 + }, + "explain": { + "messages": 10000 + }, + "expiry_and_migrations": { + "users_before": 108, + "users_after": 109, + "migration": "001_initial.sql\n002_idempotency.sql" + }, + "redis_restart": { + "pttl_before_ms": 3582575, + "pttl_after_ms": 3581127 + }, + "dependency_loss": { + "redis_down": { + "live": 200, + "ready": 503, + "anonymous": 401, + "bearer": 503 + }, + "postgres_down": { + "live": 200, + "ready": 503, + "anonymous": 401, + "bearer": 503 + } + }, + "messages_after_postgres_restart": 10000 +} diff --git a/evidence/rolling.json b/evidence/rolling.json index ba7939c3..b0922c6d 100644 --- a/evidence/rolling.json +++ b/evidence/rolling.json @@ -1,18 +1,18 @@ { - "date": "2026-10-30T16:14:24Z", + "date": "2026-11-13T09:54:05Z", "replaced": [ - "9fe46a8ef3ce", - "4d6d0836aa27" + "4f9fc3be2925", + "87a318266c19" ], "replicas_before": [ - "9fe46a8ef3ce", - "4d6d0836aa27" + "4f9fc3be2925", + "87a318266c19" ], "replicas_after": [ - "eb055e557646", - "5ea08fe69111" + "2644ce84e5ea", + "4a0edb995144" ], - "successful_writes": 1980, - "failed_writes": 24, - "error_ratio": 0.011976 + "successful_writes": 1212, + "failed_writes": 26, + "error_ratio": 0.021002 } diff --git a/evidence/track1.json b/evidence/track1.json index 94be0b53..64818673 100644 --- a/evidence/track1.json +++ b/evidence/track1.json @@ -1,45 +1,277 @@ { - "date": "2026-10-30T16:17:53Z", - "hypothesis": "При фиксированном суммарном CPU/RAM добавление API-реплик перестаёт помогать (и может снизить RPS), когда узкое место — CPU процессов API: PostgreSQL на этом профиле не насыщается.", + "date": "2026-11-20T16:28:47Z", + "hypothesis": "Горизонтальное масштабирование ускоряет POST, когда каждая новая реплика приносит СВОЙ CPU (как ещё один сервер). Нарезка одного и того же суммарного CPU на больше копий на одном хосте не масштабирование: RPS не растёт. Потолок тогда ищется у БД/LB/пула на серии с ростом суммарного бюджета.", "profile": { "duration_seconds": 20.0, "concurrency": 8, "warmup_seconds": 5.0, "workload": "closed-loop POST /messages through HAProxy" }, - "fixed_total_budget": [ + "scale_out_own_cpu": [ { - "elapsed_seconds": 20.907, + "elapsed_seconds": 21.282, "concurrency": 8, - "successful_requests": 2678, + "successful_requests": 670, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 128.093, + "successful_rps": 31.482, "successful_latency_ms": { - "p50": 51.921, - "p95": 108.599, - "p99": 156.367 + "p50": 191.581, + "p95": 404.512, + "p99": 1111.992 }, "docker_stats": [ { - "name": "mtusi-lab3-api-4", - "cpu": "13.84%", - "mem": "89.5MiB / 512MiB" + "name": "mtusi-lab3-api-5", + "cpu": "0.63%", + "mem": "73.35MiB / 256MiB" }, { "name": "mtusi-lab3-lb-1", - "cpu": "0.09%", - "mem": "28.19MiB / 64MiB" + "cpu": "0.20%", + "mem": "38.12MiB / 64MiB" }, { "name": "mtusi-lab3-postgres-1", - "cpu": "0.06%", - "mem": "52.93MiB / 512MiB" + "cpu": "8.83%", + "mem": "71.43MiB / 512MiB" }, { "name": "mtusi-lab3-redis-1", - "cpu": "2.34%", - "mem": "9.738MiB / 128MiB" + "cpu": "4.57%", + "mem": "11.64MiB / 128MiB" + } + ], + "label": "scale-1x0.50", + "replicas": 1, + "cpus_each": 0.5, + "memory_mb_each": 256, + "total_cpu": 0.5, + "total_memory_mb": 256 + }, + { + "elapsed_seconds": 20.999, + "concurrency": 8, + "successful_requests": 1164, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 55.431, + "successful_latency_ms": { + "p50": 108.652, + "p95": 305.824, + "p99": 397.395 + }, + "docker_stats": [ + { + "name": "mtusi-lab3-api-6", + "cpu": "45.65%", + "mem": "82.82MiB / 256MiB" + }, + { + "name": "mtusi-lab3-api-5", + "cpu": "40.86%", + "mem": "87.78MiB / 256MiB" + }, + { + "name": "mtusi-lab3-lb-1", + "cpu": "0.22%", + "mem": "38.38MiB / 64MiB" + }, + { + "name": "mtusi-lab3-postgres-1", + "cpu": "0.09%", + "mem": "90.45MiB / 512MiB" + }, + { + "name": "mtusi-lab3-redis-1", + "cpu": "0.56%", + "mem": "11.62MiB / 128MiB" + } + ], + "label": "scale-2x0.50", + "replicas": 2, + "cpus_each": 0.5, + "memory_mb_each": 256, + "total_cpu": 1.0, + "total_memory_mb": 512 + }, + { + "elapsed_seconds": 21.016, + "concurrency": 8, + "successful_requests": 1697, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 80.747, + "successful_latency_ms": { + "p50": 78.142, + "p95": 209.908, + "p99": 302.912 + }, + "docker_stats": [ + { + "name": "mtusi-lab3-api-7", + "cpu": "42.36%", + "mem": "70.76MiB / 256MiB" + }, + { + "name": "mtusi-lab3-api-8", + "cpu": "35.28%", + "mem": "79.51MiB / 256MiB" + }, + { + "name": "mtusi-lab3-api-6", + "cpu": "37.01%", + "mem": "70.36MiB / 256MiB" + }, + { + "name": "mtusi-lab3-api-5", + "cpu": "36.66%", + "mem": "77.76MiB / 256MiB" + }, + { + "name": "mtusi-lab3-lb-1", + "cpu": "0.63%", + "mem": "38.64MiB / 64MiB" + }, + { + "name": "mtusi-lab3-postgres-1", + "cpu": "7.77%", + "mem": "122.5MiB / 512MiB" + }, + { + "name": "mtusi-lab3-redis-1", + "cpu": "0.58%", + "mem": "11.76MiB / 128MiB" + } + ], + "label": "scale-4x0.50", + "replicas": 4, + "cpus_each": 0.5, + "memory_mb_each": 256, + "total_cpu": 2.0, + "total_memory_mb": 1024 + }, + { + "elapsed_seconds": 21.856, + "concurrency": 8, + "successful_requests": 1518, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 69.454, + "successful_latency_ms": { + "p50": 89.322, + "p95": 190.273, + "p99": 205.464 + }, + "docker_stats": [ + { + "name": "mtusi-lab3-api-5", + "cpu": "52.06%", + "mem": "87.58MiB / 512MiB" + }, + { + "name": "mtusi-lab3-lb-1", + "cpu": "11.02%", + "mem": "39.48MiB / 64MiB" + }, + { + "name": "mtusi-lab3-postgres-1", + "cpu": "0.07%", + "mem": "76.89MiB / 512MiB" + }, + { + "name": "mtusi-lab3-redis-1", + "cpu": "0.69%", + "mem": "11.71MiB / 128MiB" + } + ], + "label": "scale-1x1.00", + "replicas": 1, + "cpus_each": 1.0, + "memory_mb_each": 512, + "total_cpu": 1.0, + "total_memory_mb": 512 + }, + { + "elapsed_seconds": 21.894, + "concurrency": 8, + "successful_requests": 2110, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 96.372, + "successful_latency_ms": { + "p50": 55.975, + "p95": 185.862, + "p99": 217.461 + }, + "docker_stats": [ + { + "name": "mtusi-lab3-api-6", + "cpu": "34.19%", + "mem": "84.52MiB / 512MiB" + }, + { + "name": "mtusi-lab3-api-5", + "cpu": "0.75%", + "mem": "92.05MiB / 512MiB" + }, + { + "name": "mtusi-lab3-lb-1", + "cpu": "0.17%", + "mem": "39.99MiB / 64MiB" + }, + { + "name": "mtusi-lab3-postgres-1", + "cpu": "7.84%", + "mem": "97.84MiB / 512MiB" + }, + { + "name": "mtusi-lab3-redis-1", + "cpu": "0.59%", + "mem": "12.3MiB / 128MiB" + } + ], + "label": "scale-2x1.00", + "replicas": 2, + "cpus_each": 1.0, + "memory_mb_each": 512, + "total_cpu": 2.0, + "total_memory_mb": 1024 + } + ], + "fixed_total_budget": [ + { + "elapsed_seconds": 22.063, + "concurrency": 8, + "successful_requests": 1491, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 67.58, + "successful_latency_ms": { + "p50": 92.179, + "p95": 195.608, + "p99": 216.499 + }, + "docker_stats": [ + { + "name": "mtusi-lab3-api-5", + "cpu": "1.16%", + "mem": "93.65MiB / 512MiB" + }, + { + "name": "mtusi-lab3-lb-1", + "cpu": "0.14%", + "mem": "40.46MiB / 64MiB" + }, + { + "name": "mtusi-lab3-postgres-1", + "cpu": "0.38%", + "mem": "81.44MiB / 512MiB" + }, + { + "name": "mtusi-lab3-redis-1", + "cpu": "5.34%", + "mem": "12.53MiB / 128MiB" } ], "label": "fixed-1", @@ -50,42 +282,42 @@ "total_memory_mb": 512 }, { - "elapsed_seconds": 20.894, + "elapsed_seconds": 21.108, "concurrency": 8, - "successful_requests": 2246, + "successful_requests": 1083, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 107.496, + "successful_rps": 51.308, "successful_latency_ms": { - "p50": 71.633, - "p95": 189.116, - "p99": 245.528 + "p50": 110.223, + "p95": 299.364, + "p99": 463.741 }, "docker_stats": [ { - "name": "mtusi-lab3-api-5", - "cpu": "24.21%", - "mem": "72.12MiB / 256MiB" + "name": "mtusi-lab3-api-6", + "cpu": "30.22%", + "mem": "81.15MiB / 256MiB" }, { - "name": "mtusi-lab3-api-4", - "cpu": "0.71%", - "mem": "91.05MiB / 256MiB" + "name": "mtusi-lab3-api-5", + "cpu": "0.69%", + "mem": "95.84MiB / 256MiB" }, { "name": "mtusi-lab3-lb-1", - "cpu": "0.31%", - "mem": "28.9MiB / 64MiB" + "cpu": "0.21%", + "mem": "40.92MiB / 64MiB" }, { "name": "mtusi-lab3-postgres-1", - "cpu": "4.47%", - "mem": "73.19MiB / 512MiB" + "cpu": "8.16%", + "mem": "103.1MiB / 512MiB" }, { "name": "mtusi-lab3-redis-1", - "cpu": "0.33%", - "mem": "9.035MiB / 128MiB" + "cpu": "4.19%", + "mem": "12.3MiB / 128MiB" } ], "label": "fixed-2", @@ -96,52 +328,52 @@ "total_memory_mb": 512 }, { - "elapsed_seconds": 21.006, + "elapsed_seconds": 21.199, "concurrency": 8, - "successful_requests": 1456, + "successful_requests": 786, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 69.315, + "successful_rps": 37.077, "successful_latency_ms": { - "p50": 94.785, - "p95": 292.96, - "p99": 400.018 + "p50": 114.739, + "p95": 532.515, + "p99": 1304.135 }, "docker_stats": [ + { + "name": "mtusi-lab3-api-8", + "cpu": "23.90%", + "mem": "79.59MiB / 128MiB" + }, { "name": "mtusi-lab3-api-7", - "cpu": "16.08%", - "mem": "79.37MiB / 128MiB" + "cpu": "27.10%", + "mem": "77.96MiB / 128MiB" }, { "name": "mtusi-lab3-api-6", - "cpu": "11.19%", - "mem": "76.64MiB / 128MiB" + "cpu": "9.06%", + "mem": "69.91MiB / 128MiB" }, { "name": "mtusi-lab3-api-5", - "cpu": "8.82%", - "mem": "83.37MiB / 128MiB" - }, - { - "name": "mtusi-lab3-api-4", - "cpu": "5.77%", - "mem": "98.27MiB / 128MiB" + "cpu": "11.39%", + "mem": "88.77MiB / 128MiB" }, { "name": "mtusi-lab3-lb-1", - "cpu": "0.48%", - "mem": "29.2MiB / 64MiB" + "cpu": "0.39%", + "mem": "41MiB / 64MiB" }, { "name": "mtusi-lab3-postgres-1", - "cpu": "0.05%", - "mem": "94.67MiB / 512MiB" + "cpu": "13.26%", + "mem": "137.6MiB / 512MiB" }, { "name": "mtusi-lab3-redis-1", - "cpu": "2.17%", - "mem": "8.914MiB / 128MiB" + "cpu": "0.62%", + "mem": "12.09MiB / 128MiB" } ], "label": "fixed-4", @@ -154,42 +386,42 @@ ], "growing_resources": [ { - "elapsed_seconds": 21.009, + "elapsed_seconds": 21.075, "concurrency": 8, - "successful_requests": 1031, + "successful_requests": 550, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 49.073, + "successful_rps": 26.097, "successful_latency_ms": { - "p50": 111.033, - "p95": 302.796, - "p99": 399.196 + "p50": 277.91, + "p95": 600.586, + "p99": 801.976 }, "docker_stats": [ { - "name": "mtusi-lab3-api-5", - "cpu": "4.23%", - "mem": "76.67MiB / 128MiB" + "name": "mtusi-lab3-api-6", + "cpu": "15.72%", + "mem": "79.91MiB / 128MiB" }, { - "name": "mtusi-lab3-api-4", - "cpu": "0.43%", - "mem": "89.02MiB / 128MiB" + "name": "mtusi-lab3-api-5", + "cpu": "10.74%", + "mem": "93.98MiB / 128MiB" }, { "name": "mtusi-lab3-lb-1", - "cpu": "0.13%", - "mem": "29.92MiB / 64MiB" + "cpu": "0.19%", + "mem": "41.1MiB / 64MiB" }, { "name": "mtusi-lab3-postgres-1", - "cpu": "4.40%", - "mem": "76.54MiB / 512MiB" + "cpu": "8.09%", + "mem": "107.4MiB / 512MiB" }, { "name": "mtusi-lab3-redis-1", - "cpu": "2.30%", - "mem": "9.145MiB / 128MiB" + "cpu": "0.56%", + "mem": "12.26MiB / 128MiB" } ], "label": "grow-2x0.25", @@ -200,42 +432,42 @@ "total_memory_mb": 256 }, { - "elapsed_seconds": 20.917, + "elapsed_seconds": 21.026, "concurrency": 8, - "successful_requests": 2206, + "successful_requests": 1181, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 105.463, + "successful_rps": 56.169, "successful_latency_ms": { - "p50": 75.963, - "p95": 184.365, - "p99": 212.521 + "p50": 106.044, + "p95": 295.28, + "p99": 314.704 }, "docker_stats": [ { - "name": "mtusi-lab3-api-5", - "cpu": "0.58%", - "mem": "83.3MiB / 256MiB" + "name": "mtusi-lab3-api-6", + "cpu": "15.99%", + "mem": "81.01MiB / 256MiB" }, { - "name": "mtusi-lab3-api-4", - "cpu": "18.11%", - "mem": "89.97MiB / 256MiB" + "name": "mtusi-lab3-api-5", + "cpu": "4.97%", + "mem": "85.26MiB / 256MiB" }, { "name": "mtusi-lab3-lb-1", - "cpu": "4.50%", - "mem": "30.62MiB / 64MiB" + "cpu": "0.76%", + "mem": "41.43MiB / 64MiB" }, { "name": "mtusi-lab3-postgres-1", - "cpu": "0.08%", - "mem": "78.58MiB / 512MiB" + "cpu": "9.65%", + "mem": "108.1MiB / 512MiB" }, { "name": "mtusi-lab3-redis-1", - "cpu": "0.36%", - "mem": "9.082MiB / 128MiB" + "cpu": "0.59%", + "mem": "12.21MiB / 128MiB" } ], "label": "grow-2x0.50", @@ -246,42 +478,42 @@ "total_memory_mb": 512 }, { - "elapsed_seconds": 20.827, + "elapsed_seconds": 20.989, "concurrency": 8, - "successful_requests": 4602, + "successful_requests": 2498, "failed_requests": 0, "error_ratio": 0.0, - "successful_rps": 220.96, + "successful_rps": 119.016, "successful_latency_ms": { - "p50": 29.331, - "p95": 82.961, - "p99": 105.895 + "p50": 50.289, + "p95": 126.45, + "p99": 179.556 }, "docker_stats": [ { - "name": "mtusi-lab3-api-5", - "cpu": "1.21%", - "mem": "87.79MiB / 512MiB" + "name": "mtusi-lab3-api-6", + "cpu": "41.05%", + "mem": "93MiB / 512MiB" }, { - "name": "mtusi-lab3-api-4", - "cpu": "27.65%", - "mem": "90.96MiB / 512MiB" + "name": "mtusi-lab3-api-5", + "cpu": "1.07%", + "mem": "88.75MiB / 512MiB" }, { "name": "mtusi-lab3-lb-1", - "cpu": "5.02%", - "mem": "31.52MiB / 64MiB" + "cpu": "0.24%", + "mem": "42.16MiB / 64MiB" }, { "name": "mtusi-lab3-postgres-1", - "cpu": "0.18%", - "mem": "82.41MiB / 512MiB" + "cpu": "0.03%", + "mem": "110.3MiB / 512MiB" }, { "name": "mtusi-lab3-redis-1", - "cpu": "0.35%", - "mem": "8.906MiB / 128MiB" + "cpu": "5.42%", + "mem": "12.75MiB / 128MiB" } ], "label": "grow-2x1.00", diff --git a/evidence/track1_fixed_budget.svg b/evidence/track1_fixed_budget.svg index e534d8df..f79100ea 100644 --- a/evidence/track1_fixed_budget.svg +++ b/evidence/track1_fixed_budget.svg @@ -1,12 +1,27 @@ -Fixed total 1.0 CPU and 512 MiB for all API replicas -14711074370 +Fixed total 1.0 CPU split across replicas + +0 + +19 + +39 + +58 + +78 - -128.1107.569.3 -1 replica2 replicas4 replicas -API replicas (same total CPU/RAM) -successful RPS + +67.6 +1 + +51.3 +2 + +37.1 +4 +Replica count at the same total CPU +successful RPS diff --git a/evidence/track1_growing_cpu.svg b/evidence/track1_growing_cpu.svg index 999106d1..bcac664c 100644 --- a/evidence/track1_growing_cpu.svg +++ b/evidence/track1_growing_cpu.svg @@ -1,12 +1,27 @@ Two API replicas, growing CPU/RAM budget -254191127640 + +0 + +34 + +68 + +103 + +137 - -49.1105.5221.0 -0.50 CPU1.00 CPU2.00 CPU + +26.1 +0,50 CPU + +56.2 +1,00 CPU + +119.0 +2,00 CPU Total CPU for two replicas -successful RPS +successful RPS diff --git a/evidence/track1_scale_out.svg b/evidence/track1_scale_out.svg new file mode 100644 index 00000000..7890333d --- /dev/null +++ b/evidence/track1_scale_out.svg @@ -0,0 +1,27 @@ + + +Each replica keeps 0.50 CPU (like another server) + +0 + +23 + +46 + +70 + +93 + + + +31.5 +1 + +55.4 +2 + +80.7 +4 +Replicas; total CPU grows 0.5 → 1.0 → 2.0 +successful RPS + diff --git a/infra/__init__.py b/infra/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/infra/haproxy.cfg b/infra/haproxy.cfg index 50a953b2..f03a9526 100644 --- a/infra/haproxy.cfg +++ b/infra/haproxy.cfg @@ -37,7 +37,7 @@ frontend public backend api balance roundrobin option httpchk - http-check send meth GET uri /health/ready ver HTTP/1.1 hdr Host api + http-check send meth GET uri /health/live ver HTTP/1.1 hdr Host api http-check expect status 200 default-server inter 1s fall 2 rise 1 resolvers docker resolve-prefer ipv4 init-addr none server-template api 4 api:8080 check diff --git a/scripts/build_defense_pdf.py b/scripts/build_defense_pdf.py new file mode 100644 index 00000000..7a737d41 --- /dev/null +++ b/scripts/build_defense_pdf.py @@ -0,0 +1,747 @@ +# -*- coding: utf-8 -*- +"""Собрать шпаргалку к защите lab3 (кириллица, Windows Arial).""" +from pathlib import Path + +from fpdf import FPDF + +ROOT = Path(__file__).resolve().parents[1] +OUT = ROOT / "DEFENSE.pdf" +FONT = Path(r"C:\Windows\Fonts\arial.ttf") +FONT_B = Path(r"C:\Windows\Fonts\arialbd.ttf") +FONT_I = Path(r"C:\Windows\Fonts\ariali.ttf") +FONT_C = Path(r"C:\Windows\Fonts\consola.ttf") +if not FONT_C.exists(): + FONT_C = Path(r"C:\Windows\Fonts\cour.ttf") + + +class Pdf(FPDF): + def header(self): + if self.page_no() == 1: + return + self.set_font("Body", "", 8) + self.set_text_color(90, 90, 90) + self.set_x(self.l_margin) + self.cell(0, 6, "Lab3 zashchita | Shcherbatsevich | BPI2302 | 5 track 1", align="L") + self.ln(8) + self.set_text_color(0, 0, 0) + self.set_x(self.l_margin) + + def footer(self): + self.set_y(-12) + self.set_font("Body", "", 8) + self.set_text_color(90, 90, 90) + self.set_x(self.l_margin) + self.cell(0, 8, str(self.page_no()), align="C") + self.set_text_color(0, 0, 0) + + +def _w(pdf): + pdf.set_x(pdf.l_margin) + return pdf.epw + + +def h1(pdf, text): + pdf.ln(4) + pdf.set_font("Body", "B", 16) + pdf.multi_cell(_w(pdf), 8, text) + pdf.ln(1) + + +def h2(pdf, text): + pdf.ln(3) + pdf.set_font("Body", "B", 13) + pdf.multi_cell(_w(pdf), 7, text) + pdf.ln(1) + + +def h3(pdf, text): + pdf.ln(2) + pdf.set_font("Body", "B", 11) + pdf.multi_cell(_w(pdf), 6, text) + + +def body(pdf, text): + pdf.set_font("Body", "", 10) + pdf.multi_cell(_w(pdf), 5.2, text) + pdf.ln(0.8) + + +def speak(pdf, text): + pdf.set_fill_color(235, 243, 255) + pdf.set_font("Body", "I", 10) + pdf.multi_cell(_w(pdf), 5.2, "ГОВОРИТЬ: " + text, fill=True) + pdf.ln(1.5) + + +def warn(pdf, text): + pdf.set_fill_color(255, 243, 220) + pdf.set_font("Body", "B", 10) + pdf.multi_cell(_w(pdf), 5.2, "НЕ ВРАТЬ: " + text, fill=True) + pdf.ln(1.5) + + +def show(pdf, text): + pdf.set_fill_color(232, 245, 233) + pdf.set_font("Body", "B", 10) + pdf.multi_cell(_w(pdf), 5.2, "ПОКАЗАТЬ: " + text, fill=True) + pdf.ln(1.5) + + +def code(pdf, text): + pdf.set_font("Code", "", 7.5) + pdf.set_fill_color(245, 245, 245) + pdf.multi_cell(_w(pdf), 4.0, text.rstrip() + "\n", fill=True) + pdf.ln(1.2) + + +def bullet(pdf, text): + pdf.set_font("Body", "", 10) + pdf.multi_cell(_w(pdf), 5.2, "- " + text) + pdf.ln(0.3) + + +def qa(pdf, q, a): + pdf.set_font("Body", "B", 10) + pdf.multi_cell(_w(pdf), 5.2, "В: " + q) + pdf.set_font("Body", "", 10) + pdf.multi_cell(_w(pdf), 5.2, "О: " + a) + pdf.ln(1.5) + + +def build(): + pdf = Pdf(format="A4", unit="mm") + pdf.set_auto_page_break(auto=True, margin=16) + pdf.add_font("Body", "", str(FONT)) + pdf.add_font("Body", "B", str(FONT_B)) + pdf.add_font("Body", "I", str(FONT_I)) + pdf.add_font("Code", "", str(FONT_C)) + pdf.add_page() + pdf.set_font("Body", "B", 22) + pdf.multi_cell(_w(pdf), 10, "Методичка к защите") + pdf.set_font("Body", "B", 16) + pdf.multi_cell(_w(pdf), 8, "Лабораторная 3 — балансировка и отказ API-реплики") + pdf.ln(2) + pdf.set_font("Body", "", 11) + for line in [ + "Автор: Щербацевич Владислав Сергеевич", + "Группа: БПИ2302", + "Целевая оценка: 5", + "Трек: 1 — цена масштабирования (Compose + HAProxy, не Swarm, не трек 2)", + "Вход: http://127.0.0.1:8080 и http://localhost:8080 (оба должны отвечать)", + "Этот файл — шпаргалка. Не читать с листа целиком: открывать нужный раздел.", + ]: + pdf.multi_cell(_w(pdf), 6, line) + pdf.ln(3) + body( + pdf, + "Как пользоваться на защите. Сначала 90 секунд «что это за система». Потом живой стенд: " + "два X-Instance-Id, docker ps, stop-one. Код показывают только когда спрашивают «где». " + "Цифры трека 1 — из REPORT.md и evidence/, не из головы. Если не помните число — откройте JSON.", + ) + + h1(pdf, "0. Карта выступления (10–15 минут)") + bullet(pdf, "1 мин — задача лабы и схема Клиент → HAProxy → api×2 → Postgres + Redis.") + bullet(pdf, "1 мин — живой стенд: curl/браузер, два разных X-Instance-Id, одна сессия.") + bullet(pdf, "2 мин — docker compose ps: API без host-порта, имена api-N, лимиты.") + bullet(pdf, "2 мин — идемпотентность: ключ в заголовке, таблица в Postgres, гонка 12 потоков.") + bullet(pdf, "2 мин — отказ: stop-one, recovery ~2.5 с, вторая реплика.") + bullet(pdf, "2 мин — уровень 4: ready 1 с fall 2, SIGTERM, rolling, migrate one-shot.") + bullet(pdf, "3 мин — трек 1: гипотеза, 128/107/69 и 49/105/221, честно про saturation, IPv6.") + bullet(pdf, "Оставшееся — вопросы.") + + h1(pdf, "1. Что говорить в первые 90 секунд") + speak( + pdf, + "Это мессенджер с lab2: пользователи, чаты, сообщения, сессии. В lab3 я не размножаю данные, " + "а размножаю процессы API. Снаружи одна дверь — HAProxy на порту 8080. За ней минимум два " + "одинаковых контейнера api. Сообщения пишет PostgreSQL, сессии лежат в Redis, не в памяти " + "процесса. Поэтому можно убить один api — логин не слетает, дублей сообщения нет, если клиент " + "повторил тот же Idempotency-Key. Sticky-сессий нет: один пользователь разными запросами " + "попадает на разные реплики — это видно по заголовку X-Instance-Id. Для пятёрки выбран трек 1: " + "не «ещё узлов», а цена лишних реплик при фиксированном CPU.", + ) + warn( + pdf, + "Не говорить «у нас высокая доступность системы». Выдерживается отказ ОДНОГО процесса API. " + "Хост, HAProxy, Postgres, Redis — точки отказа. Трек 2 не делался.", + ) + + h1(pdf, "2. Схема и роли файлов") + body( + pdf, + "Клиент (браузер, smoke, level3) бьёт в localhost:8080. Контейнер lb — HAProxy. Он round-robin " + "раздаёт на контейнеры сервиса api. Имя api в Docker DNS имеет несколько IP. Postgres — источник " + "истины (users, chats, messages, idempotency_records, schema_migrations). Redis — сессии, AOF " + "appendfsync always. Контейнер migrate один раз накатывает SQL и выходит. API сами DDL не гоняют.", + ) + h3(pdf, "Куда ткнуть курсор, если просят «покажи файл»") + bullet(pdf, "compose.yaml — весь стенд: сервисы, реплики, лимиты, секреты, нет ports у api, нет container_name.") + bullet(pdf, "infra/haproxy.cfg — roundrobin, httpchk /health/ready, inter 1s fall 2, live отвечает сам LB.") + bullet(pdf, "src/app/middleware.py — X-Request-Id и X-Instance-Id, 503 при shutdown.") + bullet(pdf, "src/app/config.py — instance_id из HOSTNAME.") + bullet(pdf, "src/app/api/health.py — live vs ready.") + bullet(pdf, "src/app/main.py — accepting, lifespan SIGTERM.") + bullet(pdf, "src/app/__main__.py — uvicorn timeout_graceful_shutdown=5.") + bullet(pdf, "src/app/sessions.py — Redis PXAT, не память процесса.") + bullet(pdf, "src/app/api/messages.py и src/app/crud/messages.py — Idempotency-Key.") + bullet(pdf, "migrations/002_idempotency.sql — таблица ключей.") + bullet(pdf, "src/app/migrate.py и сервис migrate в compose — one-shot.") + bullet(pdf, "scripts/stop-one.sh (.cmd) — стоп по X-Instance-Id.") + bullet(pdf, "scripts/rolling-update.sh — новый контейнер до удаления старого.") + bullet(pdf, "student-tests/level3.py — две реплики + гонка ключа.") + bullet(pdf, "student-tests/track1.py и evidence/track1.json — пятёрка.") + bullet(pdf, "REPORT.md — цифры, которые можно зачитать.") + + h1(pdf, "3. Команды: стенд, тесты, доказательства") + body( + pdf, + "Защита на Windows. В PowerShell из корня репозитория. PYTHONUTF8=1 — чтобы make/python не падали на кириллице. " + "Секреты не печатать в чат и не открывать на проекторе содержимое secrets/.", + ) + h3(pdf, "3.1. Поднять с нуля (если стенд ещё нет)") + code( + pdf, + "cd C:\\Users\\Admin\\PycharmProjects\\mtusi2026lab3\n" + "powershell -ExecutionPolicy Bypass -File scripts\\bootstrap.ps1\n" + "docker compose --env-file .env config --quiet\n" + "docker compose --env-file .env up -d --build --wait --scale api=2", + ) + body( + pdf, + "bootstrap создаёт .env и файлы секретов, не коммитятся. config --quiet проверяет compose. " + "--wait ждёт healthcheck. scale api=2 обязательно: дефолт тоже 2, но на защите произнесите число.", + ) + h3(pdf, "3.2. Живой пульс") + code( + pdf, + "curl.exe -i http://127.0.0.1:8080/health/live\n" + "curl.exe -i http://127.0.0.1:8080/health/ready\n" + "docker compose --env-file .env ps", + ) + body( + pdf, + "live с улицы отдаёт HAProxy: X-Instance-Id: load-balancer — это касса, не реплика. " + "ready идёт на API. В ps у api колонка PORTS должна быть 8080/tcp БЕЗ 0.0.0.0:xxxx — порты на хост не проброшены. " + "Доказательство уже снято: evidence/compose-ps.txt.", + ) + warn(pdf, "Не доказывать разные реплики через /health/live. Только /api/v1/users/me или POST сообщения.") + + h3(pdf, "3.3. Два instance id одной сессией (сценарий README пункт 1)") + body(pdf, "Проще всего готовый тест — он логинится сам и 40 раз бьёт /users/me:") + code(pdf, "$env:PYTHONUTF8='1'\npython student-tests/level3.py") + body( + pdf, + "PASS и evidence/level3.json: unique_instance_ids длина ≥2. Если хотят руками: зарегистрировать пользователя " + "(examples/requests.http), взять Bearer, повторять GET /api/v1/users/me — заголовок X-Instance-Id должен чередоваться.", + ) + h3(pdf, "3.4. Публичные проверки курса") + code( + pdf, + "python tests/smoke.py --base-url http://127.0.0.1:8080\n" + "python student-tests/persistence_hook.py\n" + "python student-tests/failover.py\n" + "scripts\\restore-api.cmd\n" + "python student-tests/failover.py\n" + "python student-tests/rolling.py", + ) + body( + pdf, + "smoke — контракт lab3 (ключ, replay, 409). persistence — restart стенда, тот же токен, volumes на месте " + "(scripts/restart.cmd внутри хука). failover — stop-one.cmd по TARGET_INSTANCE_ID. " + "После первого failover реплик станет 1 — restore-api.cmd возвращает scale 2, второй прогон бьёт уже другую. " + "На POSIX в README: make test-failover ACTION_SCRIPT=scripts/stop-one.sh. У вас Windows, поэтому .cmd.", + ) + show(pdf, "Готовые логи: evidence/smoke.txt, persistence.txt, failover.txt, sequential_failover.json, rolling.json, level3.json.") + + h3(pdf, "3.5. Трек 1 (долго, на защите обычно НЕ гонять заново)") + code( + pdf, + "python student-tests/track1.py\n" + "python tests/load.py --duration 20 --concurrency 8 --output evidence/load_ipv4.json", + ) + body(pdf, "Открыть evidence/track1.json и SVG. Повтор прогона — много минут и сменит цифры; для защиты достаточно снятого замера 2026-10-30.") + + h3(pdf, "3.6. Остановить / поднять") + code( + pdf, + "docker compose --env-file .env down # данные в volumes остаются\n" + "docker compose --env-file .env down -v # учебное обнуление БД — на защите не делать", + ) + + h1(pdf, "4. Оценка 3 — что говорить и какой код") + + h2(pdf, "4.1. Стенд в одном compose, две реплики, одна дверь") + speak( + pdf, + "Весь стенд в compose.yaml, не Swarm. Имя проекта mtusi-lab3. Сервисы: postgres, redis, migrate, api, lb. " + "Реплик api две. С хоста торчит только lb 127.0.0.1:8080 и [::1]:8080. База и redis на loopback для отладки, " + "это не API. Образы с digest, не latest.", + ) + show(pdf, "compose.yaml — services api и lb; блок deploy.replicas; отсутствие ports у api.") + code( + pdf, + " api:\n" + " deploy:\n" + " replicas: ${API_REPLICAS:-2}\n" + " # НЕТ ports: и НЕТ container_name\n" + " lb:\n" + " ports:\n" + " - \"127.0.0.1:8080:8080\"\n" + " - \"[::1]:8080:8080\"", + ) + body( + pdf, + "Зачем нет container_name: имя контейнера в Docker уникально. Если написать messenger-api, вторую реплику " + "scale не создаст. Compose сам даёт mtusi-lab3-api-1, api-2.", + ) + + h2(pdf, "4.2. HAProxy: очередь без прилипания") + speak( + pdf, + "HAProxy — касса с одной дверью. Клиент не знает про два официанта. Алгоритм roundrobin: запросы по кругу. " + "Cookie нет, IP не клеим — sticky запрещён заданием, иначе скрыли бы, что сессия не общая. " + "Список бэкендов не руками: server-template спрашивает Docker DNS имя api, до 4 слотов. " + "Проверка живости — GET /health/ready каждые 1 с, два провала — вон из круга.", + ) + show(pdf, "infra/haproxy.cfg целиком, особенно backend api.") + code( + pdf, + "frontend public\n" + " bind *:8080\n" + " http-request return status 200 ... hdr X-Instance-Id \"load-balancer\" ... if { path /health/live }\n" + " default_backend api\n" + "backend api\n" + " balance roundrobin\n" + " option httpchk\n" + " http-check send meth GET uri /health/ready ...\n" + " http-check expect status 200\n" + " default-server inter 1s fall 2 rise 1 resolvers docker ...\n" + " server-template api 4 api:8080 check", + ) + body( + pdf, + "Почему не Nginx: свободный выбор, взяли HAProxy 3.2 с docker resolvers. Почему live на LB: контракт хочет, " + "чтобы публичный live проверял процесс ВХОДА. Ready — можно ли давать работу этой реплике (БД+Redis+accepting).", + ) + + h2(pdf, "4.3. X-Instance-Id и X-Request-Id") + speak( + pdf, + "Request-Id — имя письма, каждый запрос новый UUID, его клеит middleware. Instance-Id — имя почтальона: " + "пока жив процесс, строка одна. Берётся из переменной INSTANCE_ID, иначе HOSTNAME контейнера. " + "В базу не пишется. Нужен, чтобы доказать две реплики и чтобы stop-one нашёл контейнер. " + "Request-Id для docker stop бесполезен.", + ) + show(pdf, "src/app/config.py функция _instance_id; src/app/middleware.py; src/app/main.py app.state.instance_id") + code( + pdf, + "# config.py\n" + "configured = os.environ.get(\"INSTANCE_ID\", \"\").strip()\n" + "if configured: return configured\n" + "host = os.environ.get(\"HOSTNAME\", \"\").strip() or socket.gethostname()\n" + "return host\n" + "\n" + "# middleware.py\n" + "response.headers[\"X-Request-Id\"] = request_id\n" + "response.headers[\"X-Instance-Id\"] = _instance_id(request)", + ) + + h2(pdf, "4.4. Общие сессии — почему не память API") + speak( + pdf, + "Если сессию хранить в словаре Python, второй контейнер не узнает токен — после round-robin будет 401, " + "придётся логиниться снова. Redis общий. Ключ sess:sha256(token), TTL абсолютный PXAT, чтобы после " + "рестарта Redis из AOF срок не продлился. AOF appendfsync always — учебная сохранность при restart.", + ) + show(pdf, "src/app/sessions.py create_session / resolve_session; compose redis command --appendonly yes") + code( + pdf, + "token = secrets.token_urlsafe(32)\n" + "await redis.set(session_key(token), payload, pxat=int(expires_at.timestamp() * 1000))", + ) + + h2(pdf, "4.5. Идемпотентность POST сообщения") + speak( + pdf, + "Ключ придумывает клиент, не человек в UI и не сервер. Сервер только читает заголовок Idempotency-Key. " + "Без него 400. Область: пользователь + POST + путь чата + строка ключа. Хранится в Postgres таблица " + "idempotency_records. Повтор того же текста — тот же message id. Другой текст — 409. Другой пользователь " + "с тем же ключом — другое сообщение. Параллель: pg_advisory_xact_lock, чтобы два API не вставили два сообщения. " + "Пишем Message, flush, потом запись ключа — в одной транзакции. 5xx не сохраняем: если упали до INSERT ключа, " + "клиент может повторить тот же ключ.", + ) + show(pdf, "src/app/api/messages.py require_idempotency_key; crud/messages.py create_message; migrations/002_idempotency.sql") + code( + pdf, + "# api: без заголовка — 400\n" + "value = request.headers.get(\"idempotency-key\")\n" + "\n" + "# crud: замок по user+path+key, потом SELECT ключа\n" + "SELECT pg_advisory_xact_lock(:a, :b)\n" + "# тот же hash текста → вернуть старое сообщение\n" + "# другой hash → 409\n" + "# нет записи → INSERT messages, INSERT idempotency_records status 201", + ) + body( + pdf, + "Генерация ключа в тестах: tests/client.py — uuid.uuid4().hex если вызывающий не передал key. " + "Гонка: student-tests/level3.py функция test_concurrent_key — Barrier на 12 потоков, один ключ, " + "ожидаем 12×201 и один id, в истории одна копия. Запускается внутри python student-tests/level3.py.", + ) + + h2(pdf, "4.6. Failover ≤ 10 секунд") + speak( + pdf, + "Тест читает X-Instance-Id из ответа, кладёт в TARGET_INSTANCE_ID, вызывает scripts/stop-one.cmd. " + "Скрипт сверяет hostname/имя/id контейнера и docker stop -t 5. HAProxy за ~2 с (1 с × fall 2) выкидывает " + "труп из круга. Живая реплика продолжает. Сессия в Redis, сообщения в Postgres — повторный логин не нужен. " + "Измеренный recovery 2.46 с, ошибок 2 из 93. Курс просит не больше 10 с. Краткие ошибки в момент обнаружения допустимы.", + ) + show(pdf, "scripts/stop-one.sh и stop-one.cmd; student-tests/failover.py; evidence/failover.txt и sequential_failover.json") + code( + pdf, + "# stop-one.sh\n" + "hostname=$(docker inspect -f '{{.Config.Hostname}}' \"$id\")\n" + "if [ \"$TARGET_INSTANCE_ID\" = \"$hostname\" ] || ...; then found=$id; fi\n" + "docker stop -t 5 \"$found\"", + ) + body( + pdf, + "После первого стопа restore-api.cmd поднимает вторую реплику. Повтор failover.py бьёт уже её. " + "Отдельно в отчёте docker stop второй: пишет оставшийся api, recovery почти 0, потому что касса уже на живом. " + "Показать docker compose ps — один Exited, второй healthy.", + ) + + h1(pdf, "5. Оценка 4") + + h2(pdf, "5.1. Health, таймауты, SIGTERM, период проверки") + speak( + pdf, + "Live — процесс существует. Ready — принимаем работу: accepting=True, SELECT 1 в Postgres, ping Redis. " + "HAProxy проверяет ready, не live: иначе труп без базы остался бы в круге. " + "Период проверок: inter 1s. Максимум обнаружения отказа: fall 2 → около 2 секунд; с DNS hold valid 2s верхняя оценка около 4 с. " + "SIGTERM: compose stop_signal SIGTERM, stop_grace_period 8s, uvicorn timeout_graceful_shutdown 5. " + "В finally lifespan accepting=False — ready и бизнес отдают 503, касса выкидывает бэкенд до убийства процесса.", + ) + show(pdf, "health.py; main.py lifespan; __main__.py uvicorn; compose stop_grace_period; haproxy inter/fall") + code( + pdf, + "# health.py ready\n" + "if not request.app.state.accepting: 503\n" + "SELECT 1; redis.ping()\n" + "\n" + "# main.py finally\n" + "app.state.accepting = False\n" + "\n" + "# middleware: если not accepting и путь не /health/live → 503", + ) + + h2(pdf, "5.2. По очереди обе реплики, RPS, идемпотентность параллельно") + body( + pdf, + "Цифры зачитать из REPORT / sequential_failover.json, не путать с 128 RPS трека 1 — другой клиент.", + ) + bullet(pdf, "stop той, что ответила: recovery 2.46 с, 91 успех / 2 ошибки, 6.07 RPS, окно 15 с.") + bullet(pdf, "restore + ещё раз: 2.74 с, 90/2, 6.00 RPS.") + bullet(pdf, "stop второй: ~0.03 с, 46/1, 3.83 RPS.") + bullet(pdf, "параллельный ключ: level3, 12 потоков, один id.") + + h2(pdf, "5.3. Лимиты, секреты, нет порта API") + speak( + pdf, + "У каждого сервиса deploy.resources.limits. api 0.50 CPU / 256M каждая. Секреты Docker: postgres_password " + "только postgres, database_url — migrate и api, cache_url только api. HAProxy паролей не видит. " + "Volume только postgres_data и redis_data — у api своего диска с чатами нет.", + ) + show(pdf, "compose.yaml secrets, volumes, deploy.resources, отсутствие ports у api, отсутствие container_name.") + + h2(pdf, "5.4. Rolling и миграции один раз") + speak( + pdf, + "Rolling не равен failover. Failover — убили живого. Rolling — сначала подняли нового, потом стопнули старого, " + "по одной штуке, под нагрузкой. Скрипт: scale N+1, wait, docker stop -t 5 старого, rm, вернуть scale N. " + "Замер: rolling.json, 1980 ok / 24 err (1.2%), оба старых instance id исчезли. Ненулевые ошибки на стыке DNS нормальны.", + ) + show(pdf, "scripts/rolling-update.sh; student-tests/rolling.py") + speak( + pdf, + "Миграции: сервис migrate, restart no, python -m app.migrate, API depends_on service_completed_successfully, " + "RUN_MIGRATIONS=0. API ждут schema_migrations. Совместимость: rolling одной версии API; схему заранее накатил migrate. " + "Не обещаем lab2 и lab3 одновременно. Ограничение честно: откат схемы не делали.", + ) + show(pdf, "compose.yaml service migrate; src/app/migrate.py pg_advisory_xact_lock; main.py wait_for_schema") + + h1(pdf, "6. Оценка 5 — трек 1") + + h2(pdf, "6.1. Речь 2–3 минуты") + speak( + pdf, + "Трек 1 — цена масштабирования. Гипотеза: при фиксированном суммарном CPU добавление реплик не ускоряет POST, " + "потому что режется CPU каждого процесса, а не потому что кончилась база. " + "Методика: один профиль, 8 closed-loop клиентов через HAProxy, прогрев 5 с, замер 20 с. " + "Серия A: всегда 1.0 CPU и 512 MiB на все API, реплик 1, 2, 4. " + "Серия B: всегда 2 реплики, CPU растёт 0.5 → 1 → 2 суммарно. " + "A: 128 → 107 → 69 RPS. Четыре реплики на том же ватте почти вдвое медленнее одной. Ошибок 0. " + "B: 49 → 105 → 221. Дали CPU — почти линейно. Значит запас по Postgres был. " + "Улучшение: bind [::1]:8080, иначе Windows localhost давал p50 две секунды.", + ) + + h2(pdf, "6.2. Где цифры") + show(pdf, "REPORT.md таблица; evidence/track1.json; графики track1_fixed_budget.svg и track1_growing_cpu.svg") + bullet(pdf, "fixed-1: 1×1.00 CPU, 128.1 RPS, p50 52 мс") + bullet(pdf, "fixed-2: 2×0.50, 107.5 RPS, p50 72 мс") + bullet(pdf, "fixed-4: 4×0.25, 69.3 RPS, p50 95 мс") + bullet(pdf, "grow-2×0.25: сумма 0.50 CPU, 49.1 RPS") + bullet(pdf, "grow-2×0.50: сумма 1.00, 105.5 RPS") + bullet(pdf, "grow-2×1.00: сумма 2.00, 221.0 RPS") + body( + pdf, + "Скрипт student-tests/track1.py: scale_api, docker update --cpus/--memory, run_load 8 потоков POST /messages. " + "Closed-loop: следующий запрос только после ответа, RPS ≈ 8 / среднее время.", + ) + + h2(pdf, "6.3. Saturation point — как не попасть") + warn( + pdf, + "В README написано «найдите saturation point БД/LB/пула». Классического плато этих трёх НЕТ. " + "Серия B ещё растёт до 221, postgres в docker stats доли процента, пул 10+10 на реплику, при 4 репликах до 80 " + "соединений при max_connections 100, ошибок 0. Мы НЕ дожали базу до потолка. Это дырка по букве задания. " + "Закрываем её честным текстом, не выдуманным «Postgres на 100%».", + ) + speak( + pdf, + "Искали насыщение Postgres, HAProxy и пула. На этом профиле они не насытились: stats пустые, при росте CPU " + "RPS ещё линейный. То, что видно: при фиксированном бюджете рост ЧИСЛА реплик перестаёт помогать и вредит — " + "это нарезка CPU API. Чтобы поймать плато базы, нужен более жёсткий профиль, его нет в evidence. " + "Это ограничение опыта, записано в конце REPORT.md.", + ) + body( + pdf, + "Где «показано» в работе: абзац под таблицей в REPORT.md и массивы docker_stats в track1.json " + "(имена postgres-1, lb-1, api-*). Отрицательный результат: они не bottleneck. " + "Не ищите слайд «база 100%» — его нет.", + ) + + h2(pdf, "6.4. Подтверждённое улучшение") + body( + pdf, + "Задание не требует конкретно IPv6. Требует одно измеренное до/после. В отчёте взяли вход. " + "Было только 127.0.0.1:8080. Windows localhost идёт в ::1, p50 ≈ 2 с, ≈1.9 RPS. " + "Добавили [::1]:8080. После: localhost 87.6 RPS p50 75 мс, 127.0.0.1 94.7 RPS. " + "Файлы: compose.yaml ports lb; evidence/load_localhost.json. " + "Это не «серия B». Серия B — обязательный второй опыт, не фикс.", + ) + + h2(pdf, "6.5. Ограничения трека, которые сами назвать первым") + bullet(pdf, "Один Docker-host. Отказ VM/ноутбука не переживается.") + bullet(pdf, "Один HAProxy, одна Postgres, один Redis — SPOF.") + bullet(pdf, "Closed-loop занижает абсолютный RPS; сравнивать отношения точек, не 128 с одногруппником.") + bullet(pdf, "docker stats --no-stream — кадр в конце, не среднее; не объяснять 24% vs 0.7% как «вторая не работала».") + bullet(pdf, "Две реплики для failover, не для скорости при 1 CPU. Это разные оси.") + bullet(pdf, "Гипотеза в исходнике track1.py чуть старая про Postgres; в JSON и REPORT исправлена — читать REPORT.") + + h1(pdf, "7. Живой сценарий защиты (чеклист)") + bullet(pdf, "Стенд уже up --scale api=2, ready 200.") + bullet(pdf, "docker compose ps — два api healthy без host-порта, lb 8080.") + bullet(pdf, "python student-tests/level3.py — две реплики + идемпотентность. Открыть level3.json.") + bullet(pdf, "По желанию: два curl GET /api/v1/users/me с одним Bearer — разные X-Instance-Id.") + bullet(pdf, "python student-tests/failover.py — не паниковать из-за 1–2 ошибок. Потом docker ps: один Exited.") + bullet(pdf, "scripts\\restore-api.cmd, второй failover или руками docker stop второго имени из ps.") + bullet(pdf, "Открыть REPORT таблицу трека 1 и два SVG. Произнести 128/107/69 и 49/105/221.") + bullet(pdf, "Если просят код HAProxy / идемпотентности / stop-one — разделы 4–5 этой методички.") + bullet(pdf, "Не гонять track1.py с нуля, если нет 15+ минут.") + + h1(pdf, "8. Примерные вопросы и ответы") + + qa( + pdf, + "Чем отказ процесса отличается от отказа узла?", + "Процесс — один контейнер api, docker stop. Второй api на том же host + общие Redis/Postgres живут. " + "Узел — вся ВМ/ноутбук/Docker Desktop: вместе падают LB, обе реплики, база. Это трек 2, мы его не заявляем.", + ) + qa( + pdf, + "Почему depends_on и healthcheck — не балансировщик?", + "depends_on решает порядок СТАРТА (сначала postgres healthy, потом api). Healthcheck Compose красит контейнер " + "healthy для --wait. Трафик клиентов они не делят. Делит HAProxy: у него свой httpchk и roundrobin. " + "Без LB клиент должен был бы сам знать два IP.", + ) + qa( + pdf, + "Какие POST можно повторять после timeout и что защищает Idempotency-Key?", + "Клиент не знает, записалось ли сообщение. Имеет право повторить ТОТ ЖЕ POST с ТЕМ ЖЕ ключом и тем же телом. " + "Сервер вернёт старый id. Другое тело с тем же ключом — 409, это уже другое сообщение, новый ключ. " + "Ключ обязателен только у POST сообщения. Регистрацию/чаты так не защищали.", + ) + qa( + pdf, + "Что сломается, если сессии в локальной памяти, а API станет больше?", + "Round-robin отправит следующий запрос на соседний процесс — токена там нет — 401. Sticky это запрещённый костыль: " + "убили «свою» реплику — сессия всё равно умерла. Поэтому Redis.", + ) + qa( + pdf, + "Зачем X-Instance-Id, если есть X-Request-Id?", + "Request-Id уникален на каждый хит даже на одном процессе. Им нельзя доказать две реплики и нельзя docker stop. " + "Instance-Id стабилен на жизнь процесса и равен hostname.", + ) + qa( + pdf, + "Как HAProxy выбирает первое или второе API?", + "Счётчик round-robin + кто проходит ready. «Второе вместо первого» — следующий слот, не баг. " + "Порядок слотов из DNS, не «api-1 важнее».", + ) + qa( + pdf, + "Период проверок и максимальное время обнаружения отказа?", + "inter 1s, fall 2 → типично ~2 с после 503/смерти. timeout check 1s. DNS hold valid 2s → верх ~4 с. " + "Измерили recovery 2.46 с. Бюджет курса 10 с.", + ) + qa( + pdf, + "Где генерируется Idempotency-Key?", + "На клиенте. В сервере генерации нет, иначе сервер не отличит повтор от нового. Тесты: uuid4 в tests/client.py " + "и student-tests/level3.py. Человек в чате ключ не печатает.", + ) + qa( + pdf, + "Почему 12 параллельных POST не делают 12 сообщений?", + "Оба API идут в одну таблицу. Замок advisory на время транзакции: второй ждёт и видит ключ первого. " + "UNIQUE на (user, method, path, key) — страховка. Тест test_concurrent_key.", + ) + qa( + pdf, + "Почему публичный live отвечает HAProxy?", + "Live входа = жива ли касса. Если live отдавать API, при мёртвом LB клиент не достучится, а при живом LB и мёртвых " + "API live всё равно можно отдать с кассы. Ready специально идёт на API.", + ) + qa( + pdf, + "Зачем два одинаковых контейнера, если трек 1 показал, что один быстрее?", + "Скорость при фиксированном 1 CPU и выживаемость — разные цели. Один толстый процесс быстрее на этом профиле. " + "Два нужны, чтобы docker stop одного не обнулил сервис. На защите развести оси.", + ) + qa( + pdf, + "Где saturation point БД/LB/пула?", + "Не найден как плато. Stats postgres/lb ≈0%, серия grow ещё линейна до 221 RPS, пул не упёрся. " + "Нашли другое: при фиксированном CPU рост реплик вреден. Классическое насыщение склада не показали — " + "ограничение профиля 8×20с. Так и написано в REPORT.", + ) + qa( + pdf, + "Почему не нулевые ошибки на failover/rolling?", + "Между SIGTERM и исключением из LB есть запросы в умирающий процесс. Курс это разрешает, если измеряли. " + "У нас единицы процентов, recovery секунды.", + ) + qa( + pdf, + "Миграции на каждой реплике?", + "Нет. Отдельный one-shot migrate, API RUN_MIGRATIONS=0. Иначе гонка CREATE TABLE.", + ) + qa( + pdf, + "Почему нет sticky?", + "Sticky прячет раздельное состояние. Задание прямо запрещает чинить им локальные сессии. " + "Состояние общее — прилипать незачем.", + ) + qa( + pdf, + "Что будет, если убить Postgres?", + "Все api станут unready (ping БД падает), HAProxy перестанет слать бизнес-трафик, сервис ляжет. " + "Две реплики API базу не спасают. Не заявлять обратное.", + ) + qa( + pdf, + "Что будет, если убить Redis?", + "Новые логины и проверка Bearer не работают (503). Старые сообщения в Postgres живы, но API без сессии их не отдаст. " + "Redis SPOF для аутентификации.", + ) + qa( + pdf, + "Closed-loop / coordinated omission?", + "Клиент ждёт ответа, медленные запросы уменьшают число попыток. Для сравнения 1/2/4 одним клиентом ок. " + "Это не абсолютный потолок стенда как open-loop.", + ) + qa( + pdf, + "Почему в stats одна реплика 24%, сосед 0.7%?", + "Один кадр docker stats в конце прогона, не интеграл за 20 с. Не строить на этом теорию. Смотреть RPS и лимиты.", + ) + qa( + pdf, + "Зачем [::1], это же не про реплики?", + "На Windows localhost ≠ 127.0.0.1. Без IPv6-bind измерение «через localhost» врало бы ~2 с на запрос. " + "Это подтверждённое улучшение входа, без него трек 1 на localhost не про API.", + ) + qa( + pdf, + "Можно ли сравнить ваш 128 RPS с чужим ноутбуком?", + "Нет. Курс: универсального проходного RPS нет. Сравнивают отношения на одной машине: 128:107:69.", + ) + qa( + pdf, + "workers uvicorn больше 1?", + "workers=1. Несколько воркеров в одном контейнере — уже не наш X-Instance-Id=hostname на всех. " + "Горизонталь — отдельные контейнеры.", + ) + qa( + pdf, + "Как stop-one понимает, кого убивать?", + "Тест передаёт TARGET_INSTANCE_ID = значение заголовка. Скрипт сравнивает с Hostname контейнера " + "(мы как раз кладём hostname в заголовок).", + ) + qa( + pdf, + "Rolling под нагрузкой зачем, если есть failover?", + "Обновление образа без «выключить всех». Сначала лишний здоровый, потом убрать старого. Иначе дыра на время сборки.", + ) + qa( + pdf, + "Совместимы ли миграции с работающей версией?", + "Additive: новая таблица ключей. Rolling гоняет одну версию API после migrate. Не заявляем blue-green двух схем.", + ) + qa( + pdf, + "Почему Postgres слушает 5433 на хосте, это же дырка?", + "Учебный отладочный bind на 127.0.0.1, не публикация API. Снаружи интернет не торчит. Можно признать упрощением.", + ) + qa( + pdf, + "Аргон2 и lab2?", + "Пароли как в lab2, Basic только на создание сессии, дальше Bearer. Это не тема lab3, но контракт сохранён.", + ) + qa( + pdf, + "Что в PR / отчёте ещё TODO?", + "В REPORT строка Commit/PR: TODO после публикации. Если PR не открыт — сказать как есть, не выдумывать номер.", + ) + + h1(pdf, "9. Мини-шпаргалка чисел") + bullet(pdf, "Реплики: 2. Вход: 8080. Ready LB: 1 с, fall 2, обнаружение ~2 с (верх ~4 с). Failover recovery ~2.5 с.") + bullet(pdf, "Grace: stop -t 5, uvicorn 5, compose 8 с.") + bullet(pdf, "TTL сессии 3600, ключа идемпотентности 86400.") + bullet(pdf, "Лимит api: 0.50 CPU / 256M. Трек1 fixed сумма всегда 1 CPU / 512M.") + bullet(pdf, "Трек1 RPS: 128 / 107 / 69 и 49 / 105 / 221. Ошибки 0.") + bullet(pdf, "IPv6 фикс: ~1.9 RPS → ~88 RPS на localhost.") + bullet(pdf, "Гонка: 12 POST, 1 message id. Rolling: ~1.2% ошибок.") + + h1(pdf, "10. Если что-то пойдёт не так на защите") + bullet(pdf, "Стенд не ready: docker compose ps, логи docker compose logs api --tail 80, часто migrate не прошёл или Docker Desktop спал.") + bullet(pdf, "Один instance id: реплика одна — compose up --scale api=2; или смотрите live вместо /users/me.") + bullet(pdf, "localhost тупит, 127.0.0.1 быстрый: проверяйте, что в compose есть [::1]:8080 и контейнер lb пересоздан.") + bullet(pdf, "failover не находит TARGET: instance id должен совпасть с hostname (inspect). Не сравнивать с load-balancer.") + bullet(pdf, "Не лезьте чинить публичные tests/ и contracts/ на глазах — это запрещено курсом.") + + pdf.ln(4) + body( + pdf, + "Конец методички. Источник цифр: REPORT.md и evidence/ на дату 2026-10-30. Если перегоните тесты — замените числа, " + "не зубрите старые. Код открывать из репозитория, не из памяти.", + ) + pdf.output(str(OUT)) + print("wrote", OUT) + + +if __name__ == "__main__": + build() diff --git a/scripts/render_track1_svg.py b/scripts/render_track1_svg.py new file mode 100644 index 00000000..3008d283 --- /dev/null +++ b/scripts/render_track1_svg.py @@ -0,0 +1,110 @@ +# -*- coding: utf-8 -*- +"""Перерисовать графики трека 1 из evidence/track1.json.""" +from __future__ import annotations + +import json +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +EVIDENCE = ROOT / "evidence" +JSON_PATH = EVIDENCE / "track1.json" + + +def bar_chart(path: Path, title: str, xlabel: str, bars: list[tuple[str, float]], color: str) -> None: + width, height = 820, 420 + left, right, top, bottom = 70, 790, 50, 350 + plot_w = right - left + plot_h = bottom - top + values = [v for _, v in bars] or [1.0] + ymax = max(values) * 1.15 if max(values) else 1.0 + n = len(bars) + gap = plot_w / n + bar_w = gap * 0.48 + ticks = 4 + lines = [ + f'', + '', + f'{_esc(title)}', + ] + for i in range(ticks + 1): + y = bottom - plot_h * i / ticks + val = ymax * i / ticks + lines.append(f'') + lines.append( + f'{val:.0f}' + ) + lines.append(f'') + lines.append(f'') + for i, (label, value) in enumerate(bars): + h = 0 if ymax <= 0 else plot_h * value / ymax + x = left + gap * i + (gap - bar_w) / 2 + y = bottom - h + lines.append(f'') + lines.append( + f'{value:.1f}' + ) + lines.append( + f'{_esc(label)}' + ) + lines.append( + f'{_esc(xlabel)}' + ) + lines.append( + f'successful RPS' + ) + lines.append("\n") + path.write_text("\n".join(lines), encoding="utf-8") + + +def _esc(text: str) -> str: + return text.replace("&", "&").replace("<", "<").replace(">", ">") + + +def rps(item: dict) -> float: + return float(item["successful_rps"] or 0) + + +def main() -> None: + data = json.loads(JSON_PATH.read_text(encoding="utf-8")) + scale = data.get("scale_out_own_cpu") or [] + half = [x for x in scale if abs(x["cpus_each"] - 0.5) < 1e-9] + full = [x for x in scale if abs(x["cpus_each"] - 1.0) < 1e-9] + if half: + bar_chart( + EVIDENCE / "track1_scale_out.svg", + "Each replica keeps 0.50 CPU (like another server)", + "Replicas; total CPU grows 0.5 → 1.0 → 2.0", + [(str(x["replicas"]), rps(x)) for x in half], + "#276749", + ) + elif full: + bar_chart( + EVIDENCE / "track1_scale_out.svg", + "Each replica keeps 1.0 CPU (like another server)", + "Replicas; total CPU grows with copies", + [(str(x["replicas"]), rps(x)) for x in full], + "#276749", + ) + fixed = data.get("fixed_total_budget") or [] + if fixed: + bar_chart( + EVIDENCE / "track1_fixed_budget.svg", + "Fixed total 1.0 CPU split across replicas", + "Replica count at the same total CPU", + [(str(x["replicas"]), rps(x)) for x in fixed], + "#c53030", + ) + growing = data.get("growing_resources") or [] + if growing: + bar_chart( + EVIDENCE / "track1_growing_cpu.svg", + "Two API replicas, growing CPU/RAM budget", + "Total CPU for two replicas", + [(("%.2f CPU" % x["total_cpu"]).replace(".", ","), rps(x)) for x in growing], + "#2c5282", + ) + print("wrote SVGs next to", JSON_PATH) + + +if __name__ == "__main__": + main() diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/app/api/health.py b/src/app/api/health.py index 8e61555a..77c7b21b 100644 --- a/src/app/api/health.py +++ b/src/app/api/health.py @@ -16,7 +16,11 @@ class HealthOut(BaseModel): @router.get("/health/live", response_model=HealthOut) -async def live() -> dict: +async def live(request: Request) -> dict: + # Для httpchk HAProxy: процесс принимает работу. Redis/Postgres здесь не смотрим, + # иначе при отказе Redis касса выкинет ВСЕ реплики и /users/me не сможет отдать 401. + if not getattr(request.app.state, "accepting", False): + raise AppError(503, "unavailable", "Сервер останавливается") return {"status": "ok"} diff --git a/src/app/crud/users.py b/src/app/crud/users.py index 884381fc..2e3d47fe 100644 --- a/src/app/crud/users.py +++ b/src/app/crud/users.py @@ -1,10 +1,13 @@ +import asyncio +import hashlib import re from uuid import UUID, uuid4 -from sqlalchemy import select +from sqlalchemy import select, text from sqlalchemy.exc import IntegrityError from app.db import map_integrity, session_scope +from app.errors import AppError from app.models import User from app.present import PublicUser from app.security import hash_password, verify_password @@ -26,14 +29,25 @@ async def get_user(user_id: UUID) -> PublicUser | None: return PublicUser(id=row.id, username=row.username, display_name=row.display_name, created_at=row.created_at) +def _username_lock(username: str) -> tuple[int, int]: + digest = hashlib.sha256(("register:" + username).encode("utf-8")).digest() + return int.from_bytes(digest[:4], "big", signed=True), int.from_bytes(digest[4:8], "big", signed=True) + + async def create_user(username: str, display_name: str, password: str) -> PublicUser: - # Argon2 считается до открытия транзакции, чтобы не держать соединение пула. - password_hash = hash_password(password) + # Argon2 в потоке: иначе 16 параллельных hash блокируют event loop, + # /health/ready не отвечает, HAProxy снимает реплику и клиент видит 503. + password_hash = await asyncio.to_thread(hash_password, password) user_id = uuid4() created_at = utcnow() + lock_a, lock_b = _username_lock(username) async with session_scope() as session: try: async with session.begin(): + await session.execute(text("SELECT pg_advisory_xact_lock(:a, :b)"), {"a": lock_a, "b": lock_b}) + taken = await session.scalar(select(User.id).where(User.username == username)) + if taken is not None: + raise AppError(409, "conflict", "Имя пользователя занято") session.add( User( id=user_id, @@ -51,7 +65,7 @@ async def create_user(username: str, display_name: str, password: str) -> Public async def authenticate(username: str, password: str) -> PublicUser | None: if _USERNAME.fullmatch(username) is None or not 12 <= len(password) <= 128: - verify_password("rejected-credential", None) + await asyncio.to_thread(verify_password, "rejected-credential", None) return None async with session_scope() as session: async with session.begin(): @@ -73,6 +87,6 @@ async def authenticate(username: str, password: str) -> PublicUser | None: display_name=row.display_name, created_at=row.created_at, ) - if not verify_password(password, stored): + if not await asyncio.to_thread(verify_password, password, stored): return None return snapshot diff --git a/student-tests/track1.py b/student-tests/track1.py index 6cb94f5b..3bcf8d5b 100644 --- a/student-tests/track1.py +++ b/student-tests/track1.py @@ -165,6 +165,15 @@ def measure(label, replicas, cpus_each, memory_mb_each): def main(): wait_ready() + # Как отдельные серверы: у каждой реплики СВОЙ CPU. Сумма растёт вместе с числом копий. + scale_out = [ + measure("scale-1x0.50", 1, 0.50, 256), + measure("scale-2x0.50", 2, 0.50, 256), + measure("scale-4x0.50", 4, 0.50, 256), + measure("scale-1x1.00", 1, 1.00, 512), + measure("scale-2x1.00", 2, 1.00, 512), + ] + # Требование README: тот же суммарный бюджет на 1/2/4 — это нарезка ОДНОГО хоста, не «новые серверы». fixed_budget = [ measure("fixed-1", 1, 1.00, 512), measure("fixed-2", 2, 0.50, 256), @@ -179,19 +188,25 @@ def main(): apply_limits(0.50, 256) report = { "date": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()), - "hypothesis": "При фиксированном суммарном CPU/RAM добавление реплик перестаёт помогать, когда узким местом становится PostgreSQL/HAProxy, а не CPU процесса API.", + "hypothesis": ( + "Горизонтальное масштабирование ускоряет POST, когда каждая новая реплика приносит СВОЙ CPU " + "(как ещё один сервер). Нарезка одного и того же суммарного CPU на больше копий на одном хосте " + "не масштабирование: RPS не растёт. Потолок тогда ищется у БД/LB/пула на серии с ростом суммарного бюджета." + ), "profile": { "duration_seconds": DURATION, "concurrency": CONCURRENCY, "warmup_seconds": WARMUP, "workload": "closed-loop POST /messages through HAProxy", }, + "scale_out_own_cpu": scale_out, "fixed_total_budget": fixed_budget, "growing_resources": growing, } EVIDENCE.mkdir(exist_ok=True) (EVIDENCE / "track1.json").write_text(json.dumps(report, ensure_ascii=False, indent=2) + "\n", encoding="utf-8") - check(all(item["successful_requests"] > 0 for item in fixed_budget + growing), "a track1 series had no successes") + series = scale_out + fixed_budget + growing + check(all(item["successful_requests"] > 0 for item in series), "a track1 series had no successes") print("PASS: track1 series written to evidence/track1.json")