diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 2321919..d234b62 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -6,13 +6,13 @@ Что реализовано и что перенесено: база lab5; OTLP у API и worker, Collector, Prometheus, Loki, Tempo, Grafana provisioning. Инциденты и измерения burn rate ещё не сняты. Команды запуска из чистого clone: см. REPORT.md (`cp .env.example .env`, `docker compose --env-file .env up -d --build --scale api=2`). -Результаты проверок и ссылка на REPORT.md: TODO -Ограничения / известные ошибки: TODO +Результаты проверок и ссылка на REPORT.md: make check PASS, make test PASS, persistence PASS, failover PASS, lab5 worker-down PASS, lab6 incidents PASS. Вывод в evidence/ и REPORT.md. +Ограничения / известные ошибки: полный замер времени обнаружения короткого всплеска против длинной деградации ещё не снят; на этом прогоне firing был у TimeToReadyFastBurn. Источники и использование ИИ: TODO - [ ] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. - [ ] Контракт и публичные тесты не ослаблены. -- [ ] make check и make test выполнены; приложен реальный вывод. -- [ ] Сценарии отказов/безопасности своего уровня воспроизведены. +- [x] make check и make test выполнены; приложен реальный вывод. +- [x] Сценарии отказов/безопасности своего уровня воспроизведены. - [ ] Все секреты и приватные ключи находятся вне Git; отчёт не содержит tokens. - [ ] README задания сохранён, REPORT.md содержит инструкцию именно моего решения. diff --git a/Makefile b/Makefile index 5d86d17..8ebfe75 100644 --- a/Makefile +++ b/Makefile @@ -22,9 +22,13 @@ load: $(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS) test-persistence: - @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable restart hook"; exit 2) +ifeq ($(ACTION_SCRIPT),) + $(error Set ACTION_SCRIPT to your implemented executable restart hook) +endif $(PYTHON) tests/resilience.py --mode persistence --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) test-failover: - @test -n "$(ACTION_SCRIPT)" || (echo "Set ACTION_SCRIPT to your implemented executable stop-one hook"; exit 2) +ifeq ($(ACTION_SCRIPT),) + $(error Set ACTION_SCRIPT to your implemented executable stop-one hook) +endif $(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS) diff --git a/REPORT.md b/REPORT.md index 0e734f0..222bef9 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,8 +1,8 @@ # Отчёт — лабораторная 6 - Автор, группа: Булацев, БПИ2301 -- Целевая оценка; выбранный трек 5: 5, трек 2 «SLO и обнаружение инцидентов». Эксперименты со всплеском и длинной деградацией ещё не прогнаны. -- Commit/PR: локальные коммиты, PR не открыт +- Целевая оценка; выбранный трек 5: 5, трек 2 «SLO и обнаружение инцидентов». На стенде воспроизведены отказ worker, Postgres и collector; отдельный замер короткого всплеска против длинной деградации ещё не снят. +- Commit/PR: https://gitea.privcloud.tech/mtusi2026/mtusi2026lab6/pulls/37 - Использованные источники, библиотеки и помощь ИИ: контракт lab6, OpenTelemetry Python SDK 1.29.0, Collector Contrib 0.128.0, Prometheus 2.55.1, Loki 3.3.2, Tempo 2.7.1, Grafana 11.4.0. Реализация перенесена из lab5 и дополнена с помощью Cursor. ## Запуск из чистого clone @@ -44,27 +44,29 @@ SLO и burn-rate: `infra/slo.md`, правила `infra/prometheus/alerts.yml`. | Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | | --- | --- | --- | --- | -| База lab5 перенесена | код и compose | API, worker, broker, S3, Postgres на месте | compose.yaml | -| Сигналы и дашборд | provisioning Grafana | конфиги в Git, прогон стенда ещё впереди | infra/grafana/dashboards/messenger.json | -| Трасса upload → worker | traceparent в job и AMQP | код связи есть, снимок трассы ещё не снят | migrations/007_job_trace.sql | -| SLO / burn rate | правила Prometheus | пороги заданы, firing на стенде ещё не снят | infra/prometheus/alerts.yml | -| Инциденты трека 2 | короткий всплеск и длинная деградация | не выполнено в этом коммите | — | +| make check | `make PYTHON=python check` | PASS, offline skeleton | evidence/make-check.txt | +| Публичный smoke | `make PYTHON=python BASE_URL=http://127.0.0.1:8082 test` | PASS lab6 public API scenario | evidence/make-test.txt | +| Сохранность | `make test-persistence ACTION_SCRIPT=scripts/restart.cmd` | PASS, сессия и данные живы после restart | evidence/persistence.txt | +| Отказ одной реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.cmd` | 2 реплики до отказа, 104 успешных записи, 1 ошибка, восстановление за 3.316 с | evidence/failover.txt | +| Worker остановлен | `python -X utf8 scripts/lab5_checks.py` | upload 202, content 409, после старта worker ready и thumbnail | evidence/lab5-worker-down.txt | +| Очередь, БД, collector | `python -X utf8 scripts/lab6_incidents.py` | возраст очереди вырос до 23 с, `TimeToReadyFastBurn` был firing; live 200 и ready/бизнес 503 без Postgres; регистрация 201 без collector | evidence/lab6-incidents.txt | ## Эксперименты и отказы Гипотеза трека 2: пара окон 5m+1h ловит короткий всплеск 5xx быстрее, чем пара 30m+6h, а длинная деградация остаётся видна после того, как короткое окно уже чистое. Ложные срабатывания на одном шумном интервале режет требование совпадения обоих окон. -Прогон, время обнаружения и время восстановления ещё не измерены. +На этой машине lab4 занимает `127.0.0.1:8080` и `:9000`, lab5 — `:8081` и `:9001`, поэтому прогон шёл с `compose.altports.yaml`: API `127.0.0.1:8082`, S3 `127.0.0.1:9002`. `PYTHONUTF8=1`, потому что публичные проверки читают `lab.json` в локальной кодировке Windows. | Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | | --- | --- | --- | --- | -| Остановка worker | растёт oldest job age, alert QueueLagHigh | ещё не прогнано | — | -| Медленная или недоступная БД | 5xx и pool waiting, это не медленный handler | ещё не прогнано | — | -| Недоступный backend телеметрии | API жив, очередь SDK ограничена | ещё не прогнано | — | -| Короткий всплеск и длинная деградация | fast burn и slow burn расходятся по времени | ещё не прогнано | — | +| Остановка worker | upload остаётся 202, content 409, растёт возраст очереди | 202 и 409, `messenger_queue_oldest_age_seconds` дошёл до 23.4; `TimeToReadyFastBurn` был firing | worker поднят, тот же attachment стал ready; после сценария alert уже не firing | +| Postgres остановлен | `/health/live` жив, ready и запись дают 503 | live 200, ready 503, 8 из 8 регистраций 503 | ready снова 200 после `compose start postgres`; данные не удалялись | +| Collector остановлен | API принимает запрос | регистрация 201 | collector запущен снова | +| Restart хранилищ и API | тот же токен и вложение | PASS persistence | volumes сохранены | +| Остановка одной API-реплики | вторая продолжает запись | 2 instance id до отказа, восстановление записи за 3.316 с | остановленная реплика поднята отдельно | ## Ограничения и следующие шаги Алерты вычисляет Prometheus; отдельной доставки нет. Анонимный Admin Grafana слушает только `127.0.0.1`. Возраст очереди — возраст строки `queued` в Postgres, а не lag consumer RabbitMQ. Две реплики публикуют один и тот же gauge глубины, поэтому на графике `max`. -Дальше: поднять стенд, снять одну трассу и связанный лог, остановить worker и замедлить БД, затем прогнать оба сценария burn rate и записать времена. \ No newline at end of file +Дальше: снять одну трассу upload до S3 вместе со структурным логом и отдельно измерить время обнаружения короткого всплеска и длинной деградации. `QueueLagHigh` в этом прогоне не дождались: worker вернули, когда возраст очереди был около 23 с, порог правила — 30 с. \ No newline at end of file diff --git a/compose.altports.yaml b/compose.altports.yaml index 059b0f4..3565898 100644 --- a/compose.altports.yaml +++ b/compose.altports.yaml @@ -1,9 +1,9 @@ -# Local-only overlay so this stand can run beside lab4, which already owns 8080 and 9000. +# Local-only overlay so this stand can run beside lab4 (8080/9000) and lab5 (8081/9001). # Not part of the submission. Delete it and use compose.yaml when those ports are free. services: lb: ports: !override - - "127.0.0.1:8081:8080" + - "127.0.0.1:8082:8080" s3: ports: !override - - "127.0.0.1:9001:9000" + - "127.0.0.1:9002:9000" diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 0000000..54ad497 Binary files /dev/null and b/evidence/failover.txt differ diff --git a/evidence/lab5-worker-down.txt b/evidence/lab5-worker-down.txt new file mode 100644 index 0000000..33adc53 Binary files /dev/null and b/evidence/lab5-worker-down.txt differ diff --git a/evidence/lab6-incidents.txt b/evidence/lab6-incidents.txt new file mode 100644 index 0000000..aa1c628 Binary files /dev/null and b/evidence/lab6-incidents.txt differ diff --git a/evidence/make-check.txt b/evidence/make-check.txt new file mode 100644 index 0000000..2b6f92c Binary files /dev/null and b/evidence/make-check.txt differ diff --git a/evidence/make-test.txt b/evidence/make-test.txt new file mode 100644 index 0000000..2dfd88f Binary files /dev/null and b/evidence/make-test.txt differ diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 0000000..423fe61 Binary files /dev/null and b/evidence/persistence.txt differ diff --git a/scripts/lab6_incidents.py b/scripts/lab6_incidents.py new file mode 100644 index 0000000..72a47b8 --- /dev/null +++ b/scripts/lab6_incidents.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python3 +"""Lab6 failure scenarios. Prints statuses, ids and metric values. Never tokens.""" + +import base64 +import json +import os +import subprocess +import time +import urllib.error +import urllib.parse +import urllib.request +import uuid +from pathlib import Path + +ROOT = Path(__file__).resolve().parents[1] +BASE = os.environ.get("BASE_URL", "http://127.0.0.1:8080") +PROM = os.environ.get("PROMETHEUS_URL", "http://127.0.0.1:9090") +FIXTURE = ROOT / "tests" / "fixtures" / "sample.png" + + +def compose(*args: str) -> None: + command = ["docker", "compose", "--env-file", ".env", "-f", "compose.yaml"] + if os.environ.get("COMPOSE_ALTPORTS") == "1": + command.extend(["-f", "compose.altports.yaml"]) + subprocess.run([*command, *args], cwd=ROOT, check=True) + + +class Api: + def __init__(self) -> None: + self.opener = urllib.request.build_opener(urllib.request.ProxyHandler({})) + + def call(self, method, path, body=None, token=None, raw=None, content_type=None, headers=None, timeout=15): + hdrs = dict(headers or {}) + data = raw + if body is not None: + data = json.dumps(body).encode("utf-8") + hdrs["Content-Type"] = "application/json" + if content_type: + hdrs["Content-Type"] = content_type + if token: + hdrs["Authorization"] = "Bearer " + token + request = urllib.request.Request(BASE + path, data=data, headers=hdrs, method=method) + try: + response = self.opener.open(request, timeout=timeout) + except urllib.error.HTTPError as error: + response = error + with response: + payload = response.read() + return response.status, payload + + +def expect(status, got, label): + if got != status: + raise SystemExit("FAIL %s expected %s got %s" % (label, status, got)) + print("PASS", label, got) + + +def prom_query(expr: str): + url = PROM + "/api/v1/query?" + urllib.parse.urlencode({"query": expr}) + with urllib.request.urlopen(url, timeout=10) as response: + body = json.loads(response.read().decode()) + if body.get("status") != "success": + raise SystemExit("FAIL prometheus query") + result = body["data"]["result"] + if not result: + return None + return float(result[0]["value"][1]) + + +def alerts(): + with urllib.request.urlopen(PROM + "/api/v1/alerts", timeout=10) as response: + body = json.loads(response.read().decode()) + names = [] + for item in body["data"]["alerts"]: + if item.get("state") == "firing": + names.append(item["labels"].get("alertname", "")) + return sorted(names) + + +def wait_ready_http(): + deadline = time.monotonic() + 90 + while time.monotonic() < deadline: + try: + status, _ = Api().call("GET", "/health/ready", timeout=3) + if status == 200: + return + except Exception: + pass + time.sleep(1) + raise SystemExit("FAIL API did not become ready") + + +def user(api: Api): + username = "l6_" + uuid.uuid4().hex[:10] + password = "T3st-" + uuid.uuid4().hex + status, _ = api.call( + "POST", + "/api/v1/users", + {"username": username, "display_name": "Lab6", "password": password}, + ) + expect(201, status, "register") + basic = base64.b64encode((username + ":" + password).encode()).decode() + status, payload = api.call("POST", "/api/v1/auth/sessions", headers={"Authorization": "Basic " + basic}) + expect(201, status, "login") + return json.loads(payload)["token"] + + +def main() -> None: + api = Api() + token = user(api) + status, chat_raw = api.call( + "POST", + "/api/v1/chats", + {"title": "lab6-incidents", "member_ids": []}, + token=token, + ) + # member_ids must include someone? empty may 400. Create with only self via API rules. + if status != 201: + me_status, me_raw = api.call("GET", "/api/v1/users/me", token=token) + expect(200, me_status, "me") + me = json.loads(me_raw)["id"] + status, chat_raw = api.call( + "POST", + "/api/v1/chats", + {"title": "lab6-incidents", "member_ids": [me]}, + token=token, + ) + expect(201, status, "chat") + chat_id = json.loads(chat_raw)["id"] + print("chat", chat_id) + + print("-- worker stopped: queue age grows, content stays 409 --") + compose("stop", "worker") + content = FIXTURE.read_bytes() + status, attachment_raw = api.call( + "POST", + "/api/v1/chats/%s/attachments?filename=sample.png" % chat_id, + token=token, + raw=content, + content_type="image/png", + ) + expect(202, status, "upload while worker stopped") + attachment_id = json.loads(attachment_raw)["id"] + print("attachment", attachment_id) + status, _ = api.call("GET", "/api/v1/attachments/%s/content" % attachment_id, token=token) + expect(409, status, "content before ready") + deadline = time.monotonic() + 80 + age = None + while time.monotonic() < deadline: + age = prom_query("max(messenger_queue_oldest_age_seconds)") + print("queue_oldest_age_seconds", age, "firing", ",".join(alerts()) or "-") + if age is not None and age >= 15: + break + time.sleep(5) + if age is None or age < 5: + raise SystemExit("FAIL queue age did not grow") + compose("start", "worker") + ready_deadline = time.monotonic() + 90 + while time.monotonic() < ready_deadline: + status, body = api.call("GET", "/api/v1/attachments/" + attachment_id, token=token) + expect(200, status, "poll") + parsed = json.loads(body) + if parsed["status"] == "ready": + print("PASS attachment ready after worker start", attachment_id) + break + if parsed["status"] == "failed": + raise SystemExit("FAIL attachment failed") + time.sleep(0.5) + else: + raise SystemExit("FAIL attachment did not become ready") + time.sleep(12) + print("queue_oldest_age_seconds_after", prom_query("max(messenger_queue_oldest_age_seconds)")) + + print("-- postgres stopped: live stays 200, ready becomes 503 --") + compose("stop", "postgres") + time.sleep(2) + status, _ = api.call("GET", "/health/live") + expect(200, status, "live while postgres stopped") + status, _ = api.call("GET", "/health/ready") + expect(503, status, "ready while postgres stopped") + burst_503 = 0 + for _ in range(8): + status, _ = api.call( + "POST", + "/api/v1/users", + { + "username": "l6d_" + uuid.uuid4().hex[:8], + "display_name": "DbDown", + "password": "T3st-" + uuid.uuid4().hex, + }, + ) + if status == 503: + burst_503 += 1 + else: + print("unexpected status during postgres stop", status) + if burst_503 < 8: + raise SystemExit("FAIL expected every business write to be 503") + print("PASS business 503 while postgres stopped", burst_503) + compose("start", "postgres") + wait_ready_http() + print("PASS ready after postgres start") + + print("-- collector stopped: API still accepts a registration --") + compose("stop", "otel-collector") + time.sleep(1) + status, _ = api.call( + "POST", + "/api/v1/users", + { + "username": "l6c_" + uuid.uuid4().hex[:10], + "display_name": "CollectorDown", + "password": "T3st-" + uuid.uuid4().hex, + }, + ) + expect(201, status, "register while collector is down") + compose("start", "otel-collector") + print("PASS collector restarted") + print("firing_at_end", ",".join(alerts()) or "-") + + +if __name__ == "__main__": + main() diff --git a/scripts/restart.cmd b/scripts/restart.cmd new file mode 100644 index 0000000..551e409 --- /dev/null +++ b/scripts/restart.cmd @@ -0,0 +1,4 @@ +@echo off +cd /d "%~dp0\.." +docker compose --env-file .env restart postgres redis s3 rabbitmq api worker +exit /b %ERRORLEVEL% diff --git a/scripts/stop-one.cmd b/scripts/stop-one.cmd new file mode 100644 index 0000000..5131d3a --- /dev/null +++ b/scripts/stop-one.cmd @@ -0,0 +1,3 @@ +@echo off +powershell -NoProfile -ExecutionPolicy Bypass -File "%~dp0stop-one.ps1" +exit /b %ERRORLEVEL% diff --git a/scripts/stop-one.ps1 b/scripts/stop-one.ps1 new file mode 100644 index 0000000..f863741 --- /dev/null +++ b/scripts/stop-one.ps1 @@ -0,0 +1,23 @@ +$ErrorActionPreference = "Stop" +if (-not $env:TARGET_INSTANCE_ID) { + Write-Error "TARGET_INSTANCE_ID is required" + exit 1 +} +Set-Location (Join-Path $PSScriptRoot "..") +$ids = docker compose --env-file .env ps -q api +$found = $false +foreach ($id in $ids) { + if (-not $id) { continue } + $iid = "" + try { $iid = (docker exec $id cat /tmp/instance-id).Trim() } catch { $iid = "" } + $hostName = (docker inspect -f "{{.Config.Hostname}}" $id).Trim() + if ($iid -eq $env:TARGET_INSTANCE_ID -or $hostName -eq $env:TARGET_INSTANCE_ID) { + docker stop -t 5 $id | Out-Null + $found = $true + break + } +} +if (-not $found) { + Write-Error "no running API replica matched TARGET_INSTANCE_ID" + exit 1 +}