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`.
-
+
+
+

-| Серия | Реплики | 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 @@
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 @@
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 @@
+
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'\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")