From 9af10200875a5c9e0f3dace22eaca6814d2239ef Mon Sep 17 00:00:00 2001 From: Atelier77 Date: Tue, 17 Nov 2026 02:15:14 +0300 Subject: [PATCH] feat-(4 level done, ready to 5) --- .github/pull_request_template.md | 3 +- REPORT.md | 5 ++- results/failover_metrics.json | 17 +++++++ scripts/failover_test.sh | 26 +++++++++++ scripts/test_idempotency_failover.py | 66 ++++++++++++++++++++++++++++ src/api/routes/messages/message.py | 19 ++++---- src/services/idempotency.py | 66 ++++++++++++++++++++++------ 7 files changed, 179 insertions(+), 23 deletions(-) create mode 100644 results/failover_metrics.json create mode 100644 scripts/failover_test.sh create mode 100644 scripts/test_idempotency_failover.py diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md index 0e0e4bc4..ddf661a1 100644 --- a/.github/pull_request_template.md +++ b/.github/pull_request_template.md @@ -10,7 +10,8 @@ Ограничения / известные ошибки: описано в REPORT.md Источники и использование ИИ: руками -Graceful Degradation: SIGTERM перестаёт принимать новые запросы, выполняет уже полученные в течение 30 секунд и останавливает процесс, встроенная функция сервера Uvicorn. +Graceful Degradation: SIGTERM перестаёт принимать новые запросы, выполняет уже полученные в течение 30 секунд и останавливает процесс, встроенная функция сервера Uvicorn. Для проверки отказоустойчивости был использован скрипт `scripts/failover_test.sh`, который выполняет нагрузочное тестирование (`tests/load.py`) с помощью файла `scripts/test_idempotency_failover.py` и последовательно останавливает/восстанавливает(проверка на отказоустойчивость) реплики API. Результат описан в README.md и метрики представлены в `results/failover_metrics.json`. Идемпотентность при параллельных запросах с одинаковым idempotency-key проводилась с concurrency 4, duration 60s и при 2 репликах api с ограничениями cpus 0.5 и memory 512M. Cache Stampede при холодном запуске решается через Redis Lock на idempotency-key для конкретного запроса благодаря асинхронности запросов. Параллельные запросы с одним idempotent-key создают одну запись, response кэшируется и отдаётся без обращения к БД. Health/readiness и timeouts настроены в `docker-compose.yml` и `nginx.conf`, время обнаружения отказа инстанса ~20 сек. Миграции вынесены в отдельный сервис `migrate` в `docker-compose.yml`. Сервис `api` имеет зависимость `depends_on: migrate (condition: service_completed_successfully)`. В виду этого миграции выполняются только один раз перед запуском реплик api. +- Реплики API только проверяют подключение к БД и инициализируют Redis - [+] Весь обязательный минимум текущей и предыдущих работ сохранён с объявленными переходами. diff --git a/REPORT.md b/REPORT.md index 3f6ca9cf..4862061c 100644 --- a/REPORT.md +++ b/REPORT.md @@ -38,7 +38,10 @@ Idempotent-Key, генерируемый при отправке запросо | Нагрузочный тест | `python tests/load.py --duration 30 --concurrency 10| "successful_rps": 134.009, "error_ratio": 0.0 | `results/load.log` | | Проверка нагрузки | python tests/load.py | Latency percentiles cover successes only. | `results/test_load.log` | | Все пункты уровня 4, если заявлен | TODO | TODO | TODO | - +| Последовательно остановите API-реплику, соберите RPS, ошибки, идемпотентность при параллельных запросах с одним ключом | chmod +x scripts/failover.sh --> git bash: ./scripts/failover_test.sh | Отправка 5 параллельных запросов с ключом: failover-test-key-48cc8fb4cd7a46b282292636122fa0c8 +Полученные статусы: [201, 201, 201, 201, 201] +Полученные ID сообщений: ['41646804-dfd6-43bf-b839-983c1244c8ee', '41646804-dfd6-43bf-b839-983c1244c8ee', '41646804-dfd6-43bf-b839-983c1244c8ee', '41646804-dfd6-43bf-b839-983c1244c8ee', '41646804-dfd6-43bf-b839-983c1244c8ee'] +PASS: Идемпотентность работает! Создано ровно 1 сообщение (ID: 41646804-dfd6-43bf-b839-983c1244c8ee) | results/failover_metrics.json | | Выбранный трек 5, если заявлен | TODO | TODO | TODO | TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. diff --git a/results/failover_metrics.json b/results/failover_metrics.json new file mode 100644 index 00000000..07ce3535 --- /dev/null +++ b/results/failover_metrics.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.241, + "concurrency": 4, + "successful_requests": 1127, + "failed_requests": 18, + "error_ratio": 0.015721, + "successful_rps": 18.708, + "successful_latency_ms": { + "p50": 106.965, + "p95": 237.71, + "p99": 406.082 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/scripts/failover_test.sh b/scripts/failover_test.sh new file mode 100644 index 00000000..c597d9c4 --- /dev/null +++ b/scripts/failover_test.sh @@ -0,0 +1,26 @@ +#!/bin/bash +set -e +export PYTHONUTF8=1 + +echo "Запуск фоновой нагрузки на 60 секунд" +python tests/load.py --duration 60 --concurrency 4 --output results/failover_metrics.json & LOAD_PID=$! + +echo "Прогрев (10 секунд)" +sleep 10 + +echo "Имитация отказа: остановка 1 реплики API" +docker stop mtusi2026lab3-api-1 + +echo "Ожидание перенаправления трафика (15 секунд)" +sleep 15 + +echo "Восстановление: запуск 1 реплики(Rolling Update)" +docker start mtusi2026lab3-api-1 + +echo "Ожидание завершения нагрузочного теста" +wait $LOAD_PID + +echo "Проверка идемпотентности (параллельный запрос с одним ключом)" +python scripts/test_idempotency_failover.py + +echo "Результаты в results/failover_metrics.json" diff --git a/scripts/test_idempotency_failover.py b/scripts/test_idempotency_failover.py new file mode 100644 index 00000000..cf1ec7e3 --- /dev/null +++ b/scripts/test_idempotency_failover.py @@ -0,0 +1,66 @@ +import requests +import uuid +import base64 +from concurrent.futures import ThreadPoolExecutor, as_completed + +BASE_URL = "http://localhost:8080" + +def setup_test_data(): + username = f"idem_test_{uuid.uuid4().hex[:8]}" + password = "SecurePassword123!" + + r = requests.post(f"{BASE_URL}/api/v1/users", json={ + "username": username, "display_name": "Test User", "password": password + }) + r.raise_for_status() + + creds = base64.b64encode(f"{username}:{password}".encode()).decode() + r = requests.post(f"{BASE_URL}/api/v1/auth/sessions", headers={"Authorization": f"Basic {creds}"}) + r.raise_for_status() + token = r.json()["token"] + headers = {"Authorization": f"Bearer {token}"} + + r = requests.post(f"{BASE_URL}/api/v1/chats", headers=headers, json={ + "title": "Idempotency Test Chat", + "member_ids": [r.json()["user"]["id"]] + }) + r.raise_for_status() + chat_id = r.json()["id"] + + return headers, chat_id + +def send_message(headers, chat_id, idempotency_key, worker_id): + r = requests.post( + f"{BASE_URL}/api/v1/chats/{chat_id}/messages", + headers={**headers, "Idempotency-Key": idempotency_key}, + json={"text": f"failover test message"} + ) + return r.status_code, r.json().get("id") if r.status_code == 201 else None, r.text + +def main(): + print("Проверка идемпотентности (параллельные запросы с одним ключом)") + headers, chat_id = setup_test_data() + idempotency_key = f"failover-test-key-{uuid.uuid4().hex}" + + print(f"Отправка 5 параллельных запросов с ключом: {idempotency_key}") + + results = [] + with ThreadPoolExecutor(max_workers=5) as executor: + futures = [executor.submit(send_message, headers, chat_id, idempotency_key, i) for i in range(5)] + for future in as_completed(futures): + results.append(future.result()) + + status_codes = [r[0] for r in results] + message_ids = [r[1] for r in results] + + print(f"Полученные статусы: {status_codes}") + print(f"Полученные ID сообщений: {message_ids}") + + if all(code == 201 for code in status_codes) and len(set(message_ids)) == 1: + print(f"PASS: Идемпотентность работает! Создано ровно 1 сообщение (ID: {message_ids[0]}).") + else: + print("FAIL: Ожидалось 5 ответов '201' с одинаковым 'id'.") + print("Детали ответов:", results) + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/src/api/routes/messages/message.py b/src/api/routes/messages/message.py index 3eedf0dd..19d45771 100644 --- a/src/api/routes/messages/message.py +++ b/src/api/routes/messages/message.py @@ -6,7 +6,7 @@ from src.pydantic_valid.message import Message, CreateMessage from src.pydantic_valid.page_response import PageResponse from src.api.dependencies import DbSession, CurrentUser from src.api.repositories.main_repo import Repository -from src.services.idempotency import get_cached, body_hash, save_cached +from src.services.idempotency import check_idempotency, body_hash, save_idempotency from src.utils import generate_id, get_now_iso from datetime import datetime @@ -53,13 +53,16 @@ async def send_message(chat_id: UUID, msg_in: CreateMessage, session: DbSession, detail="chat not found") current_hash = body_hash(msg_in.model_dump()) - cached = await get_cached(str(current_user.id), str(chat_id), idempotency_key) - if cached is not None: - if cached["body_hash"] != current_hash: - raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Idempotency-Key is already using with different body") - else: - return cached["response"] + is_cached, cached_response = await check_idempotency( + str(current_user.id), + str(chat_id), + idempotency_key, + current_hash + ) + + if is_cached: + return cached_response message = await repo.messages.create(chat_id=chat_id, sender_id=current_user.id, @@ -75,7 +78,7 @@ async def send_message(chat_id: UUID, msg_in: CreateMessage, session: DbSession, response_dict = response_data.model_dump() - await save_cached( + await save_idempotency( str(current_user.id), str(chat_id), idempotency_key, diff --git a/src/services/idempotency.py b/src/services/idempotency.py index 464af8b5..4010b39c 100644 --- a/src/services/idempotency.py +++ b/src/services/idempotency.py @@ -1,41 +1,81 @@ import hashlib import json +import asyncio from redis.exceptions import RedisError from src.redis_client import get_redis +from fastapi import HTTPException, status IDEMPOTENCY_PREFIX = "idempotency:" IDEMPOTENCY_TTL = 86400 +LOCK_TIMEOUT = 10 -def _key(user_id: str, chat_id: str, idempotency_key: str) -> str: +def _cache_key(user_id: str, chat_id: str, idempotency_key: str) -> str: return f"{IDEMPOTENCY_PREFIX}{user_id}:{chat_id}:{idempotency_key}" +def _lock_key(user_id: str, chat_id: str, idempotency_key: str) -> str: + return f"{_cache_key(user_id, chat_id, idempotency_key)}:lock" + + def body_hash(body: dict) -> str: canonical = json.dumps(body, sort_keys=True, ensure_ascii=False, separators=(',', ':')) return hashlib.sha256(canonical.encode("utf-8")).hexdigest() -async def get_cached(user_id: str, chat_id: str, idempotency_key: str) -> dict | None: +async def check_idempotency(user_id: str, chat_id: str, idempotency_key: str, current_hash: str) -> dict | None: r = get_redis() if not r: - return None - try: - raw = await r.get(_key(user_id, chat_id, idempotency_key)) - return json.loads(raw) if raw else None - except (RedisError, json.JSONDecodeError): - return None + return False, None + + cache_key = _cache_key(user_id, chat_id, idempotency_key) + lock_key = _lock_key(user_id, chat_id, idempotency_key) + + raw = await r.get(cache_key) + if raw: + cached = json.loads(raw) + if cached["body_hash"] != current_hash: + raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Idempotency-Key already used with different body") + return True, cached["response"] + + lock_acquired = await r.set(lock_key, "1", nx=True, ex=LOCK_TIMEOUT) + + if not lock_acquired: + await asyncio.sleep(0.1) + raw = await r.get(cache_key) + if raw: + cached = json.loads(raw) + if cached["body_hash"] != current_hash: + raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Idempotency-Key already used with different body") + return True, cached["response"] + + raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Concurrent request with same key is being processed") + + raw = await r.get(cache_key) + if raw: + cached = json.loads(raw) + if cached["body_hash"] != current_hash: + await r.delete(lock_key) + raise HTTPException(status_code=status.HTTP_409_CONFLICT, detail="Idempotency-Key already used with different body") + await r.delete(lock_key) + return True, cached["response"] + + return False, None -async def save_cached(user_id: str, chat_id: str, idempotency_key: str, body_h: str, response: dict) -> None: +async def save_idempotency(user_id: str, chat_id: str, idempotency_key: str, current_hash: str, response_data: dict) -> None: r = get_redis() if not r: return + + cache_key = _cache_key(user_id, chat_id, idempotency_key) + lock_key = _lock_key(user_id, chat_id, idempotency_key) + try: await r.setex( - _key(user_id, chat_id, idempotency_key), + cache_key, IDEMPOTENCY_TTL, - json.dumps({"body_hash": body_h, "response": response}) + json.dumps({"body_hash": current_hash, "response": response_data}) ) - except RedisError: - pass + finally: + await r.delete(lock_key)