From d3bb55ba09830e68ac8462ddef7e1972e9e42cf3 Mon Sep 17 00:00:00 2001 From: casablanca Date: Thu, 15 Oct 2026 00:18:02 +0300 Subject: [PATCH 1/7] =?UTF-8?q?=D0=BB=D0=B0=D0=B1=D0=B0=20=D0=BD=D0=B0=203?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- Dockerfile | 25 + REPORT.md | 211 +++++- alembic.ini | 149 ++++ compose.yaml | 111 +++ evidence/compose-status.txt | 7 + evidence/failover.txt | 4 + evidence/idempotency.txt | 5 + evidence/persistence.txt | 3 + evidence/smoke.txt | 2 + infra/nginx.conf | 31 + migrations/README | 1 + migrations/env.py | 50 ++ migrations/script.py.mako | 28 + .../b3a91c0e7d42_message_idempotency.py | 61 ++ .../versions/f7c51e1e945b_initial_schema.py | 110 +++ requirements.txt | 20 + scripts/bootstrap.sh | 28 + scripts/restart.sh | 4 + scripts/stop-one.sh | 14 + src/__init__.py | 0 src/cursor.py | 60 ++ src/database.py | 57 ++ src/errors.py | 12 + src/main.py | 509 ++++++++++++++ src/models.py | 118 ++++ src/repositories.py | 646 ++++++++++++++++++ src/security.py | 16 + src/sessions.py | 87 +++ tests/test_concurrent_idempotency.py | 46 ++ 29 files changed, 2397 insertions(+), 18 deletions(-) create mode 100644 Dockerfile create mode 100644 alembic.ini create mode 100644 compose.yaml create mode 100644 evidence/compose-status.txt create mode 100644 evidence/failover.txt create mode 100644 evidence/idempotency.txt create mode 100644 evidence/persistence.txt create mode 100644 evidence/smoke.txt create mode 100644 infra/nginx.conf create mode 100644 migrations/README create mode 100644 migrations/env.py create mode 100644 migrations/script.py.mako create mode 100644 migrations/versions/b3a91c0e7d42_message_idempotency.py create mode 100644 migrations/versions/f7c51e1e945b_initial_schema.py create mode 100644 requirements.txt create mode 100755 scripts/bootstrap.sh create mode 100755 scripts/restart.sh create mode 100755 scripts/stop-one.sh create mode 100644 src/__init__.py create mode 100644 src/cursor.py create mode 100644 src/database.py create mode 100644 src/errors.py create mode 100644 src/main.py create mode 100644 src/models.py create mode 100644 src/repositories.py create mode 100644 src/security.py create mode 100644 src/sessions.py create mode 100644 tests/test_concurrent_idempotency.py diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 00000000..99aff457 --- /dev/null +++ b/Dockerfile @@ -0,0 +1,25 @@ +FROM python:3.13.15-slim + +ENV PYTHONDONTWRITEBYTECODE=1 +ENV PYTHONUNBUFFERED=1 + +WORKDIR /app + +COPY requirements.txt . + +RUN pip install --no-cache-dir -r requirements.txt + +COPY alembic.ini . +COPY migrations ./migrations +COPY src ./src + +RUN useradd --create-home --uid 10001 appuser + +USER appuser + +EXPOSE 8080 + +HEALTHCHECK --interval=10s --timeout=3s --start-period=5s --retries=3 \ + CMD python -c "import urllib.request; urllib.request.urlopen('http://127.0.0.1:8080/health/ready', timeout=2)" || exit 1 + +CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8080"] \ No newline at end of file diff --git a/REPORT.md b/REPORT.md index c2679005..38eed952 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,37 +1,212 @@ # Отчёт — лабораторная 3 -- Автор, группа: TODO -- Целевая оценка; выбранный трек 5, если нужен: TODO -- Commit/PR: TODO после публикации -- Использованные источники, библиотеки и помощь ИИ: TODO +- Автор, группа: Станислав Травкин, БВТ2304 +- Целевая оценка: 5, выполнение по этапам 3 → 4 → 5 +- Выбранный трек оценки 5: цена масштабирования +- Commit/PR: будет указан после публикации +- Использованные источники: документация Docker Compose, FastAPI, SQLAlchemy, Alembic, PostgreSQL, Redis, Nginx; материалы лабораторной работы +- Помощь ИИ: ChatGPT использовался для обсуждения архитектуры, разработки, отладки и подготовки документации ## Запуск из чистого clone -TODO: версии runtime/образов, prerequisites, команды создания локальных secrets/.env, build, миграций, запуска, ожидания готовности, тестов и остановки. Указать необходимые действия оператора. Не вставлять секреты. Отдельно указать безопасную остановку и команду намеренного удаления учебных данных. +Для запуска необходимы Docker Engine с поддержкой Docker Compose, Git и Python 3.9 или новее. + +Приложение работает в контейнерах. Локальная установка PostgreSQL и Redis не требуется. + +Используемые образы: + +- Python 3.13.15-slim +- PostgreSQL 17.6 +- Redis 8.2.2 +- Nginx 1.29-alpine + +Из корневого каталога проекта выполнить: + +```bash +./scripts/bootstrap.sh +docker compose config --quiet +docker compose up -d --build +docker compose ps -a +``` + +Скрипт `bootstrap.sh` создаёт локальные файлы секретов, если они отсутствуют, и проверяет конфигурацию Compose. Значения существующих секретов не перезаписываются. + +Используются файлы: + +- `secrets/postgres_password` — пароль PostgreSQL +- `secrets/database_url` — строка подключения к PostgreSQL +- `secrets/cache_url` — строка подключения к Redis + +Секреты не должны попадать в Git. + +Миграции Alembic выполняются отдельным сервисом `migrate` перед запуском API. Успешное завершение этого контейнера отображается как `Exited (0)`. + +После запуска обе API-реплики должны иметь статус `healthy`, PostgreSQL и Redis — `healthy`, Nginx — `Up`. + +Единая точка входа: + +`http://localhost:8080` + +Проверки: + +```bash +make check +make validate +make test +make test-persistence ACTION_SCRIPT=./scripts/restart.sh +make test-failover ACTION_SCRIPT=./scripts/stop-one.sh +python3 tests/test_concurrent_idempotency.py +``` + +Для локальных Python-проверок требуется установить зависимости из `requirements-dev.txt`, если они ещё не установлены. + +После failover-теста восстановить реплики: + +```bash +docker compose start api-1 api-2 +``` + +Безопасная остановка стенда с сохранением данных: + +```bash +docker compose down +``` + +Повторный запуск: + +```bash +docker compose up -d --build +``` + +Для намеренного удаления учебных данных и постоянных Docker volumes используется: + +```bash +docker compose down -v +``` + +Последняя команда удаляет данные PostgreSQL и Redis и не применяется при обычном перезапуске. ## Архитектура и решения -TODO: схема процессов/хранилищ, источник истины, транзакционные границы, ограничения. Что перенесено из lab2, что изменено в этой работе. Соответствие переменных из .env.example реальной конфигурации. +Используется Docker Compose со следующими компонентами: + +```text +Client + | + v +Nginx :8080 + | + +---- API-1 :8080 + | + +---- API-2 :8080 + | + +---- PostgreSQL + | + +---- Redis +``` + +Nginx является единой публичной точкой входа. API-реплики не публикуют порты на хосте и доступны через внутреннюю сеть Compose. + +Обе реплики используют одну PostgreSQL и один Redis. + +PostgreSQL хранит постоянные данные приложения и информацию, необходимую для общей идемпотентности отправки сообщений. Redis хранит пользовательские сессии с TTL 3600 секунд. + +В API не используются локальные пользовательские сессии, поэтому запросы одного пользователя могут обслуживаться разными репликами без повторной авторизации. + +Каждая реплика возвращает заголовок `X-Instance-Id`, позволяющий определить обработавший запрос экземпляр. + +Для отправки сообщений используется обязательный `Idempotency-Key`. Повторная отправка с тем же ключом не должна создавать второе сообщение. Согласованность между репликами обеспечивается общим PostgreSQL и транзакционным механизмом идемпотентности. + +Миграции выполняются отдельным контейнером, что исключает одновременный запуск Alembic несколькими API-репликами. + +В Nginx настроены два backend-сервера, таймауты подключения и обработки запросов, а также повторная попытка при отдельных ошибках upstream. + +Из лабораторной 2 перенесены основная реализация API, PostgreSQL, миграции, авторизация и работа с сообщениями. В лабораторной 3 добавлены балансировка, две API-реплики, идентификация экземпляров и общая идемпотентность. + +Файл `.env.example` является шаблоном задания. Фактическая конфигурация контейнеров задаётся в `compose.yaml`; подключения к PostgreSQL и Redis передаются через файлы секретов. ## Доказательства критериев -| Критерий README | Команда/сценарий | Наблюдаемый результат | Файл доказательства | +| Критерий | Команда или сценарий | Наблюдаемый результат | Доказательство | | --- | --- | --- | --- | -| Публичный smoke | make test | TODO | TODO | -| Остальные пункты уровня 3 | TODO | TODO | TODO | -| Все пункты уровня 4, если заявлен | TODO | TODO | TODO | -| Выбранный трек 5, если заявлен | TODO | TODO | TODO | - -TODO: добавить отдельную строку для каждого заявленного критерия. PASS без команды и наблюдения не является доказательством. Проверка инфраструктурного hook требует подтверждения, какие реальные процессы/хранилища перезапущены. +| Публичный smoke | `make test` | PASS | `evidence/smoke.txt` | +| Структура проекта | `make check` | PASS | Вывод проверки | +| OpenAPI | `make validate` | PASS | Вывод проверки | +| Две API-реплики | `docker compose ps -a` | Обе реплики healthy | `evidence/compose-status.txt` | +| Общая сессия | `make test-failover` | Сессия сохраняется после отказа реплики | `evidence/failover.txt` | +| Отказ одной реплики | `make test-failover ACTION_SCRIPT=./scripts/stop-one.sh` | 55 успешных записей, 4 неудачные попытки, первое восстановление за 1,327 с | `evidence/failover.txt` | +| Сохранность данных | `make test-persistence ACTION_SCRIPT=./scripts/restart.sh` | PASS, подтверждённые данные и сессия сохранились | `evidence/persistence.txt` | +| Конкурентная идемпотентность | `python3 tests/test_concurrent_idempotency.py` | 20 запросов, 1 уникальный ID, 1 сообщение в истории | `evidence/idempotency.txt` | +| Запросы через разные реплики | Конкурентный тест | Обнаружены `api-1` и `api-2` | `evidence/idempotency.txt` | +| Остановка каждой реплики | Ручная последовательная проверка | При остановке одной реплики оставшаяся продолжала отвечать HTTP 200 | Результаты ручной проверки | ## Эксперименты и отказы -TODO: гипотеза, hardware/лимиты, версии, объём данных, профиль нагрузки, concurrency/arrival rate, длительность/прогрев, повторы, успешные RPS, ошибки, p50/p95/p99, CPU/RAM. Сохранить raw summary без tokens и объяснить ограничения измерения. +На этапе оценки 3 выполнены функциональные проверки отказоустойчивости, сохранности данных и идемпотентности. -| Воздействие | Что ожидаем | Что наблюдали | Время восстановления / потеря данных | -| --- | --- | --- | --- | -| TODO | TODO | TODO | TODO | +### Отказ API-реплики + +Команда: + +```bash +make test-failover ACTION_SCRIPT=./scripts/stop-one.sh +``` + +Полученные результаты: + +- Наблюдаемых реплик до отказа: 2 +- Успешных записей: 55 +- Неудачных попыток: 4 +- Время до первого успешного восстановления: 1,327 с +- Подтверждённые данные: сохранены +- Существующая сессия: сохранена + +Дополнительно вручную проверена остановка каждой реплики с восстановлением предыдущей. В обоих случаях оставшаяся реплика продолжала обслуживать запросы через Nginx. + +### Сохранность данных + +Команда: + +```bash +make test-persistence ACTION_SCRIPT=./scripts/restart.sh +``` + +Результат: PASS. После перезапуска PostgreSQL, Redis и API подтверждённые данные и существующая сессия остались доступными. + +### Конкурентная идемпотентность + +Команда: + +```bash +python3 tests/test_concurrent_idempotency.py +``` + +Результаты: + +- Параллельных запросов: 20 +- Уникальных идентификаторов сообщений: 1 +- Наблюдаемые реплики: `api-1`, `api-2` +- Совпадающих сообщений в истории: 1 +- Итог: PASS + +Таким образом, конкурентные запросы с одинаковым ключом не создали дублирующих сообщений. + +### Дальнейшие измерения + +Для оценки 4 планируется собрать RPS, количество ошибок, время восстановления, задержки и потребление ресурсов при последовательной остановке каждой реплики и поочерёдном обновлении контейнеров. + +Для оценки 5 выбран трек исследования цены масштабирования. Планируется сравнить 1, 2 и 4 API-реплики при фиксированном общем бюджете CPU/RAM, затем повторить эксперимент с увеличением ресурсов. ## Ограничения и следующие шаги -TODO: какие отказы выдерживаются и какие нет; что не реализовано; где учебное упрощение; какое улучшение подтверждено, а какое пока гипотеза. +Реализована устойчивость к остановке одной API-реплики при сохранении доступности второй. + +PostgreSQL, Redis и Nginx представлены одиночными экземплярами и остаются едиными точками отказа. Отказ этих компонентов не покрывается механизмом переключения API-реплик. + +Проверка повторного запуска выполнена на существующих Docker volumes. Полностью независимый запуск из чистого клона пока не проверялся. + +Время 1,327 с характеризует восстановление, наблюдаемое тестом, а не отдельное измерение времени обнаружения отказа балансировщиком. + +В текущем локальном варианте файловые секреты имеют права чтения, допускающие доступ других локальных пользователей. Для следующего этапа необходимо ограничить доступ к ним без нарушения работы непривилегированных контейнеров. + +Количественные эксперименты с производительностью, rolling update и масштабированием будут проведены при выполнении критериев оценок 4 и 5. \ No newline at end of file diff --git a/alembic.ini b/alembic.ini new file mode 100644 index 00000000..017e41ad --- /dev/null +++ b/alembic.ini @@ -0,0 +1,149 @@ +# A generic, single database configuration. + +[alembic] +# path to migration scripts. +# this is typically a path given in POSIX (e.g. forward slashes) +# format, relative to the token %(here)s which refers to the location of this +# ini file +script_location = %(here)s/migrations + +# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s +# Uncomment the line below if you want the files to be prepended with date and time +# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file +# for all available tokens +# file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s +# Or organize into date-based subdirectories (requires recursive_version_locations = true) +# file_template = %%(year)d/%%(month).2d/%%(day).2d_%%(hour).2d%%(minute).2d_%%(second).2d_%%(rev)s_%%(slug)s + +# sys.path path, will be prepended to sys.path if present. +# defaults to the current working directory. for multiple paths, the path separator +# is defined by "path_separator" below. +prepend_sys_path = . + +# timezone to use when rendering the date within the migration file +# as well as the filename. +# If specified, requires the tzdata library which can be installed by adding +# `alembic[tz]` to the pip requirements. +# string value is passed to ZoneInfo() +# leave blank for localtime +# timezone = + +# max length of characters to apply to the "slug" field +# truncate_slug_length = 40 + +# set to 'true' to run the environment during +# the 'revision' command, regardless of autogenerate +# revision_environment = false + +# set to 'true' to allow .pyc and .pyo files without +# a source .py file to be detected as revisions in the +# versions/ directory +# sourceless = false + +# version location specification; This defaults +# to /versions. When using multiple version +# directories, initial revisions must be specified with --version-path. +# The path separator used here should be the separator specified by "path_separator" +# below. +# version_locations = %(here)s/bar:%(here)s/bat:%(here)s/alembic/versions + +# path_separator; This indicates what character is used to split lists of file +# paths, including version_locations and prepend_sys_path within configparser +# files such as alembic.ini. +# The default rendered in new alembic.ini files is "os", which uses os.pathsep +# to provide os-dependent path splitting. +# +# Note that in order to support legacy alembic.ini files, this default does NOT +# take place if path_separator is not present in alembic.ini. If this +# option is omitted entirely, fallback logic is as follows: +# +# 1. Parsing of the version_locations option falls back to using the legacy +# "version_path_separator" key, which if absent then falls back to the legacy +# behavior of splitting on spaces and/or commas. +# 2. Parsing of the prepend_sys_path option falls back to the legacy +# behavior of splitting on spaces, commas, or colons. +# +# Valid values for path_separator are: +# +# path_separator = : +# path_separator = ; +# path_separator = space +# path_separator = newline +# +# Use os.pathsep. Default configuration used for new projects. +path_separator = os + + +# set to 'true' to search source files recursively +# in each "version_locations" directory +# new in Alembic version 1.10 +# recursive_version_locations = false + +# the output encoding used when revision files +# are written from script.py.mako +# output_encoding = utf-8 + +# database URL. This is consumed by the user-maintained env.py script only. +# other means of configuring database URLs may be customized within the env.py +# file. +sqlalchemy.url = + + +[post_write_hooks] +# post_write_hooks defines scripts or Python functions that are run +# on newly generated revision scripts. See the documentation for further +# detail and examples + +# format using "black" - use the console_scripts runner, against the "black" entrypoint +# hooks = black +# black.type = console_scripts +# black.entrypoint = black +# black.options = -l 79 REVISION_SCRIPT_FILENAME + +# lint with attempts to fix using "ruff" - use the module runner, against the "ruff" module +# hooks = ruff +# ruff.type = module +# ruff.module = ruff +# ruff.options = check --fix REVISION_SCRIPT_FILENAME + +# Alternatively, use the exec runner to execute a binary found on your PATH +# hooks = ruff +# ruff.type = exec +# ruff.executable = ruff +# ruff.options = check --fix REVISION_SCRIPT_FILENAME + +# Logging configuration. This is also consumed by the user-maintained +# env.py script only. +[loggers] +keys = root,sqlalchemy,alembic + +[handlers] +keys = console + +[formatters] +keys = generic + +[logger_root] +level = WARNING +handlers = console +qualname = + +[logger_sqlalchemy] +level = WARNING +handlers = +qualname = sqlalchemy.engine + +[logger_alembic] +level = INFO +handlers = +qualname = alembic + +[handler_console] +class = StreamHandler +args = (sys.stderr,) +level = NOTSET +formatter = generic + +[formatter_generic] +format = %(levelname)-5.5s [%(name)s] %(message)s +datefmt = %H:%M:%S diff --git a/compose.yaml b/compose.yaml new file mode 100644 index 00000000..a91b71ee --- /dev/null +++ b/compose.yaml @@ -0,0 +1,111 @@ +x-api: &api + build: + context: . + dockerfile: Dockerfile + environment: + APP_ENV: lab + SESSION_TTL_SECONDS: 3600 + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + secrets: + - database_url + - cache_url + depends_on: + migrate: + condition: service_completed_successfully + redis: + condition: service_healthy + expose: + - "8080" + restart: unless-stopped + stop_grace_period: 15s + mem_limit: 512m + cpus: 1.0 + +services: + postgres: + image: postgres:17.6 + environment: + POSTGRES_DB: messenger + POSTGRES_USER: lab2 + POSTGRES_PASSWORD_FILE: /run/secrets/postgres_password + secrets: + - postgres_password + volumes: + - postgres_data:/var/lib/postgresql/data + healthcheck: + test: ["CMD-SHELL", "pg_isready -U lab2 -d messenger"] + interval: 5s + timeout: 3s + retries: 10 + restart: unless-stopped + + redis: + image: redis:8.2.2 + command: + - redis-server + - --appendonly + - "yes" + - --appendfsync + - everysec + volumes: + - redis_data:/data + healthcheck: + test: ["CMD", "redis-cli", "ping"] + interval: 5s + timeout: 3s + retries: 10 + restart: unless-stopped + + migrate: + build: + context: . + dockerfile: Dockerfile + command: ["alembic", "upgrade", "head"] + secrets: + - database_url + depends_on: + postgres: + condition: service_healthy + restart: "no" + + api-1: + <<: *api + environment: + APP_ENV: lab + SESSION_TTL_SECONDS: 3600 + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + INSTANCE_ID: api-1 + + api-2: + <<: *api + environment: + APP_ENV: lab + SESSION_TTL_SECONDS: 3600 + DATABASE_URL_FILE: /run/secrets/database_url + CACHE_URL_FILE: /run/secrets/cache_url + INSTANCE_ID: api-2 + + nginx: + image: nginx:1.29-alpine + ports: + - "8080:8080" + volumes: + - ./infra/nginx.conf:/etc/nginx/nginx.conf:ro + depends_on: + - api-1 + - api-2 + restart: unless-stopped + +secrets: + postgres_password: + file: ./secrets/postgres_password + database_url: + file: ./secrets/database_url + cache_url: + file: ./secrets/cache_url + +volumes: + postgres_data: + redis_data: \ No newline at end of file diff --git a/evidence/compose-status.txt b/evidence/compose-status.txt new file mode 100644 index 00000000..c060f47d --- /dev/null +++ b/evidence/compose-status.txt @@ -0,0 +1,7 @@ +NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS +mtusi2026lab3-api-1-1 sha256:c9c8b63333aa74724c05967ab2be710213e8636de9b5563f83c992e68067fe27 "uvicorn src.main:ap…" api-1 44 minutes ago Up 6 minutes (healthy) 8080/tcp +mtusi2026lab3-api-2-1 sha256:2450b84cf4e2e2386916c732dfbf3b345488435830de312062c91953cf46eead "uvicorn src.main:ap…" api-2 44 minutes ago Up 21 minutes (healthy) 8080/tcp +mtusi2026lab3-migrate-1 sha256:e7713bfcd86cf0405a7503aaf1a00e5d3d3b3f0ce2c76d024c41b33e2f16d06e "alembic upgrade head" migrate 44 minutes ago Exited (0) 2 minutes ago +mtusi2026lab3-nginx-1 nginx:1.29-alpine "/docker-entrypoint.…" nginx 44 minutes ago Up 41 minutes 0.0.0.0:8080->8080/tcp, [::]:8080->8080/tcp +mtusi2026lab3-postgres-1 postgres:17.6 "docker-entrypoint.s…" postgres 44 minutes ago Up 27 minutes (healthy) 5432/tcp +mtusi2026lab3-redis-1 redis:8.2.2 "docker-entrypoint.s…" redis 44 minutes ago Up 27 minutes (healthy) 6379/tcp diff --git a/evidence/failover.txt b/evidence/failover.txt new file mode 100644 index 00000000..c385dbb8 --- /dev/null +++ b/evidence/failover.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "./scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 55, "failed_attempts": 4, "first_recovery_seconds": 1.327} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/idempotency.txt b/evidence/idempotency.txt new file mode 100644 index 00000000..4eeff2b6 --- /dev/null +++ b/evidence/idempotency.txt @@ -0,0 +1,5 @@ +Requests: 20 +Unique message IDs: 1 +Instances: ['api-1', 'api-2'] +Messages in history: 1 +PASS: concurrent idempotency across replicas diff --git a/evidence/persistence.txt b/evidence/persistence.txt new file mode 100644 index 00000000..1689fabe --- /dev/null +++ b/evidence/persistence.txt @@ -0,0 +1,3 @@ +python3 tests/resilience.py --mode persistence --action-script "./scripts/restart.sh" --base-url "http://localhost:8080" +Executing explicit persistence hook; hook output suppressed to avoid leaking secrets. +PASS: persistence preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/smoke.txt b/evidence/smoke.txt new file mode 100644 index 00000000..44e41deb --- /dev/null +++ b/evidence/smoke.txt @@ -0,0 +1,2 @@ +python3 tests/smoke.py --base-url "http://localhost:8080" +PASS: lab3 public API scenario; infrastructure and grading evidence remain separate. diff --git a/infra/nginx.conf b/infra/nginx.conf new file mode 100644 index 00000000..0038e997 --- /dev/null +++ b/infra/nginx.conf @@ -0,0 +1,31 @@ +events { + worker_connections 1024; +} + +http { + upstream api_backend { + server api-1:8080 max_fails=1 fail_timeout=5s; + server api-2:8080 max_fails=1 fail_timeout=5s; + } + + server { + listen 8080; + + location / { + proxy_pass http://api_backend; + proxy_http_version 1.1; + + proxy_set_header Host $host; + proxy_set_header X-Real-IP $remote_addr; + proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; + proxy_set_header X-Forwarded-Proto $scheme; + + proxy_connect_timeout 2s; + proxy_read_timeout 10s; + proxy_send_timeout 10s; + + proxy_next_upstream error timeout http_502 http_503 http_504; + proxy_next_upstream_tries 2; + } + } +} \ No newline at end of file diff --git a/migrations/README b/migrations/README new file mode 100644 index 00000000..e0d0858f --- /dev/null +++ b/migrations/README @@ -0,0 +1 @@ +Generic single-database configuration with an async dbapi. \ No newline at end of file diff --git a/migrations/env.py b/migrations/env.py new file mode 100644 index 00000000..7125d778 --- /dev/null +++ b/migrations/env.py @@ -0,0 +1,50 @@ +import asyncio + +from alembic import context +from sqlalchemy import pool +from sqlalchemy.ext.asyncio import async_engine_from_config + + +config = context.config + +DATABASE_URL_FILE = "/run/secrets/database_url" + + +def read_database_url() -> str: + with open(DATABASE_URL_FILE, encoding="utf-8") as file: + return file.read().strip() + + +config.set_main_option("sqlalchemy.url", read_database_url()) + +target_metadata = None + + +def do_run_migrations(connection) -> None: + context.configure( + connection=connection, + target_metadata=target_metadata, + ) + + with context.begin_transaction(): + context.run_migrations() + + +async def run_async_migrations() -> None: + connectable = async_engine_from_config( + config.get_section(config.config_ini_section, {}), + prefix="sqlalchemy.", + poolclass=pool.NullPool, + ) + + async with connectable.connect() as connection: + await connection.run_sync(do_run_migrations) + + await connectable.dispose() + + +def run_migrations_online() -> None: + asyncio.run(run_async_migrations()) + + +run_migrations_online() \ No newline at end of file diff --git a/migrations/script.py.mako b/migrations/script.py.mako new file mode 100644 index 00000000..11016301 --- /dev/null +++ b/migrations/script.py.mako @@ -0,0 +1,28 @@ +"""${message} + +Revision ID: ${up_revision} +Revises: ${down_revision | comma,n} +Create Date: ${create_date} + +""" +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa +${imports if imports else ""} + +# revision identifiers, used by Alembic. +revision: str = ${repr(up_revision)} +down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)} +branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)} +depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)} + + +def upgrade() -> None: + """Upgrade schema.""" + ${upgrades if upgrades else "pass"} + + +def downgrade() -> None: + """Downgrade schema.""" + ${downgrades if downgrades else "pass"} diff --git a/migrations/versions/b3a91c0e7d42_message_idempotency.py b/migrations/versions/b3a91c0e7d42_message_idempotency.py new file mode 100644 index 00000000..1a794894 --- /dev/null +++ b/migrations/versions/b3a91c0e7d42_message_idempotency.py @@ -0,0 +1,61 @@ +"""Message idempotency for lab 3. + +Revision ID: b3a91c0e7d42 +Revises: f7c51e1e945b +""" + +from alembic import op +import sqlalchemy as sa + + +revision = "b3a91c0e7d42" +down_revision = "f7c51e1e945b" +branch_labels = None +depends_on = None + + +def upgrade() -> None: + op.create_table( + "message_idempotency", + sa.Column("user_id", sa.Uuid(), nullable=False), + sa.Column("chat_id", sa.Uuid(), nullable=False), + sa.Column("key", sa.String(length=128), nullable=False), + sa.Column("request_hash", sa.String(length=64), nullable=False), + sa.Column("message_id", sa.Uuid(), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("CURRENT_TIMESTAMP"), + nullable=False, + ), + sa.ForeignKeyConstraint( + ["user_id"], + ["users.id"], + ondelete="CASCADE", + ), + sa.ForeignKeyConstraint( + ["chat_id"], + ["chats.id"], + ondelete="CASCADE", + ), + sa.ForeignKeyConstraint( + ["message_id"], + ["messages.id"], + ondelete="CASCADE", + ), + sa.PrimaryKeyConstraint("user_id", "chat_id", "key"), + ) + + op.create_index( + "ix_message_idempotency_created_at", + "message_idempotency", + ["created_at"], + ) + + +def downgrade() -> None: + op.drop_index( + "ix_message_idempotency_created_at", + table_name="message_idempotency", + ) + op.drop_table("message_idempotency") \ No newline at end of file diff --git a/migrations/versions/f7c51e1e945b_initial_schema.py b/migrations/versions/f7c51e1e945b_initial_schema.py new file mode 100644 index 00000000..5bc1512b --- /dev/null +++ b/migrations/versions/f7c51e1e945b_initial_schema.py @@ -0,0 +1,110 @@ +"""initial schema + +Revision ID: f7c51e1e945b +Revises: +Create Date: 2026-10-07 18:33:37.771593 + +""" + +from typing import Sequence, Union + +from alembic import op +import sqlalchemy as sa + + +# revision identifiers, used by Alembic. +revision: str = "f7c51e1e945b" +down_revision: Union[str, Sequence[str], None] = None +branch_labels: Union[str, Sequence[str], None] = None +depends_on: Union[str, Sequence[str], None] = None + + +def upgrade() -> None: + op.create_table( + "users", + sa.Column("id", sa.Uuid(), nullable=False), + sa.Column("username", sa.String(length=32), nullable=False), + sa.Column("display_name", sa.String(length=100), nullable=False), + sa.Column("password_hash", sa.Text(), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("CURRENT_TIMESTAMP"), + nullable=False, + ), + sa.PrimaryKeyConstraint("id"), + sa.UniqueConstraint("username", name="uq_users_username"), + ) + + op.create_table( + "chats", + sa.Column("id", sa.Uuid(), nullable=False), + sa.Column("title", sa.String(length=100), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("CURRENT_TIMESTAMP"), + nullable=False, + ), + sa.PrimaryKeyConstraint("id"), + ) + + op.create_table( + "chat_members", + sa.Column("chat_id", sa.Uuid(), nullable=False), + sa.Column("user_id", sa.Uuid(), nullable=False), + sa.ForeignKeyConstraint( + ["chat_id"], + ["chats.id"], + ondelete="CASCADE", + ), + sa.ForeignKeyConstraint( + ["user_id"], + ["users.id"], + ondelete="CASCADE", + ), + sa.PrimaryKeyConstraint("chat_id", "user_id"), + ) + + op.create_table( + "messages", + sa.Column("id", sa.Uuid(), nullable=False), + sa.Column("chat_id", sa.Uuid(), nullable=False), + sa.Column("sender_id", sa.Uuid(), nullable=False), + sa.Column("text", sa.String(length=4000), nullable=False), + sa.Column( + "created_at", + sa.DateTime(timezone=True), + server_default=sa.text("CURRENT_TIMESTAMP"), + nullable=False, + ), + sa.ForeignKeyConstraint( + ["chat_id"], + ["chats.id"], + ondelete="CASCADE", + ), + sa.ForeignKeyConstraint( + ["sender_id"], + ["users.id"], + ondelete="RESTRICT", + ), + sa.PrimaryKeyConstraint("id"), + ) + + op.create_index( + "ix_messages_chat_created_id", + "messages", + ["chat_id", "created_at", "id"], + unique=False, + ) + + +def downgrade() -> None: + op.drop_index( + "ix_messages_chat_created_id", + table_name="messages", + ) + op.drop_table("messages") + op.drop_table("chat_members") + op.drop_table("chats") + op.drop_table("users") \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 00000000..2f27f572 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,20 @@ +annotated-doc==0.0.5 +annotated-types==0.8.0 +anyio==4.15.1 +click==8.5.0 +fastapi==0.141.1 +h11==0.16.0 +idna==3.20 +pydantic==2.13.5 +pydantic_core==2.46.5 +starlette==1.7.0 +typing-inspection==0.4.4 +typing_extensions==4.16.0 +uvicorn==0.53.0 +SQLAlchemy==2.1.4 +asyncpg==0.32.0 +alembic==1.20.0 +greenlet==3.5.6 + +argon2-cffi==25.1.0 +redis==7.0.1 diff --git a/scripts/bootstrap.sh b/scripts/bootstrap.sh new file mode 100755 index 00000000..a24b5636 --- /dev/null +++ b/scripts/bootstrap.sh @@ -0,0 +1,28 @@ +#!/usr/bin/env bash +set -euo pipefail + +cd "$(dirname "$0")/.." + +mkdir -p secrets +chmod 700 secrets + +if [[ ! -f secrets/postgres_password ]]; then + python3 -c 'import secrets; print(secrets.token_hex(24))' > secrets/postgres_password +fi + +if [[ ! -f secrets/database_url ]]; then + PASSWORD="$(cat secrets/postgres_password)" + printf 'postgresql+asyncpg://lab2:%s@postgres:5432/messenger\n' "$PASSWORD" > secrets/database_url +fi + +if [[ ! -f secrets/cache_url ]]; then + printf 'redis://redis:6379/0\n' > secrets/cache_url +fi + +chmod 644 secrets/postgres_password secrets/database_url secrets/cache_url + +if [[ ! -f .env ]]; then + cp .env.example .env +fi + +docker compose config --quiet \ No newline at end of file diff --git a/scripts/restart.sh b/scripts/restart.sh new file mode 100755 index 00000000..7ef0d531 --- /dev/null +++ b/scripts/restart.sh @@ -0,0 +1,4 @@ +#!/usr/bin/env bash +set -euo pipefail + +docker compose restart postgres redis api-1 api-2 \ No newline at end of file diff --git a/scripts/stop-one.sh b/scripts/stop-one.sh new file mode 100755 index 00000000..d1e8633b --- /dev/null +++ b/scripts/stop-one.sh @@ -0,0 +1,14 @@ +#!/usr/bin/env bash +set -euo pipefail + +: "${TARGET_INSTANCE_ID:?}" + +case "$TARGET_INSTANCE_ID" in + api-1|api-2) + docker compose stop "$TARGET_INSTANCE_ID" + ;; + *) + echo "Unknown instance: $TARGET_INSTANCE_ID" >&2 + exit 1 + ;; +esac \ No newline at end of file diff --git a/src/__init__.py b/src/__init__.py new file mode 100644 index 00000000..e69de29b diff --git a/src/cursor.py b/src/cursor.py new file mode 100644 index 00000000..16702905 --- /dev/null +++ b/src/cursor.py @@ -0,0 +1,60 @@ +import base64 +import binascii +import json +from datetime import datetime +from uuid import UUID + + +def encode_cursor( + chat_id: UUID, + created_at: datetime, + message_id: UUID, +) -> str: + data = { + "chat_id": str(chat_id), + "created_at": created_at.isoformat(), + "message_id": str(message_id), + } + + raw = json.dumps( + data, + separators=(",", ":"), + ).encode("utf-8") + + return base64.urlsafe_b64encode(raw).decode("ascii") + + +def decode_cursor(cursor: str) -> tuple[UUID, datetime, UUID]: + try: + raw = base64.urlsafe_b64decode(cursor.encode("ascii")) + + data = json.loads(raw.decode("utf-8")) + + if not isinstance(data, dict): + raise ValueError("Invalid cursor") + + if set(data.keys()) != { + "chat_id", + "created_at", + "message_id", + }: + raise ValueError("Invalid cursor") + + chat_id = UUID(data["chat_id"]) + created_at = datetime.fromisoformat(data["created_at"]) + message_id = UUID(data["message_id"]) + + if created_at.tzinfo is None or created_at.utcoffset() is None: + raise ValueError("Invalid cursor") + + return chat_id, created_at, message_id + + except ( + ValueError, + KeyError, + TypeError, + UnicodeError, + binascii.Error, + json.JSONDecodeError, + ) as exc: + raise ValueError("Invalid cursor") from exc \ No newline at end of file diff --git a/src/database.py b/src/database.py new file mode 100644 index 00000000..95b01ffb --- /dev/null +++ b/src/database.py @@ -0,0 +1,57 @@ +from collections.abc import AsyncIterator + +import socket + +from sqlalchemy import text +from sqlalchemy.exc import SQLAlchemyError +from sqlalchemy.ext.asyncio import ( + AsyncSession, + async_sessionmaker, + create_async_engine, +) + + +DATABASE_URL_FILE = "/run/secrets/database_url" + +POOL_SIZE = 5 +MAX_OVERFLOW = 5 +POOL_TIMEOUT_SECONDS = 5 +DB_CONNECT_TIMEOUT_SECONDS = 5 + + +def read_database_url() -> str: + with open(DATABASE_URL_FILE, encoding="utf-8") as file: + return file.read().strip() + + +database_url = read_database_url() + +engine = create_async_engine( + database_url, + pool_size=POOL_SIZE, + max_overflow=MAX_OVERFLOW, + pool_timeout=POOL_TIMEOUT_SECONDS, + connect_args={ + "timeout": DB_CONNECT_TIMEOUT_SECONDS, + }, + pool_pre_ping=True, +) + +SessionFactory = async_sessionmaker( + bind=engine, + expire_on_commit=False, +) + + +async def get_db_session() -> AsyncIterator[AsyncSession]: + async with SessionFactory() as session: + yield session + + +async def ping_database() -> bool: + try: + async with engine.connect() as connection: + await connection.execute(text("SELECT 1")) + return True + except (SQLAlchemyError, OSError): + return False \ No newline at end of file diff --git a/src/errors.py b/src/errors.py new file mode 100644 index 00000000..8b853205 --- /dev/null +++ b/src/errors.py @@ -0,0 +1,12 @@ +class APIError(Exception): + def __init__( + self, + status_code: int, + code: str, + message: str, + headers: dict[str, str] | None = None, + ): + self.status_code = status_code + self.code = code + self.message = message + self.headers = headers \ No newline at end of file diff --git a/src/main.py b/src/main.py new file mode 100644 index 00000000..825bd234 --- /dev/null +++ b/src/main.py @@ -0,0 +1,509 @@ +from datetime import datetime, timedelta, timezone +from uuid import UUID, uuid4 +import socket +import os +import re + +from fastapi import Depends, FastAPI, Request, Header +from fastapi.exceptions import RequestValidationError +from fastapi.responses import JSONResponse +from fastapi.security import ( + HTTPAuthorizationCredentials, + HTTPBasic, + HTTPBasicCredentials, + HTTPBearer, +) +from sqlalchemy.exc import IntegrityError, SQLAlchemyError +from sqlalchemy.ext.asyncio import AsyncSession +from starlette.exceptions import HTTPException as StarletteHTTPException + +from src.database import get_db_session, ping_database +from src.errors import APIError +from src.models import CreateUser, SessionResponse, User, CreateChat, Chat, ChatPage, CreateMessage, Message, MessagePage +from src.repositories import ( + create_chat, + list_chats, + create_user as create_user_in_db, + get_user_by_id, + get_chat_by_id, + get_user_credentials_by_username, + create_message, + get_messages, +) +from src.security import verify_password +from src.sessions import ( + create_session, + delete_session, + get_session_user_id, + ping_session_store, +) + + +app = FastAPI() +INSTANCE_ID = os.getenv("INSTANCE_ID") or str(uuid4()) + +basic_security = HTTPBasic(auto_error=False) +bearer_security = HTTPBearer(auto_error=False) + + +async def get_current_user( + credentials: HTTPAuthorizationCredentials | None = Depends(bearer_security), + session: AsyncSession = Depends(get_db_session), +) -> User: + if credentials is None or credentials.scheme.lower() != "bearer": + raise APIError( + status_code=401, + code="unauthorized", + message="Unauthorized", + headers={ + "WWW-Authenticate": "Bearer", + }, + ) + + user_id = await get_session_user_id(credentials.credentials) + + if user_id is None: + raise APIError( + status_code=401, + code="unauthorized", + message="Unauthorized", + headers={ + "WWW-Authenticate": "Bearer", + }, + ) + + user = await get_user_by_id(session, user_id) + + if user is None: + raise APIError( + status_code=401, + code="unauthorized", + message="Unauthorized", + headers={ + "WWW-Authenticate": "Bearer", + }, + ) + + return user + + +@app.middleware("http") +async def request_middleware(request: Request, call_next): + request_id = str(uuid4()) + request.state.request_id = request_id + + if request.method in {"POST", "PUT", "PATCH"}: + content_type = request.headers.get("content-type") + + if content_type is not None: + media_type = content_type.split(";", 1)[0].strip().lower() + + if media_type != "application/json": + return JSONResponse( + status_code=415, + content={ + "error": { + "code": "unsupported_media_type", + "message": "Unsupported media type", + "request_id": request_id, + } + }, + headers={ + "X-Request-Id": request_id, + "X-Instance-Id": INSTANCE_ID, + }, + ) + + response = await call_next(request) + + response.headers["X-Request-Id"] = request_id + response.headers["X-Instance-Id"] = INSTANCE_ID + + return response + + +@app.exception_handler(RequestValidationError) +async def validation_exception_handler( + request: Request, + exc: RequestValidationError, +): + request_id = request.state.request_id + + return JSONResponse( + status_code=400, + content={ + "error": { + "code": "invalid_request", + "message": "Invalid request", + "request_id": request_id, + } + }, + ) + + +@app.exception_handler(APIError) +async def api_error_handler(request: Request, exc: APIError): + request_id = request.state.request_id + + return JSONResponse( + status_code=exc.status_code, + content={ + "error": { + "code": exc.code, + "message": exc.message, + "request_id": request_id, + } + }, + headers=exc.headers, + ) + + +@app.exception_handler(SQLAlchemyError) +async def database_exception_handler( + request: Request, + exc: SQLAlchemyError, +): + request_id = request.state.request_id + + return JSONResponse( + status_code=503, + content={ + "error": { + "code": "service_unavailable", + "message": "Database unavailable", + "request_id": request_id, + } + }, + ) + + +@app.exception_handler(OSError) +async def database_connection_exception_handler( + request: Request, + exc: OSError, +): + request_id = request.state.request_id + + return JSONResponse( + status_code=503, + content={ + "error": { + "code": "service_unavailable", + "message": "Database unavailable", + "request_id": request_id, + } + }, + ) + + +@app.exception_handler(StarletteHTTPException) +async def http_exception_handler( + request: Request, + exc: StarletteHTTPException, +): + request_id = request.state.request_id + + if exc.status_code == 404: + code = "not_found" + message = "Not found" + else: + code = "invalid_request" + message = "Invalid request" + + return JSONResponse( + status_code=exc.status_code, + content={ + "error": { + "code": code, + "message": message, + "request_id": request_id, + } + }, + headers=exc.headers, + ) + + +@app.exception_handler(Exception) +async def unexpected_exception_handler( + request: Request, + exc: Exception, +): + request_id = request.state.request_id + + return JSONResponse( + status_code=500, + content={ + "error": { + "code": "internal_error", + "message": "Internal server error", + "request_id": request_id, + } + }, + ) + + +@app.get("/health/live") +async def health_live(): + return {"status": "ok"} + + +@app.get("/health/ready") +async def health_ready(): + database_ready = await ping_database() + session_store_ready = await ping_session_store() + + if not database_ready or not session_store_ready: + raise APIError( + status_code=503, + code="service_unavailable", + message="Service dependencies unavailable", + ) + + return {"status": "ok"} + + +@app.post("/api/v1/users", response_model=User, status_code=201) +async def create_user( + data: CreateUser, + session: AsyncSession = Depends(get_db_session), +): + try: + async with session.begin(): + return await create_user_in_db(session, data) + + except IntegrityError as exc: + raise APIError( + status_code=409, + code="conflict", + message="Username already exists", + ) from exc + + +@app.get("/api/v1/users/me", response_model=User) +async def get_me( + current_user: User = Depends(get_current_user), +): + return current_user + + +@app.post( + "/api/v1/auth/sessions", + response_model=SessionResponse, + status_code=201, +) +async def create_auth_session( + credentials: HTTPBasicCredentials | None = Depends(basic_security), + session: AsyncSession = Depends(get_db_session), +): + if credentials is None: + raise APIError( + status_code=401, + code="unauthorized", + message="Unauthorized", + headers={ + "WWW-Authenticate": 'Basic realm="messenger"', + }, + ) + + user_credentials = await get_user_credentials_by_username( + session, + credentials.username, + ) + + if user_credentials is None: + raise APIError( + status_code=401, + code="unauthorized", + message="Unauthorized", + headers={ + "WWW-Authenticate": 'Basic realm="messenger"', + }, + ) + + if not verify_password( + user_credentials.password_hash, + credentials.password, + ): + raise APIError( + status_code=401, + code="unauthorized", + message="Unauthorized", + headers={ + "WWW-Authenticate": 'Basic realm="messenger"', + }, + ) + + user = User( + id=user_credentials.id, + username=user_credentials.username, + display_name=user_credentials.display_name, + created_at=user_credentials.created_at, + ) + + token, ttl = await create_session(user.id) + + expires_at = datetime.now(timezone.utc) + timedelta(seconds=ttl) + + return SessionResponse( + token=token, + token_type="Bearer", + expires_at=expires_at, + user=user, + ) + + +@app.delete( + "/api/v1/auth/sessions/current", + status_code=204, +) +async def delete_current_session( + credentials: HTTPAuthorizationCredentials | None = Depends(bearer_security), + current_user: User = Depends(get_current_user), +): + await delete_session(credentials.credentials) + + +@app.post( + "/api/v1/chats", + response_model=Chat, + status_code=201, +) +async def create_chat_endpoint( + data: CreateChat, + current_user: User = Depends(get_current_user), + session: AsyncSession = Depends(get_db_session), +) -> Chat: + try: + chat = await create_chat( + session=session, + data=data, + current_user_id=current_user.id, + ) + await session.commit() + except Exception: + await session.rollback() + raise + + return chat + + +@app.get( + "/api/v1/chats", + response_model=ChatPage, +) +async def get_chats( + limit: int = 50, + current_user: User = Depends(get_current_user), + session: AsyncSession = Depends(get_db_session), +) -> ChatPage: + if limit < 1 or limit > 100: + raise APIError( + status_code=400, + code="invalid_request", + message="Limit must be between 1 and 100", + ) + + return await list_chats( + session=session, + current_user_id=current_user.id, + limit=limit, + ) + + +@app.get( + "/api/v1/chats/{chat_id}", + response_model=Chat, +) +async def get_chat_endpoint( + chat_id: UUID, + current_user: User = Depends(get_current_user), + session: AsyncSession = Depends(get_db_session), +) -> Chat: + chat = await get_chat_by_id( + session=session, + chat_id=chat_id, + current_user_id=current_user.id, + ) + + if chat is None: + raise APIError( + status_code=404, + code="not_found", + message="Chat not found", + ) + + return chat + + +@app.post( + "/api/v1/chats/{chat_id}/messages", + response_model=Message, + status_code=201, +) +async def create_message_endpoint( + chat_id: UUID, + data: CreateMessage, + idempotency_key: str | None = Header( + default=None, + alias="Idempotency-Key", + ), + current_user: User = Depends(get_current_user), + session: AsyncSession = Depends(get_db_session), +) -> Message: + + if ( + idempotency_key is None + or re.fullmatch( + r"[A-Za-z0-9._:-]{1,128}", + idempotency_key, + ) is None + ): + raise APIError( + status_code=400, + code="invalid_request", + message="Invalid or missing Idempotency-Key", + ) + + try: + message = await create_message( + session=session, + chat_id=chat_id, + current_user_id=current_user.id, + data=data, + idempotency_key=idempotency_key, + ) + + await session.commit() + + except Exception: + await session.rollback() + raise + + return message + + +@app.get( + "/api/v1/chats/{chat_id}/messages", + response_model=MessagePage, +) +async def get_messages_endpoint( + chat_id: UUID, + limit: int = 50, + cursor: str | None = None, + current_user: User = Depends(get_current_user), + session: AsyncSession = Depends(get_db_session), +) -> MessagePage: + if limit < 1 or limit > 100: + raise APIError( + status_code=400, + code="invalid_request", + message="Limit must be between 1 and 100", + ) + + return await get_messages( + session=session, + chat_id=chat_id, + current_user_id=current_user.id, + limit=limit, + cursor=cursor, + ) \ No newline at end of file diff --git a/src/models.py b/src/models.py new file mode 100644 index 00000000..5f2c2991 --- /dev/null +++ b/src/models.py @@ -0,0 +1,118 @@ +from datetime import datetime +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, field_validator + + +class CreateUser(BaseModel): + model_config = ConfigDict(extra="forbid") + + username: str = Field( + min_length=3, + max_length=32, + pattern=r"^[a-z0-9_]+$", + ) + + display_name: str = Field( + min_length=1, + max_length=100, + ) + + password: str = Field( + min_length=12, + max_length=128, + ) + + @field_validator("display_name") + @classmethod + def validate_display_name(cls, value: str) -> str: + if not value.strip(): + raise ValueError("Display name must not be blank") + + return value + + +class User(BaseModel): + id: UUID + username: str + display_name: str + created_at: datetime + + +class SessionResponse(BaseModel): + token: str + token_type: str + expires_at: datetime + user: User + + +class CreateChat(BaseModel): + model_config = ConfigDict(extra="forbid") + + title: str = Field( + min_length=1, + max_length=100, + ) + + member_ids: list[UUID] = Field( + min_length=1, + max_length=100, + ) + + @field_validator("title") + @classmethod + def validate_title(cls, value: str) -> str: + if not value.strip(): + raise ValueError("Chat title must not be blank") + + return value + + @field_validator("member_ids") + @classmethod + def validate_member_ids(cls, value: list[UUID]) -> list[UUID]: + if len(value) != len(set(value)): + raise ValueError("Member IDs must be unique") + + return value + + +class Chat(BaseModel): + id: UUID + title: str + member_ids: list[UUID] + created_at: datetime + + +class ChatPage(BaseModel): + items: list[Chat] + next_cursor: str | None + + +class CreateMessage(BaseModel): + model_config = ConfigDict(extra="forbid") + + text: str = Field( + min_length=1, + max_length=4000, + ) + + @field_validator("text") + @classmethod + def validate_text(cls, value: str) -> str: + if not value.strip(): + raise ValueError("Message text must not be blank") + + return value + + +class Message(BaseModel): + id: UUID + chat_id: UUID + sender_id: UUID + text: str + created_at: datetime + + +class MessagePage(BaseModel): + items: list[Message] + next_cursor: str | None \ No newline at end of file diff --git a/src/repositories.py b/src/repositories.py new file mode 100644 index 00000000..f7b6c335 --- /dev/null +++ b/src/repositories.py @@ -0,0 +1,646 @@ +from uuid import UUID, uuid4 +import hashlib +import json + +from sqlalchemy import text +from sqlalchemy.ext.asyncio import AsyncSession + +from src.models import Chat, ChatPage, CreateChat, CreateUser, User, CreateMessage, Message, MessagePage +from src.security import hash_password +from src.errors import APIError +from src.cursor import decode_cursor, encode_cursor + + +async def create_user( + session: AsyncSession, + data: CreateUser, +) -> User: + user_id = uuid4() + password_hash = hash_password(data.password) + + result = await session.execute( + text( + """ + INSERT INTO users ( + id, + username, + display_name, + password_hash + ) + VALUES ( + :id, + :username, + :display_name, + :password_hash + ) + RETURNING + id, + username, + display_name, + created_at + """ + ), + { + "id": user_id, + "username": data.username, + "display_name": data.display_name, + "password_hash": password_hash, + }, + ) + + row = result.one() + + return User( + id=UUID(str(row.id)), + username=row.username, + display_name=row.display_name, + created_at=row.created_at, + ) + +async def get_user_credentials_by_username( + session: AsyncSession, + username: str, +): + result = await session.execute( + text( + """ + SELECT + id, + username, + display_name, + password_hash, + created_at + FROM users + WHERE username = :username + """ + ), + { + "username": username, + }, + ) + + return result.one_or_none() + + +async def get_user_by_id( + session: AsyncSession, + user_id: UUID, +) -> User | None: + result = await session.execute( + text( + """ + SELECT + id, + username, + display_name, + created_at + FROM users + WHERE id = :user_id + """ + ), + { + "user_id": user_id, + }, + ) + + row = result.one_or_none() + + if row is None: + return None + + return User( + id=UUID(str(row.id)), + username=row.username, + display_name=row.display_name, + created_at=row.created_at, + ) + + +async def create_chat( + session: AsyncSession, + data: CreateChat, + current_user_id: UUID, +) -> Chat: + if current_user_id not in data.member_ids: + raise APIError( + status_code=400, + code="invalid_request", + message="Current user must be a chat member", + ) + + users_result = await session.execute( + text( + """ + SELECT id + FROM users + WHERE id = ANY(:member_ids) + """ + ), + { + "member_ids": data.member_ids, + }, + ) + + existing_user_ids = { + UUID(str(row.id)) + for row in users_result + } + + if existing_user_ids != set(data.member_ids): + raise APIError( + status_code=400, + code="invalid_request", + message="Unknown chat member", + ) + + chat_id = uuid4() + + chat_result = await session.execute( + text( + """ + INSERT INTO chats ( + id, + title + ) + VALUES ( + :id, + :title + ) + RETURNING + id, + title, + created_at + """ + ), + { + "id": chat_id, + "title": data.title, + }, + ) + + chat_row = chat_result.one() + + for member_id in data.member_ids: + await session.execute( + text( + """ + INSERT INTO chat_members ( + chat_id, + user_id + ) + VALUES ( + :chat_id, + :user_id + ) + """ + ), + { + "chat_id": chat_id, + "user_id": member_id, + }, + ) + + return Chat( + id=UUID(str(chat_row.id)), + title=chat_row.title, + member_ids=data.member_ids, + created_at=chat_row.created_at, + ) + + +async def get_chat_by_id( + session: AsyncSession, + chat_id: UUID, + current_user_id: UUID, +) -> Chat | None: + chat_result = await session.execute( + text( + """ + SELECT + c.id, + c.title, + c.created_at + FROM chats AS c + JOIN chat_members AS cm + ON cm.chat_id = c.id + WHERE c.id = :chat_id + AND cm.user_id = :current_user_id + """ + ), + { + "chat_id": chat_id, + "current_user_id": current_user_id, + }, + ) + + chat_row = chat_result.one_or_none() + + if chat_row is None: + return None + + members_result = await session.execute( + text( + """ + SELECT user_id + FROM chat_members + WHERE chat_id = :chat_id + ORDER BY user_id + """ + ), + { + "chat_id": chat_id, + }, + ) + + member_ids = [ + UUID(str(row.user_id)) + for row in members_result + ] + + return Chat( + id=UUID(str(chat_row.id)), + title=chat_row.title, + member_ids=member_ids, + created_at=chat_row.created_at, + ) + + +async def list_chats( + session: AsyncSession, + current_user_id: UUID, + limit: int, +) -> ChatPage: + chats_result = await session.execute( + text( + """ + SELECT + c.id, + c.title, + c.created_at + FROM chats AS c + JOIN chat_members AS cm + ON cm.chat_id = c.id + WHERE cm.user_id = :current_user_id + ORDER BY c.created_at, c.id + LIMIT :limit + """ + ), + { + "current_user_id": current_user_id, + "limit": limit, + }, + ) + + chat_rows = chats_result.all() + + items = [] + + for chat_row in chat_rows: + members_result = await session.execute( + text( + """ + SELECT user_id + FROM chat_members + WHERE chat_id = :chat_id + ORDER BY user_id + """ + ), + { + "chat_id": chat_row.id, + }, + ) + + member_ids = [ + UUID(str(row.user_id)) + for row in members_result + ] + + items.append( + Chat( + id=UUID(str(chat_row.id)), + title=chat_row.title, + member_ids=member_ids, + created_at=chat_row.created_at, + ) + ) + + return ChatPage( + items=items, + next_cursor=None, + ) + + +async def create_message( + session: AsyncSession, + chat_id: UUID, + current_user_id: UUID, + data: CreateMessage, + idempotency_key: str, +) -> Message: + membership_result = await session.execute( + text(""" + SELECT 1 + FROM chat_members + WHERE chat_id = :chat_id + AND user_id = :user_id + """), + { + "chat_id": chat_id, + "user_id": current_user_id, + }, + ) + + if membership_result.scalar_one_or_none() is None: + raise APIError( + status_code=404, + code="not_found", + message="Chat not found", + ) + + canonical_body = json.dumps( + {"text": data.text}, + sort_keys=True, + ensure_ascii=False, + separators=(",", ":"), + ) + + request_hash = hashlib.sha256( + canonical_body.encode("utf-8") + ).hexdigest() + + scope = ( + f"{current_user_id}:POST:" + f"/api/v1/chats/{chat_id}/messages:" + f"{idempotency_key}" + ) + + await session.execute( + text(""" + SELECT pg_advisory_xact_lock( + hashtextextended(:scope, 0) + ) + """), + {"scope": scope}, + ) + + await session.execute( + text(""" + DELETE FROM message_idempotency + WHERE user_id = :user_id + AND chat_id = :chat_id + AND key = :key + AND created_at <= + clock_timestamp() - INTERVAL '24 hours' + """), + { + "user_id": current_user_id, + "chat_id": chat_id, + "key": idempotency_key, + }, + ) + + existing_result = await session.execute( + text(""" + SELECT + i.request_hash, + m.id, + m.chat_id, + m.sender_id, + m.text, + m.created_at + FROM message_idempotency AS i + JOIN messages AS m + ON m.id = i.message_id + WHERE i.user_id = :user_id + AND i.chat_id = :chat_id + AND i.key = :key + """), + { + "user_id": current_user_id, + "chat_id": chat_id, + "key": idempotency_key, + }, + ) + + existing = existing_result.one_or_none() + + if existing is not None: + if existing.request_hash != request_hash: + raise APIError( + status_code=409, + code="conflict", + message=( + "Idempotency key already used " + "with different request body" + ), + ) + + return Message( + id=UUID(str(existing.id)), + chat_id=UUID(str(existing.chat_id)), + sender_id=UUID(str(existing.sender_id)), + text=existing.text, + created_at=existing.created_at, + ) + + message_id = uuid4() + + message_result = await session.execute( + text(""" + INSERT INTO messages ( + id, + chat_id, + sender_id, + text + ) + VALUES ( + :id, + :chat_id, + :sender_id, + :text + ) + RETURNING + id, + chat_id, + sender_id, + text, + created_at + """), + { + "id": message_id, + "chat_id": chat_id, + "sender_id": current_user_id, + "text": data.text, + }, + ) + + row = message_result.one() + + await session.execute( + text(""" + INSERT INTO message_idempotency ( + user_id, + chat_id, + key, + request_hash, + message_id + ) + VALUES ( + :user_id, + :chat_id, + :key, + :request_hash, + :message_id + ) + """), + { + "user_id": current_user_id, + "chat_id": chat_id, + "key": idempotency_key, + "request_hash": request_hash, + "message_id": message_id, + }, + ) + + return Message( + id=UUID(str(row.id)), + chat_id=UUID(str(row.chat_id)), + sender_id=UUID(str(row.sender_id)), + text=row.text, + created_at=row.created_at, + ) + + +async def get_messages( + session: AsyncSession, + chat_id: UUID, + current_user_id: UUID, + limit: int, + cursor: str | None, +) -> MessagePage: + membership_result = await session.execute( + text( + """ + SELECT 1 + FROM chat_members + WHERE chat_id = :chat_id + AND user_id = :current_user_id + """ + ), + { + "chat_id": chat_id, + "current_user_id": current_user_id, + }, + ) + + if membership_result.scalar_one_or_none() is None: + raise APIError( + status_code=404, + code="not_found", + message="Chat not found", + ) + + cursor_created_at = None + cursor_message_id = None + + if cursor is not None: + try: + ( + cursor_chat_id, + cursor_created_at, + cursor_message_id, + ) = decode_cursor(cursor) + except ValueError: + raise APIError( + status_code=400, + code="invalid_request", + message="Invalid cursor", + ) + + if cursor_chat_id != chat_id: + raise APIError( + status_code=400, + code="invalid_request", + message="Cursor belongs to another chat", + ) + + if cursor is None: + messages_result = await session.execute( + text( + """ + SELECT + id, + chat_id, + sender_id, + text, + created_at + FROM messages + WHERE chat_id = :chat_id + ORDER BY created_at, id + LIMIT :fetch_limit + """ + ), + { + "chat_id": chat_id, + "fetch_limit": limit + 1, + }, + ) + else: + messages_result = await session.execute( + text( + """ + SELECT + id, + chat_id, + sender_id, + text, + created_at + FROM messages + WHERE chat_id = :chat_id + AND (created_at, id) > ( + :cursor_created_at, + :cursor_message_id + ) + ORDER BY created_at, id + LIMIT :fetch_limit + """ + ), + { + "chat_id": chat_id, + "cursor_created_at": cursor_created_at, + "cursor_message_id": cursor_message_id, + "fetch_limit": limit + 1, + }, + ) + + rows = messages_result.all() + + has_more = len(rows) > limit + rows = rows[:limit] + + items = [ + Message( + id=UUID(str(row.id)), + chat_id=UUID(str(row.chat_id)), + sender_id=UUID(str(row.sender_id)), + text=row.text, + created_at=row.created_at, + ) + for row in rows + ] + + next_cursor = None + + if has_more: + last_message = items[-1] + + next_cursor = encode_cursor( + chat_id=chat_id, + created_at=last_message.created_at, + message_id=last_message.id, + ) + + return MessagePage( + items=items, + next_cursor=next_cursor, + ) \ No newline at end of file diff --git a/src/security.py b/src/security.py new file mode 100644 index 00000000..0afbbf1a --- /dev/null +++ b/src/security.py @@ -0,0 +1,16 @@ +from argon2 import PasswordHasher +from argon2.exceptions import VerifyMismatchError + + +password_hasher = PasswordHasher() + + +def hash_password(password: str) -> str: + return password_hasher.hash(password) + + +def verify_password(password_hash: str, password: str) -> bool: + try: + return password_hasher.verify(password_hash, password) + except VerifyMismatchError: + return False \ No newline at end of file diff --git a/src/sessions.py b/src/sessions.py new file mode 100644 index 00000000..45339a25 --- /dev/null +++ b/src/sessions.py @@ -0,0 +1,87 @@ +import os +import secrets +from uuid import UUID + +from redis.asyncio import Redis +from redis.exceptions import RedisError + +from src.errors import APIError + + +CACHE_URL_FILE = "/run/secrets/cache_url" +DEFAULT_SESSION_TTL_SECONDS = 3600 + + +def read_cache_url() -> str: + with open(CACHE_URL_FILE, encoding="utf-8") as file: + return file.read().strip() + + +def get_session_ttl_seconds() -> int: + return int( + os.getenv( + "SESSION_TTL_SECONDS", + str(DEFAULT_SESSION_TTL_SECONDS), + ) + ) + + +redis_client = Redis.from_url( + read_cache_url(), + decode_responses=True, + socket_connect_timeout=5, + socket_timeout=5, +) + + +def session_store_unavailable() -> APIError: + return APIError( + status_code=503, + code="service_unavailable", + message="Session store unavailable", + ) + + +async def create_session(user_id: UUID) -> tuple[str, int]: + token = secrets.token_urlsafe(32) + ttl = get_session_ttl_seconds() + + try: + await redis_client.set( + f"session:{token}", + str(user_id), + ex=ttl, + ) + except RedisError as exc: + raise session_store_unavailable() from exc + + return token, ttl + + +async def get_session_user_id(token: str) -> UUID | None: + try: + value = await redis_client.get(f"session:{token}") + except RedisError as exc: + raise session_store_unavailable() from exc + + if value is None: + return None + + try: + return UUID(value) + except ValueError: + return None + + +async def delete_session(token: str) -> None: + try: + await redis_client.delete(f"session:{token}") + except RedisError as exc: + raise session_store_unavailable() from exc + + +async def ping_session_store() -> bool: + try: + return bool(await redis_client.ping()) + except RedisError: + return False \ No newline at end of file diff --git a/tests/test_concurrent_idempotency.py b/tests/test_concurrent_idempotency.py new file mode 100644 index 00000000..945eb2f5 --- /dev/null +++ b/tests/test_concurrent_idempotency.py @@ -0,0 +1,46 @@ +import concurrent.futures +import uuid + +from client import Client, check + + +def main(): + client = Client("http://localhost:8080") + alice, bob, eve, chat = client.bootstrap() + + key = uuid.uuid4().hex + text = "Concurrent idempotency " + key + + def send(_): + return client.message(alice, chat, text, key=key) + + with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor: + results = list(executor.map(send, range(20))) + + message_ids = {result["json"]["id"] for result in results} + instances = {result["headers"]["X-Instance-Id"] for result in results} + + page = client.call( + "GET", + "/api/v1/chats/" + chat["id"] + "/messages?limit=100", + actor=alice, + schema="MessagePage", + )["json"] + + matches = [message for message in page["items"] if message["text"] == text] + + print("Requests:", len(results)) + print("Unique message IDs:", len(message_ids)) + print("Instances:", sorted(instances)) + print("Messages in history:", len(matches)) + + check(len(message_ids) == 1, "duplicate message IDs returned") + check(len(instances) >= 2, "requests did not reach both replicas") + check(len(matches) == 1, "duplicate messages found in history") + check(matches[0]["id"] in message_ids, "history message ID differs") + + print("PASS: concurrent idempotency across replicas") + + +if __name__ == "__main__": + main() \ No newline at end of file -- 2.54.0 From 666c13cd5af128c3ed043b37f60469ff5a4789bb Mon Sep 17 00:00:00 2001 From: casablanca Date: Thu, 15 Oct 2026 01:15:29 +0300 Subject: [PATCH 2/7] =?UTF-8?q?=D0=BB=D0=B0=D0=B1=D0=B0=20=D0=BD=D0=B0=204?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 345 ++++++++++++++++-- evidence/failover-concurrent-idempotency.txt | 8 + evidence/failover-grade4-api1.txt | 4 + evidence/failover-grade4-second.txt | 4 + evidence/load-baseline.json | 17 + evidence/load-failover-api1.json | 17 + evidence/load-failover-api2.json | 17 + evidence/load-rolling.json | 17 + infra/nginx.conf | 9 +- scripts/bootstrap.sh | 1 + src/main.py | 13 +- tests/test_failover_concurrent_idempotency.py | 80 ++++ 12 files changed, 498 insertions(+), 34 deletions(-) create mode 100644 evidence/failover-concurrent-idempotency.txt create mode 100644 evidence/failover-grade4-api1.txt create mode 100644 evidence/failover-grade4-second.txt create mode 100644 evidence/load-baseline.json create mode 100644 evidence/load-failover-api1.json create mode 100644 evidence/load-failover-api2.json create mode 100644 evidence/load-rolling.json create mode 100644 tests/test_failover_concurrent_idempotency.py diff --git a/REPORT.md b/REPORT.md index 38eed952..4e4c7bc3 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,7 +1,9 @@ + # Отчёт — лабораторная 3 - Автор, группа: Станислав Травкин, БВТ2304 - Целевая оценка: 5, выполнение по этапам 3 → 4 → 5 +- Текущий этап: реализация и проверка критериев оценок 3 и 4 - Выбранный трек оценки 5: цена масштабирования - Commit/PR: будет указан после публикации - Использованные источники: документация Docker Compose, FastAPI, SQLAlchemy, Alembic, PostgreSQL, Redis, Nginx; материалы лабораторной работы @@ -37,9 +39,9 @@ docker compose ps -a - `secrets/database_url` — строка подключения к PostgreSQL - `secrets/cache_url` — строка подключения к Redis -Секреты не должны попадать в Git. +Секреты исключены из Git. -Миграции Alembic выполняются отдельным сервисом `migrate` перед запуском API. Успешное завершение этого контейнера отображается как `Exited (0)`. +Миграции Alembic выполняются отдельным сервисом `migrate` перед запуском API. Успешное завершение контейнера миграций отображается как `Exited (0)`. После запуска обе API-реплики должны иметь статус `healthy`, PostgreSQL и Redis — `healthy`, Nginx — `Up`. @@ -47,7 +49,7 @@ docker compose ps -a `http://localhost:8080` -Проверки: +Основные проверки: ```bash make check @@ -56,11 +58,12 @@ make test make test-persistence ACTION_SCRIPT=./scripts/restart.sh make test-failover ACTION_SCRIPT=./scripts/stop-one.sh python3 tests/test_concurrent_idempotency.py +python3 tests/test_failover_concurrent_idempotency.py ``` Для локальных Python-проверок требуется установить зависимости из `requirements-dev.txt`, если они ещё не установлены. -После failover-теста восстановить реплики: +После failover-тестов восстановить реплики: ```bash docker compose start api-1 api-2 @@ -99,10 +102,10 @@ Nginx :8080 +---- API-1 :8080 | +---- API-2 :8080 - | - +---- PostgreSQL - | - +---- Redis + | + +---- PostgreSQL + | + +---- Redis ``` Nginx является единой публичной точкой входа. API-реплики не публикуют порты на хосте и доступны через внутреннюю сеть Compose. @@ -115,16 +118,73 @@ PostgreSQL хранит постоянные данные приложения Каждая реплика возвращает заголовок `X-Instance-Id`, позволяющий определить обработавший запрос экземпляр. -Для отправки сообщений используется обязательный `Idempotency-Key`. Повторная отправка с тем же ключом не должна создавать второе сообщение. Согласованность между репликами обеспечивается общим PostgreSQL и транзакционным механизмом идемпотентности. +Для отправки сообщений используется обязательный `Idempotency-Key`. Повторная отправка с тем же ключом не должна создавать второе сообщение. Согласованность между репликами обеспечивается общим PostgreSQL, транзакциями и механизмом advisory locks. Миграции выполняются отдельным контейнером, что исключает одновременный запуск Alembic несколькими API-репликами. -В Nginx настроены два backend-сервера, таймауты подключения и обработки запросов, а также повторная попытка при отдельных ошибках upstream. +В Nginx настроены два backend-сервера, динамическое разрешение DNS-имён контейнеров через Docker DNS, таймауты подключения и обработки запросов, а также повторная попытка при отдельных ошибках upstream. Из лабораторной 2 перенесены основная реализация API, PostgreSQL, миграции, авторизация и работа с сообщениями. В лабораторной 3 добавлены балансировка, две API-реплики, идентификация экземпляров и общая идемпотентность. Файл `.env.example` является шаблоном задания. Фактическая конфигурация контейнеров задаётся в `compose.yaml`; подключения к PostgreSQL и Redis передаются через файлы секретов. +### Проверки работоспособности и готовности + +В приложении реализованы два endpoint: + +- `GET /health/live` — проверяет работоспособность процесса API. +- `GET /health/ready` — проверяет доступность PostgreSQL и Redis. + +При недоступности необходимой зависимости `/health/ready` возвращает HTTP 503. + +Для API также настроен Docker HEALTHCHECK, обращающийся к `/health/ready`. + +Это позволяет различать работающий процесс и экземпляр, готовый обслуживать запросы. + +### Таймауты и завершение работы + +Для подключения к PostgreSQL и Redis заданы ограничения времени ожидания. В Nginx настроены таймауты подключения, чтения и отправки запросов. + +Для API установлен `stop_grace_period: 15s`. + +При получении SIGTERM сервер Uvicorn завершает приложение штатно. В обработчике lifespan закрываются клиент Redis и пул соединений SQLAlchemy. + +При ручной остановке `api-1` в логах наблюдались сообщения об успешном завершении приложения и серверного процесса. + +### Ограничения ресурсов + +Для каждой API-реплики заданы ограничения: + +- CPU: 1 +- RAM: 512 MiB + +Проверка через `docker inspect` подтвердила: + +- `NanoCpus = 1000000000` +- `Memory = 536870912` +- `StopTimeout = 15` + +Ограничения применяются к каждой реплике отдельно. При изменении количества реплик суммарный ресурсный бюджет также изменяется, если не корректировать лимиты. + +Для исследования цены масштабирования на оценку 5 потребуется зафиксировать общий бюджет CPU/RAM для сравниваемых конфигураций. + +### Секреты и сетевой доступ + +API запускается от непривилегированного пользователя `appuser` с UID 10001. PostgreSQL использует пользователя `postgres` с UID 999. + +API, PostgreSQL и Redis не публикуют порты на хосте. Внешний порт `8080` опубликован только у Nginx. + +Секреты хранятся в локальном каталоге `secrets/`, исключённом из Git. + +Скрипт `bootstrap.sh` устанавливает права: + +- `700` для каталога `secrets/` +- `644` для файлов секретов + +Каталог недоступен другим обычным пользователям хоста. При этом файлы с правами `644` после монтирования в контейнер доступны для чтения согласно правам файловой системы. + +Это ограничение выбранной схемы Docker Compose с файловыми bind mounts. Для более строгой изоляции секретов необходим другой способ их предоставления контейнерам. + ## Доказательства критериев | Критерий | Команда или сценарий | Наблюдаемый результат | Доказательство | @@ -134,17 +194,23 @@ PostgreSQL хранит постоянные данные приложения | OpenAPI | `make validate` | PASS | Вывод проверки | | Две API-реплики | `docker compose ps -a` | Обе реплики healthy | `evidence/compose-status.txt` | | Общая сессия | `make test-failover` | Сессия сохраняется после отказа реплики | `evidence/failover.txt` | -| Отказ одной реплики | `make test-failover ACTION_SCRIPT=./scripts/stop-one.sh` | 55 успешных записей, 4 неудачные попытки, первое восстановление за 1,327 с | `evidence/failover.txt` | -| Сохранность данных | `make test-persistence ACTION_SCRIPT=./scripts/restart.sh` | PASS, подтверждённые данные и сессия сохранились | `evidence/persistence.txt` | +| Отказ реплики на оценку 3 | `make test-failover ACTION_SCRIPT=./scripts/stop-one.sh` | 55 успешных записей, 4 неудачные попытки, восстановление за 1,327 с | `evidence/failover.txt` | +| Сохранность данных | `make test-persistence ACTION_SCRIPT=./scripts/restart.sh` | PASS | `evidence/persistence.txt` | | Конкурентная идемпотентность | `python3 tests/test_concurrent_idempotency.py` | 20 запросов, 1 уникальный ID, 1 сообщение в истории | `evidence/idempotency.txt` | -| Запросы через разные реплики | Конкурентный тест | Обнаружены `api-1` и `api-2` | `evidence/idempotency.txt` | -| Остановка каждой реплики | Ручная последовательная проверка | При остановке одной реплики оставшаяся продолжала отвечать HTTP 200 | Результаты ручной проверки | +| Базовая нагрузка | `tests/load.py`, 30 с, 8 клиентов | 199,148 RPS, 0 ошибок | `evidence/load-baseline.json` | +| Остановка `api-1` под нагрузкой | `tests/load.py`, 45 с, 8 клиентов | 130,833 RPS, 0 ошибок | `evidence/load-failover-api1.json` | +| Остановка `api-2` под нагрузкой | `tests/load.py`, 45 с, 8 клиентов | 133,351 RPS, 0 ошибок | `evidence/load-failover-api2.json` | +| Failover `api-1` | `make test-failover` | PASS, восстановление за 1,311 с | `evidence/failover-grade4-api1.txt` | +| Failover `api-2` | `make test-failover` | PASS, восстановление за 1,339 с | `evidence/failover-grade4-second.txt` | +| Идемпотентность при отказе | `python3 tests/test_failover_concurrent_idempotency.py` | 20 запросов, 1 сообщение, PASS | `evidence/failover-concurrent-idempotency.txt` | +| Rolling replacement | Поочерёдное пересоздание API под нагрузкой | 16927 успешных запросов, 1 ошибка | `evidence/load-rolling.json` | +| Ограничения CPU/RAM | `docker inspect` | 1 CPU и 512 MiB на реплику | Результат проверки | +| Закрытые внутренние порты | `docker compose ps` | На хост опубликован только порт Nginx | Результат проверки | +| Корректное завершение | `docker compose stop api-1` | Штатное завершение Uvicorn | Логи контейнера | ## Эксперименты и отказы -На этапе оценки 3 выполнены функциональные проверки отказоустойчивости, сохранности данных и идемпотентности. - -### Отказ API-реплики +### Оценка 3 — отказ API-реплики Команда: @@ -163,7 +229,7 @@ make test-failover ACTION_SCRIPT=./scripts/stop-one.sh Дополнительно вручную проверена остановка каждой реплики с восстановлением предыдущей. В обоих случаях оставшаяся реплика продолжала обслуживать запросы через Nginx. -### Сохранность данных +### Оценка 3 — сохранность данных Команда: @@ -171,9 +237,11 @@ make test-failover ACTION_SCRIPT=./scripts/stop-one.sh make test-persistence ACTION_SCRIPT=./scripts/restart.sh ``` -Результат: PASS. После перезапуска PostgreSQL, Redis и API подтверждённые данные и существующая сессия остались доступными. +Результат: PASS. -### Конкурентная идемпотентность +После перезапуска PostgreSQL, Redis и API подтверждённые данные и существующая сессия остались доступными. + +### Оценка 3 — конкурентная идемпотентность Команда: @@ -191,22 +259,239 @@ python3 tests/test_concurrent_idempotency.py Таким образом, конкурентные запросы с одинаковым ключом не создали дублирующих сообщений. -### Дальнейшие измерения +### Оценка 4 — базовая нагрузка -Для оценки 4 планируется собрать RPS, количество ошибок, время восстановления, задержки и потребление ресурсов при последовательной остановке каждой реплики и поочерёдном обновлении контейнеров. +Команда: -Для оценки 5 выбран трек исследования цены масштабирования. Планируется сравнить 1, 2 и 4 API-реплики при фиксированном общем бюджете CPU/RAM, затем повторить эксперимент с увеличением ресурсов. +```bash +python3 tests/load.py --duration 30 --concurrency 8 --output evidence/load-baseline.json +``` -## Ограничения и следующие шаги +Результаты: -Реализована устойчивость к остановке одной API-реплики при сохранении доступности второй. +| Показатель | Значение | +| --- | ---: | +| Продолжительность | 30,038 с | +| Успешные запросы | 5982 | +| Ошибки | 0 | +| Пропускная способность | 199,148 RPS | +| p50 | 33,537 мс | +| p95 | 86,622 мс | +| p99 | 201,671 мс | -PostgreSQL, Redis и Nginx представлены одиночными экземплярами и остаются едиными точками отказа. Отказ этих компонентов не покрывается механизмом переключения API-реплик. +Полученные значения используются как базовый ориентир для сравнения с экспериментами при остановке реплик. -Проверка повторного запуска выполнена на существующих Docker volumes. Полностью независимый запуск из чистого клона пока не проверялся. +### Оценка 4 — последовательная остановка реплик под нагрузкой -Время 1,327 с характеризует восстановление, наблюдаемое тестом, а не отдельное измерение времени обнаружения отказа балансировщиком. +Для проверки устойчивости выполнялись отдельные нагрузочные испытания с последовательной остановкой `api-1` и `api-2`. -В текущем локальном варианте файловые секреты имеют права чтения, допускающие доступ других локальных пользователей. Для следующего этапа необходимо ограничить доступ к ним без нарушения работы непривилегированных контейнеров. +В каждом эксперименте нагрузка создавалась восемью параллельными клиентами. Примерно через 10 секунд после начала испытания останавливалась одна из реплик. -Количественные эксперименты с производительностью, rolling update и масштабированием будут проведены при выполнении критериев оценок 4 и 5. \ No newline at end of file +После завершения испытания реплика восстанавливалась перед следующим экспериментом. + +| Сценарий | Продолжительность | Успешные запросы | Ошибки | RPS | p50 | p95 | p99 | +| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: | +| Без отказа | 30,038 с | 5982 | 0 | 199,148 | 33,537 мс | 86,622 мс | 201,671 мс | +| Остановка `api-1` | 45,073 с | 5897 | 0 | 130,833 | 54,133 мс | 112,499 мс | 216,195 мс | +| Остановка `api-2` | 45,084 с | 6012 | 0 | 133,351 | 52,247 мс | 115,109 мс | 208,774 мс | + +Доказательства: + +- `evidence/load-baseline.json` +- `evidence/load-failover-api1.json` +- `evidence/load-failover-api2.json` + +В обоих сценариях остановки приложение продолжило обслуживать запросы через оставшуюся реплику. + +Ошибок в этих двух нагрузочных прогонах не зафиксировано. Пропускная способность была ниже базовой, а задержки увеличились. + +При интерпретации результатов необходимо учитывать различную длительность базового и отказных испытаний, а также возможные колебания производительности тестового окружения. + +### Оценка 4 — проверка восстановления после отказа + +Отдельно выполнен сценарий проверки отказоустойчивости с остановкой каждой реплики. + +Команда: + +```bash +make test-failover ACTION_SCRIPT=./scripts/stop-one.sh +``` + +Для проверки `api-2` использовалась настройка `TARGET_INSTANCE_ID`. + +Результаты: + +| Остановленная реплика | Наблюдаемых реплик до отказа | Успешные записи | Неудачные попытки | Первое восстановление | Итог | +| --- | ---: | ---: | ---: | ---: | --- | +| `api-1` | 2 | 65 | 3 | 1,311 с | PASS | +| `api-2` | 2 | 81 | 2 | 1,339 с | PASS | + +Доказательства: + +- `evidence/failover-grade4-api1.txt` +- `evidence/failover-grade4-second.txt` + +Оба испытания завершились успешно. + +Время восстановления характеризует момент первого успешного запроса, наблюдаемый тестовым клиентом. Оно не является отдельным измерением времени обнаружения отказа балансировщиком. + +Наличие нескольких неудачных попыток показывает, что переключение не было абсолютно бесшовным. + +### Оценка 4 — конкурентная идемпотентность при отказе + +Команда: + +```bash +python3 tests/test_failover_concurrent_idempotency.py +``` + +Тест создаёт 20 конкурентных запросов с одинаковым `Idempotency-Key` и инициирует остановку `api-1`. + +После завершения конкурентных запросов выполняется повторная отправка с тем же ключом и проверяется история сообщений. + +Результаты: + +- Конкурентных запросов: 20 +- Успешных запросов: 20 +- Неудачных запросов: 0 +- Наблюдаемые реплики: `api-1`, `api-2` +- Уникальных ID успешных ответов: 1 +- Сообщений с проверяемым текстом в истории: 1 +- Повторная отправка вернула тот же ID +- Итог: PASS + +Доказательство: + +`evidence/failover-concurrent-idempotency.txt` + +Эксперимент подтвердил, что при конкурентных запросах и инициированной остановке одной реплики не появились дублирующие сообщения. + +Ограничение эксперимента: все 20 запросов завершились успешно. Сам факт одновременного запуска запросов и остановки контейнера не доказывает, что конкретный запрос был прерван непосредственно во время записи в PostgreSQL. + +### Оценка 4 — rolling replacement + +Для проверки обновления без полной остановки сервиса выполнялось последовательное пересоздание API-реплик под постоянной нагрузкой. + +Нагрузочный тест: + +```bash +python3 tests/load.py --duration 90 --concurrency 8 --output evidence/load-rolling.json +``` + +Во время его выполнения поочерёдно запускались команды: + +```bash +docker compose up -d --no-deps --force-recreate api-1 +docker compose up -d --no-deps --force-recreate api-2 +``` + +Между пересозданиями проверялись готовность API и ответы через Nginx. При проверке наблюдались ответы от обеих реплик. + +Nginx, PostgreSQL и Redis во время пересоздания API не перезапускались. + +Результаты: + +| Показатель | Значение | +| --- | ---: | +| Продолжительность | 90,037 с | +| Успешные запросы | 16927 | +| Ошибки | 1 | +| Доля ошибок | Около 0,0059 % | +| Пропускная способность | 188,0 RPS | +| p50 | 33,878 мс | +| p95 | 99,116 мс | +| p99 | 199,301 мс | + +Доказательство: + +`evidence/load-rolling.json` + +Во время последовательного пересоздания реплик сервис в целом оставался доступным, однако зарегистрирована одна ошибка. + +Поэтому результат нельзя характеризовать как обновление с гарантированным отсутствием ошибок. Эксперимент подтверждает возможность поочерёдного обновления при сохранении обслуживания большинства запросов. + +### Оценка 4 — проверка ограничений и завершения + +Проверка Docker показала, что на каждую API-реплику действуют ограничения 1 CPU и 512 MiB RAM. + +При ручной остановке `api-1` контейнер завершился с кодом 0. В логах Uvicorn наблюдалось штатное завершение приложения. + +После восстановления реплика снова получила статус `healthy`. + +Проверка опубликованных портов подтвердила, что на хосте доступен только Nginx на порту 8080. + +API-реплики, PostgreSQL и Redis доступны через внутреннюю сеть Docker Compose. + +### Проверка изолированного окружения + +На этапе оценки 3 дополнительно проводились проверки с отдельным именем проекта Docker Compose и чистыми Docker volumes. + +Функциональные проверки, сохранность данных, отказоустойчивость и конкурентная идемпотентность в таком окружении завершились успешно. + +Это подтверждает воспроизводимость запуска на новом наборе volumes в использованной локальной среде. + +Полностью независимый запуск на другом компьютере из нового клона репозитория отдельно не подтверждён. + +## Ограничения + +PostgreSQL, Redis и Nginx представлены одиночными экземплярами и остаются едиными точками отказа. + +При недоступности PostgreSQL или Redis API может потерять готовность к обслуживанию запросов. Репликация и автоматическое переключение этих компонентов не реализованы. + +Nginx способен перенаправлять запросы на доступную API-реплику, но отдельные запросы во время отказа или обновления всё равно могут завершиться ошибкой. + +Нагрузочный генератор `tests/load.py` создаёт фиксированное число конкурентных клиентов и измеряет успешную пропускную способность и задержки. Он не обеспечивает точное поддержание заданного входящего RPS. + +Поэтому полученные значения характеризуют пропускную способность в выбранном режиме нагрузки, а не максимальную производительность системы при произвольном входящем потоке. + +В нагрузочных результатах отсутствует детальная посекундная разбивка ошибок и задержек. Время восстановления измеряется отдельно тестом отказоустойчивости. + +Секреты хранятся вне Git, но файловая схема Docker Compose с правами `644` не обеспечивает строгой изоляции содержимого от всех процессов, имеющих доступ к смонтированным файлам. + +Испытания проведены в одном локальном окружении. Результаты зависят от характеристик компьютера, Docker, нагрузки и состояния базы данных. + +## Итоги оценки 4 + +Выполнены следующие проверки: + +- Две API-реплики за балансировщиком Nginx. +- Общие PostgreSQL и Redis. +- Общая авторизация и идемпотентность между репликами. +- Проверки `/health/live` и `/health/ready`. +- Таймауты подключения и обработки запросов. +- Корректное завершение приложения при SIGTERM. +- Ограничения CPU и RAM. +- Отсутствие прямой публикации внутренних сервисов. +- Однократное выполнение миграций отдельным контейнером. +- Остановка каждой API-реплики под нагрузкой. +- Проверка времени восстановления после отказа. +- Конкурентная идемпотентность при инициированном отказе. +- Поочерёдное пересоздание реплик под нагрузкой. +- Хранение секретов вне Git. + +Базовая пропускная способность в проведённом испытании составила 199,148 успешного запроса в секунду. + +При остановке одной реплики оставшаяся продолжала обслуживать запросы. В отдельных failover-проверках первое успешное восстановление наблюдалось через 1,311 и 1,339 секунды. + +При rolling replacement зарегистрирована одна ошибка на 16928 попыток. + +Таким образом, реализована и экспериментально проверена устойчивость к отказу одной API-реплики. Полная безошибочность переключения и отсутствие единых точек отказа для всей инфраструктуры не заявляются. + +## Следующий этап — оценка 5 + +Выбран трек «Цена масштабирования». + +Планируется исследовать зависимость производительности приложения от количества API-реплик при фиксированном суммарном бюджете CPU и RAM. + +Для этого необходимо: + +1. Подготовить конфигурации с 1, 2 и 4 API-репликами. +2. Зафиксировать общий ресурсный бюджет для сравниваемых конфигураций. +3. Провести повторяемые нагрузочные испытания. +4. Измерить RPS, задержки и количество ошибок. +5. Определить, при каком количестве реплик рост производительности замедляется или прекращается. +6. Построить график зависимости пропускной способности от числа реплик. +7. Проанализировать влияние общих PostgreSQL и Redis на масштабирование. +8. Предложить и проверить оптимизацию на основании результатов измерений. + +Эксперименты оценки 5 будут оформлены отдельно после завершения и фиксации оценки 4. diff --git a/evidence/failover-concurrent-idempotency.txt b/evidence/failover-concurrent-idempotency.txt new file mode 100644 index 00000000..fb46440e --- /dev/null +++ b/evidence/failover-concurrent-idempotency.txt @@ -0,0 +1,8 @@ +Concurrent requests: 20 +Successful requests: 20 +Failed requests: 0 +Instances: ['api-1', 'api-2'] +Unique successful message IDs: 1 +Messages in history: 1 +Recovered message ID: 926f7a4d-017b-43d3-8ef7-3ce643534af8 +PASS: concurrent idempotency preserved during api-1 failover diff --git a/evidence/failover-grade4-api1.txt b/evidence/failover-grade4-api1.txt new file mode 100644 index 00000000..51166025 --- /dev/null +++ b/evidence/failover-grade4-api1.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "./scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 65, "failed_attempts": 3, "first_recovery_seconds": 1.311} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/failover-grade4-second.txt b/evidence/failover-grade4-second.txt new file mode 100644 index 00000000..31820c45 --- /dev/null +++ b/evidence/failover-grade4-second.txt @@ -0,0 +1,4 @@ +python3 tests/resilience.py --mode failover --action-script "./scripts/stop-one.sh" --base-url "http://localhost:8080" +Executing explicit failover hook; hook output suppressed to avoid leaking secrets. +{"observed_instances_before": 2, "successful_writes": 81, "failed_attempts": 2, "first_recovery_seconds": 1.339} +PASS: failover preserved confirmed data and existing session. Hook scope needs operator evidence. diff --git a/evidence/load-baseline.json b/evidence/load-baseline.json new file mode 100644 index 00000000..0930d08c --- /dev/null +++ b/evidence/load-baseline.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 30.0, + "elapsed_seconds": 30.038, + "concurrency": 8, + "successful_requests": 5982, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 199.148, + "successful_latency_ms": { + "p50": 33.537, + "p95": 86.622, + "p99": 201.671 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-failover-api1.json b/evidence/load-failover-api1.json new file mode 100644 index 00000000..c3fe0979 --- /dev/null +++ b/evidence/load-failover-api1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 45.0, + "elapsed_seconds": 45.073, + "concurrency": 8, + "successful_requests": 5897, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 130.833, + "successful_latency_ms": { + "p50": 54.133, + "p95": 112.499, + "p99": 216.195 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-failover-api2.json b/evidence/load-failover-api2.json new file mode 100644 index 00000000..a7615256 --- /dev/null +++ b/evidence/load-failover-api2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 45.0, + "elapsed_seconds": 45.084, + "concurrency": 8, + "successful_requests": 6012, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 133.351, + "successful_latency_ms": { + "p50": 52.247, + "p95": 115.109, + "p99": 208.774 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/load-rolling.json b/evidence/load-rolling.json new file mode 100644 index 00000000..1f3cd027 --- /dev/null +++ b/evidence/load-rolling.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 90.0, + "elapsed_seconds": 90.037, + "concurrency": 8, + "successful_requests": 16927, + "failed_requests": 1, + "error_ratio": 5.9e-05, + "successful_rps": 188.0, + "successful_latency_ms": { + "p50": 33.878, + "p95": 99.116, + "p99": 199.301 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/infra/nginx.conf b/infra/nginx.conf index 0038e997..e3000e30 100644 --- a/infra/nginx.conf +++ b/infra/nginx.conf @@ -3,9 +3,14 @@ events { } http { + resolver 127.0.0.11 valid=5s ipv6=off; + resolver_timeout 2s; + upstream api_backend { - server api-1:8080 max_fails=1 fail_timeout=5s; - server api-2:8080 max_fails=1 fail_timeout=5s; + zone api_backend 64k; + + server api-1:8080 resolve max_fails=1 fail_timeout=5s; + server api-2:8080 resolve max_fails=1 fail_timeout=5s; } server { diff --git a/scripts/bootstrap.sh b/scripts/bootstrap.sh index a24b5636..33ebc3fe 100755 --- a/scripts/bootstrap.sh +++ b/scripts/bootstrap.sh @@ -5,6 +5,7 @@ cd "$(dirname "$0")/.." mkdir -p secrets chmod 700 secrets +umask 077 if [[ ! -f secrets/postgres_password ]]; then python3 -c 'import secrets; print(secrets.token_hex(24))' > secrets/postgres_password diff --git a/src/main.py b/src/main.py index 825bd234..e68ecc6d 100644 --- a/src/main.py +++ b/src/main.py @@ -16,8 +16,9 @@ from fastapi.security import ( from sqlalchemy.exc import IntegrityError, SQLAlchemyError from sqlalchemy.ext.asyncio import AsyncSession from starlette.exceptions import HTTPException as StarletteHTTPException +from contextlib import asynccontextmanager -from src.database import get_db_session, ping_database +from src.database import engine, get_db_session, ping_database from src.errors import APIError from src.models import CreateUser, SessionResponse, User, CreateChat, Chat, ChatPage, CreateMessage, Message, MessagePage from src.repositories import ( @@ -36,10 +37,18 @@ from src.sessions import ( delete_session, get_session_user_id, ping_session_store, + redis_client, ) -app = FastAPI() +@asynccontextmanager +async def lifespan(app: FastAPI): + yield + await redis_client.aclose() + await engine.dispose() + + +app = FastAPI(lifespan=lifespan) INSTANCE_ID = os.getenv("INSTANCE_ID") or str(uuid4()) basic_security = HTTPBasic(auto_error=False) diff --git a/tests/test_failover_concurrent_idempotency.py b/tests/test_failover_concurrent_idempotency.py new file mode 100644 index 00000000..4a97556c --- /dev/null +++ b/tests/test_failover_concurrent_idempotency.py @@ -0,0 +1,80 @@ + +import concurrent.futures +import subprocess +import threading +import time +import uuid + +from client import Client, Failure, check, run + + +def main(): + client = Client("http://localhost:8080", timeout=5) + alice, bob, eve, chat = client.bootstrap() + + key = uuid.uuid4().hex + text = "Failover concurrent idempotency " + key + start = threading.Event() + + def send(_): + start.wait() + try: + response = client.message(alice, chat, text, key=key) + return response["json"]["id"], response["headers"]["X-Instance-Id"], None + except Failure as exc: + return None, None, str(exc) + + with concurrent.futures.ThreadPoolExecutor(max_workers=20) as executor: + futures = [executor.submit(send, i) for i in range(20)] + + process = subprocess.Popen( + ["docker", "compose", "stop", "api-1"], + stdout=subprocess.DEVNULL, + stderr=subprocess.DEVNULL, + ) + + start.set() + results = [future.result() for future in futures] + code = process.wait(timeout=20) + + check(code == 0, "failed to stop api-1") + + successful_ids = {item[0] for item in results if item[0] is not None} + instances = {item[1] for item in results if item[1] is not None} + failures = [item[2] for item in results if item[2] is not None] + + check(len(successful_ids) <= 1, "different message IDs returned") + + recovered = client.message(alice, chat, text, key=key) + message_id = recovered["json"]["id"] + + check( + not successful_ids or successful_ids == {message_id}, + "message ID changed after failover", + ) + + page = client.call( + "GET", + "/api/v1/chats/" + chat["id"] + "/messages?limit=100", + actor=alice, + schema="MessagePage", + )["json"] + + matches = [message for message in page["items"] if message["text"] == text] + + print("Concurrent requests:", len(results)) + print("Successful requests:", len(results) - len(failures)) + print("Failed requests:", len(failures)) + print("Instances:", sorted(instances)) + print("Unique successful message IDs:", len(successful_ids)) + print("Messages in history:", len(matches)) + print("Recovered message ID:", message_id) + + check(len(matches) == 1, "duplicate messages found in history") + check(matches[0]["id"] == message_id, "history message ID differs") + + print("PASS: concurrent idempotency preserved during api-1 failover") + + +if __name__ == "__main__": + run(main) -- 2.54.0 From b86e566ed74e89e23a6d1ccdec2b902acb7e49d6 Mon Sep 17 00:00:00 2001 From: casablanca Date: Thu, 15 Oct 2026 22:36:15 +0300 Subject: [PATCH 3/7] =?UTF-8?q?=D0=BB=D0=B0=D0=B1=D0=B0=20=D0=BD=D0=B0=205?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 359 +++++++++++++++++- compose.cpu-period.yaml | 21 + compose.scale.yaml | 36 ++ evidence/scale/api-1-cpu-after.txt | 3 + evidence/scale/api-1-cpu-before.txt | 3 + evidence/scale/api-2-cpu-after.txt | 3 + evidence/scale/api-2-cpu-before.txt | 3 + evidence/scale/api-3-cpu-after.txt | 3 + evidence/scale/api-3-cpu-before.txt | 3 + evidence/scale/api-4-cpu-after.txt | 3 + evidence/scale/api-4-cpu-before.txt | 3 + evidence/scale/charts/latency.png | Bin 0 -> 35278 bytes evidence/scale/charts/throughput.png | Bin 0 -> 32820 bytes evidence/scale/replicas-1-c16-repeat.json | 17 + evidence/scale/replicas-1-c16-repeat2.json | 17 + evidence/scale/replicas-1-c16.json | 17 + evidence/scale/replicas-1-c32.json | 17 + evidence/scale/replicas-1-c64.json | 17 + evidence/scale/replicas-1-c8.json | 17 + evidence/scale/replicas-2-c16-repeat.json | 17 + evidence/scale/replicas-2-c16-repeat2.json | 17 + evidence/scale/replicas-2-c16.json | 17 + evidence/scale/replicas-2-c32.json | 17 + evidence/scale/replicas-2-c64.json | 17 + evidence/scale/replicas-2-c8.json | 17 + evidence/scale/replicas-4-c16-cpu1.json | 17 + .../scale/replicas-4-c16-diagnostics.json | 17 + .../replicas-4-c16-period200-repeat.json | 17 + .../replicas-4-c16-period200-repeat2.json | 17 + evidence/scale/replicas-4-c16-period200.json | 17 + evidence/scale/replicas-4-c16-repeat.json | 17 + evidence/scale/replicas-4-c16.json | 17 + evidence/scale/replicas-4-c32.json | 17 + evidence/scale/replicas-4-c64.json | 17 + evidence/scale/replicas-4-c8.json | 17 + infra/scale/nginx-1.conf | 35 ++ infra/scale/nginx-2.conf | 36 ++ infra/scale/nginx-4.conf | 38 ++ scripts/analyze_scale.py | 91 +++++ 39 files changed, 998 insertions(+), 16 deletions(-) create mode 100644 compose.cpu-period.yaml create mode 100644 compose.scale.yaml create mode 100644 evidence/scale/api-1-cpu-after.txt create mode 100644 evidence/scale/api-1-cpu-before.txt create mode 100644 evidence/scale/api-2-cpu-after.txt create mode 100644 evidence/scale/api-2-cpu-before.txt create mode 100644 evidence/scale/api-3-cpu-after.txt create mode 100644 evidence/scale/api-3-cpu-before.txt create mode 100644 evidence/scale/api-4-cpu-after.txt create mode 100644 evidence/scale/api-4-cpu-before.txt create mode 100644 evidence/scale/charts/latency.png create mode 100644 evidence/scale/charts/throughput.png create mode 100644 evidence/scale/replicas-1-c16-repeat.json create mode 100644 evidence/scale/replicas-1-c16-repeat2.json create mode 100644 evidence/scale/replicas-1-c16.json create mode 100644 evidence/scale/replicas-1-c32.json create mode 100644 evidence/scale/replicas-1-c64.json create mode 100644 evidence/scale/replicas-1-c8.json create mode 100644 evidence/scale/replicas-2-c16-repeat.json create mode 100644 evidence/scale/replicas-2-c16-repeat2.json create mode 100644 evidence/scale/replicas-2-c16.json create mode 100644 evidence/scale/replicas-2-c32.json create mode 100644 evidence/scale/replicas-2-c64.json create mode 100644 evidence/scale/replicas-2-c8.json create mode 100644 evidence/scale/replicas-4-c16-cpu1.json create mode 100644 evidence/scale/replicas-4-c16-diagnostics.json create mode 100644 evidence/scale/replicas-4-c16-period200-repeat.json create mode 100644 evidence/scale/replicas-4-c16-period200-repeat2.json create mode 100644 evidence/scale/replicas-4-c16-period200.json create mode 100644 evidence/scale/replicas-4-c16-repeat.json create mode 100644 evidence/scale/replicas-4-c16.json create mode 100644 evidence/scale/replicas-4-c32.json create mode 100644 evidence/scale/replicas-4-c64.json create mode 100644 evidence/scale/replicas-4-c8.json create mode 100644 infra/scale/nginx-1.conf create mode 100644 infra/scale/nginx-2.conf create mode 100644 infra/scale/nginx-4.conf create mode 100644 scripts/analyze_scale.py diff --git a/REPORT.md b/REPORT.md index 4e4c7bc3..58c926e0 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,9 +1,8 @@ - # Отчёт — лабораторная 3 - Автор, группа: Станислав Травкин, БВТ2304 -- Целевая оценка: 5, выполнение по этапам 3 → 4 → 5 -- Текущий этап: реализация и проверка критериев оценок 3 и 4 +- Целевая оценка: 5 +- Текущий этап: реализованы и исследованы критерии оценок 3, 4 и 5; выполняется финальная проверка - Выбранный трек оценки 5: цена масштабирования - Commit/PR: будет указан после публикации - Использованные источники: документация Docker Compose, FastAPI, SQLAlchemy, Alembic, PostgreSQL, Redis, Nginx; материалы лабораторной работы @@ -477,21 +476,349 @@ Nginx способен перенаправлять запросы на дост Таким образом, реализована и экспериментально проверена устойчивость к отказу одной API-реплики. Полная безошибочность переключения и отсутствие единых точек отказа для всей инфраструктуры не заявляются. -## Следующий этап — оценка 5 +## Оценка 5 — исследование цены масштабирования -Выбран трек «Цена масштабирования». +### Цель эксперимента -Планируется исследовать зависимость производительности приложения от количества API-реплик при фиксированном суммарном бюджете CPU и RAM. +Исследовать влияние количества API-реплик на пропускную способность и задержки приложения при фиксированном суммарном бюджете CPU и RAM. -Для этого необходимо: +Сравниваются конфигурации с 1, 2 и 4 API-репликами. PostgreSQL, Redis и Nginx остаются общими компонентами системы. -1. Подготовить конфигурации с 1, 2 и 4 API-репликами. -2. Зафиксировать общий ресурсный бюджет для сравниваемых конфигураций. -3. Провести повторяемые нагрузочные испытания. -4. Измерить RPS, задержки и количество ошибок. -5. Определить, при каком количестве реплик рост производительности замедляется или прекращается. -6. Построить график зависимости пропускной способности от числа реплик. -7. Проанализировать влияние общих PostgreSQL и Redis на масштабирование. -8. Предложить и проверить оптимизацию на основании результатов измерений. +### Методика -Эксперименты оценки 5 будут оформлены отдельно после завершения и фиксации оценки 4. +Для всех конфигураций установлен одинаковый суммарный лимит ресурсов API: 2 CPU и 1024 MiB RAM. + +| API-реплик | CPU на реплику | RAM на реплику | Общий CPU | Общая RAM | +|---|---|---|---|---| +| 1 | 2 | 1024 MiB | 2 | 1024 MiB | +| 2 | 1 | 512 MiB | 2 | 1024 MiB | +| 4 | 0,5 | 256 MiB | 2 | 1024 MiB | + +Конфигурации запускаются с использованием `compose.yaml` и `compose.scale.yaml`. Для каждого количества реплик подготовлена отдельная конфигурация Nginx. + +Нагрузочные испытания выполняются скриптом `tests/load.py`. Генератор использует закрытую модель нагрузки с фиксированным количеством конкурентных клиентов, отправляющих POST-запросы на создание сообщений. Автоматические повторные попытки отсутствуют. + +Первоначально для каждой конфигурации проведены тесты продолжительностью 60 секунд с 8, 16, 32 и 64 конкурентными клиентами. + +Для сравнения воспроизводимости дополнительно выполнены повторные прогоны при 16 клиентах. В итоговом сравнении используются три измерения для каждой конфигурации. + +Измеряются успешные запросы в секунду (RPS), задержки p50, p95, p99 и количество ошибок. + +Исходные результаты сохранены в `evidence/scale/`. Скрипт `scripts/analyze_scale.py` вычисляет агрегированные показатели и формирует графики. + +### Результаты при 16 клиентах + +| API-реплик | RPS, прогон 1 | RPS, прогон 2 | RPS, прогон 3 | Средний RPS | Стандартное отклонение RPS | +|---|---|---|---|---|---| +| 1 | 145,953 | 142,549 | 142,668 | 143,723 | 1,932 | +| 2 | 224,292 | 210,316 | 228,380 | 220,996 | 9,472 | +| 4 | 106,885 | 97,026 | 108,340 | 104,084 | 6,155 | + +Средние значения перцентилей отдельных прогонов: + +| API-реплик | Средний p95 | Средний p99 | Ошибок за три прогона | +|---|---|---|---| +| 1 | 135,946 мс | 158,606 мс | 0 | +| 2 | 129,875 мс | 371,534 мс | 0 | +| 4 | 572,950 мс | 1152,931 мс | 0 | + +При одинаковом суммарном бюджете ресурсов конфигурация с двумя репликами показала наибольшую пропускную способность — 220,996 RPS. + +По сравнению с одной репликой прирост составил около 53,8%. При переходе с двух реплик на четыре пропускная способность, напротив, снизилась примерно на 52,9%. + +При этом минимальное среднее значение p99 наблюдалось у одной реплики. Следовательно, выбор конфигурации зависит не только от максимального RPS, но и от требований к задержкам. + +### Графики + +Пропускная способность при 16 конкурентных клиентах: + +![Пропускная способность](evidence/scale/charts/throughput.png) + +Задержки p95 и p99: + +![Задержки](evidence/scale/charts/latency.png) + +На первом графике столбики погрешности обозначают выборочное стандартное отклонение RPS трёх прогонов. + +На втором графике приведены средние значения перцентилей отдельных прогонов. Они не являются перцентилями объединённой выборки всех запросов. + +### Диагностика ограничений CPU + +Для конфигурации с четырьмя репликами дополнительно исследовано использование CPU. + +Проверка параметров cgroup показала, что каждой реплике установлена квота 50000 микросекунд процессорного времени на период 100000 микросекунд, что соответствует 0,5 CPU. + +Во время отдельного нагрузочного испытания зафиксировано ограничение процессорного времени (CPU throttling). Доля периодов с throttling составила приблизительно: + +| Реплика | Доля периодов с throttling | +|---|---| +| api-1 | 55,0% | +| api-2 | 35,8% | +| api-3 | 41,4% | +| api-4 | 37,8% | + +Во время нагрузки наблюдалось использование CPU около установленного лимита, тогда как потребление памяти составляло примерно 70 MiB на реплику при лимите 256 MiB. + +Это согласуется с предположением о существенном влиянии процессорных ограничений на результаты четырёх реплик. + +### Дополнительный диагностический эксперимент + +Для проверки влияния CPU-квоты проведён отдельный эксперимент с четырьмя репликами и 16 конкурентными клиентами. + +CPU-квота каждой реплики временно увеличена с 0,5 до 1 CPU. Лимит памяти не изменялся. + +При суммарном лимите 4 CPU получены следующие результаты: + +- Успешная пропускная способность: 353,146 RPS. +- p50: 31,047 мс. +- p95: 125,895 мс. +- p99: 300,611 мс. +- Ошибок: 0. + +Это приблизительно на 239,3% выше средней пропускной способности четырёх реплик при суммарном лимите 2 CPU. + +Однако данный эксперимент использовал вдвое больший CPU-бюджет, поэтому его нельзя считать прямым сравнением эффективности масштабирования при одинаковых ресурсах. + +После эксперимента ограничения четырёх реплик были возвращены к 0,5 CPU. + +Результат свидетельствует о чувствительности производительности к доступному процессорному времени, но сам по себе не доказывает, что всё снижение производительности четырёх реплик вызвано исключительно CPU throttling. + +### Ограничения исследования + +Испытания выполнялись в одном локальном окружении. На результаты могли влиять фоновая нагрузка компьютера, планировщик CPU, состояние PostgreSQL и Redis, прогрев системы и накопление данных в базе. + +Для каждой конфигурации при 16 клиентах проведено три прогона. Это позволяет оценить повторяемость результатов, но недостаточно для строгих статистических выводов. + +Генератор использует закрытую модель нагрузки, поэтому результаты зависят от задержек ответов и производительности самого клиента. Возможны coordinated omission и дополнительная нагрузка со стороны генератора. + +PostgreSQL, Redis и Nginx не масштабировались вместе с API. Поэтому эксперимент характеризует масштабирование API при фиксированной общей инфраструктуре. + +Зафиксированы признаки CPU throttling, однако влияние других факторов на снижение производительности четырёх реплик полностью не исключено. + +### Экспериментальная оптимизация CPU-периода + +В качестве дополнительной оптимизации проверено изменение периода CPU-квоты для четырёх API-реплик при неизменном суммарном бюджете ресурсов. + +В исходной конфигурации каждая реплика имела период 100000 мкс и квоту 50000 мкс. В экспериментальной конфигурации период увеличен до 200000 мкс, а квота — до 100000 мкс. В обоих случаях лимит каждой реплики составлял 0,5 CPU, суммарный бюджет — 2 CPU и 1024 MiB RAM. + +Для экспериментальной конфигурации проведено три нагрузочных теста продолжительностью 60 секунд с 16 конкурентными клиентами. + +| Прогон | RPS | p95 | p99 | Ошибок | +|---|---:|---:|---:|---:| +| 1 | 86,649 | 888,403 мс | 1559,440 мс | 1 | +| 2 | 85,505 | 925,831 мс | 1351,136 мс | 0 | +| 3 | 85,683 | 890,303 мс | 1366,728 мс | 0 | +| Среднее | 85,946 | 901,512 мс | 1425,768 мс | — | + +Сравнение со стандартным периодом 100 мс: + +| Метрика | Период 100 мс | Период 200 мс | Изменение | +|---|---:|---:|---:| +| Средний RPS | 104,084 | 85,946 | −17,4% | +| Средний p95 | 572,950 мс | 901,512 мс | +57,3% | +| Средний p99 | 1152,931 мс | 1425,768 мс | +23,7% | +| Ошибок за три прогона | 0 | 1 | — | + +Увеличение CPU-периода не привело к улучшению производительности. Средняя пропускная способность снизилась на 17,4%, а задержки p95 и p99 увеличились. + +Следовательно, предложенная оптимизация оказалась неэффективной в исследованных условиях. При этом результаты не позволяют утверждать, что увеличение CPU-периода всегда ухудшает производительность: вывод относится к данному приложению, окружению и выбранной нагрузке. + +После эксперимента восстановлена стандартная конфигурация с двумя API-репликами. + +Результаты сохранены в `evidence/scale/replicas-4-c16-period200.json`, `evidence/scale/replicas-4-c16-period200-repeat.json` и `evidence/scale/replicas-4-c16-period200-repeat2.json`. + +### Итоговые выводы + +В работе исследована цена горизонтального масштабирования API при фиксированном суммарном бюджете 2 CPU и 1024 MiB RAM. + +При 16 конкурентных клиентах конфигурация с двумя репликами обеспечила максимальную среднюю пропускную способность среди проверенных вариантов — 220,996 RPS. Это приблизительно на 53,8% больше, чем у одной реплики, и на 112,3% больше, чем у четырёх. + +При этом одна реплика показала наименьшую среднюю задержку p99 — 158,606 мс. Следовательно, оптимальный выбор зависит от требований к пропускной способности и задержкам. + +Диагностика четырёх реплик выявила CPU throttling. Дополнительный эксперимент с увеличенным CPU-бюджетом подтвердил чувствительность приложения к доступному процессорному времени, но не позволил однозначно установить единственную причину снижения производительности. + +Попытка оптимизации путём увеличения периода CPU-квоты со 100 до 200 мс при сохранении общего бюджета оказалась неэффективной: RPS снизился на 17,4%. + +По результатам исследования для данной нагрузки выбрана конфигурация с двумя API-репликами по 1 CPU и 512 MiB RAM. Она обеспечивает наибольшую пропускную способность среди проверенных вариантов без увеличения суммарного бюджета ресурсов. + +Таким образом, горизонтальное масштабирование необходимо оценивать экспериментально: увеличение числа реплик само по себе не гарантирует повышения производительности.(.venv) casablanca@CASABLANCA:~/mtuci/high_load_apps/mtusi2026lab3$ + + +## Команды для демонстрации + +Все команды выполняются из корневого каталога проекта. Команды с `docker compose down` останавливают стенд, но без `-v` сохраняют постоянные данные PostgreSQL. Для демонстрации достаточно начать с обычной конфигурации двух реплик. Запуск тестов создаёт учебные записи в базе; повторные измерения на изменившемся состоянии базы могут отличаться от приведённых в отчёте. + +### 1. Подготовка и запуск + +```bash +./scripts/bootstrap.sh +docker compose config --quiet +docker compose up -d --build +docker compose ps -a +``` + +При первом запуске локальных Python-тестов установить зависимости в виртуальное окружение: + +```bash +python3 -m venv .venv +source .venv/bin/activate +python -m pip install -r requirements-dev.txt +``` + +Если `.venv` уже существует и зависимости установлены, повторять создание окружения не нужно. Для проверки миграций и журналов: + +```bash +docker compose ps -a +docker compose logs --tail=50 migrate +docker compose logs --tail=30 api-1 api-2 nginx +``` + +Сервис `migrate` должен завершиться с кодом 0; две реплики API, PostgreSQL и Redis должны быть `healthy`. + +### 2. Проверка API, балансировки и изоляции + +```bash +curl -i http://localhost:8080/health/live +curl -i http://localhost:8080/health/ready +for i in $(seq 1 12); do curl -s -D - -o /dev/null http://localhost:8080/health/live | grep -i '^x-instance-id:'; done +docker compose ps +docker compose port nginx 8080 +``` + +В заголовке `X-Instance-Id` при повторных запросах ожидаются ответы от `api-1` и `api-2`. Порты API, PostgreSQL и Redis на хост не публикуются; точка входа — Nginx на `localhost:8080`. + +Проверка ресурсных ограничений и запуска API от непривилегированного пользователя: + +```bash +for i in 1 2; do docker inspect mtusi2026lab3-api-$i-1 --format '{{.Name}} NanoCpus={{.HostConfig.NanoCpus}} Memory={{.HostConfig.Memory}} StopTimeout={{.HostConfig.StopTimeout}}'; done +docker compose exec -T api-1 id +docker stats --no-stream +``` + +### 3. Функциональные тесты и отказоустойчивость + +```bash +make check +make validate +make test +make test-persistence ACTION_SCRIPT=./scripts/restart.sh +make test-failover ACTION_SCRIPT=./scripts/stop-one.sh +python3 tests/test_concurrent_idempotency.py +python3 tests/test_failover_concurrent_idempotency.py +docker compose start api-1 api-2 +docker compose ps +``` + +Тесты проверяют контракт, сохранность данных, работу сессии при отказе и отсутствие дублирования сообщения при конкурентной отправке с одинаковым `Idempotency-Key`. После сценариев отказа необходимо восстановить обе реплики. + +Для ручного показа остановки одной реплики и восстановления: + +```bash +docker compose stop api-1 +curl -i http://localhost:8080/health/ready +docker compose ps +docker compose start api-1 +docker compose ps +``` + +### 4. Нагрузка и последовательное обновление на оценку 4 + +Базовый нагрузочный тест: + +```bash +python3 tests/load.py --duration 30 --concurrency 8 --output evidence/load-demo.json +``` + +Для демонстрации rolling replacement запустить нагрузку в первом терминале: + +```bash +python3 tests/load.py --duration 90 --concurrency 8 --output evidence/load-rolling-demo.json +``` + +Пока идёт тест, во втором терминале поочерёдно выполнить: + +```bash +docker compose up -d --no-deps --force-recreate api-1 +docker compose ps +docker compose up -d --no-deps --force-recreate api-2 +docker compose ps +``` + +После теста посмотреть JSON-файл с RPS, задержками и ошибками. Пересоздание под нагрузкой не гарантирует нулевое число ошибок: в исходном эксперименте была зафиксирована одна ошибка. + +### 5. Воспроизведение сравнения 1, 2 и 4 реплик на оценку 5 + +Используются `compose.yaml`, `compose.scale.yaml` и конфигурации Nginx в `infra/scale/`. Для каждого варианта общий лимит API одинаков: 2 CPU и 1024 MiB RAM. Переход между вариантами выполняется с остановкой предыдущего стенда. Команды не используют `down -v`, поэтому накопленные данные сохраняются. + +Одна реплика — 2 CPU и 1024 MiB: + +```bash +docker compose -f compose.yaml -f compose.scale.yaml down +API_REPLICAS=1 API_CPUS=2.0 API_MEMORY=1024m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 nginx +docker compose -f compose.yaml -f compose.scale.yaml ps +python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/demo-1-c16.json +``` + +Две реплики — по 1 CPU и 512 MiB: + +```bash +docker compose -f compose.yaml -f compose.scale.yaml down +API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 api-2 nginx +docker compose -f compose.yaml -f compose.scale.yaml ps +python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/demo-2-c16.json +``` + +Четыре реплики — по 0,5 CPU и 256 MiB: + +```bash +docker compose -f compose.yaml -f compose.scale.yaml down +API_REPLICAS=4 API_CPUS=0.5 API_MEMORY=256m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 api-2 api-3 api-4 nginx +docker compose -f compose.yaml -f compose.scale.yaml ps +python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/demo-4-c16.json +``` + +Для демонстрации ограничений четырёх реплик: + +```bash +for i in 1 2 3 4; do docker inspect mtusi2026lab3-api-$i-1 --format '{{.Name}} NanoCpus={{.HostConfig.NanoCpus}} Memory={{.HostConfig.Memory}}'; done +docker stats --no-stream +``` + +Исторические результаты всех прогонов находятся в `evidence/scale/`; графики уже сохранены в `evidence/scale/charts/`. Для повторного формирования графиков: + +```bash +python3 scripts/analyze_scale.py +``` + +Для воспроизведения всех исходных серий вместо `--concurrency 16` последовательно использовать 8, 16, 32 и 64 клиента; для статистического сравнения провести по три прогона при 16 клиентах, сохраняя каждый результат в отдельный JSON-файл. + +### 6. Проверка изменения CPU-периода + +Этот эксперимент проводится на четырёх репликах. Он показал отрицательный результат, поэтому не является рекомендуемой рабочей конфигурацией. Дополнительный файл `compose.cpu-period.yaml` заменяет способ задания лимита CPU: `cpu_period: 200000` и `cpu_quota: 100000` вместо `cpus: 0.5`. Перед запуском убедиться, что файл присутствует в проекте. + +```bash +docker compose -f compose.yaml -f compose.scale.yaml down +API_REPLICAS=4 API_CPUS=0.5 API_MEMORY=256m docker compose -f compose.yaml -f compose.scale.yaml -f compose.cpu-period.yaml config --quiet +API_REPLICAS=4 API_CPUS=0.5 API_MEMORY=256m docker compose -f compose.yaml -f compose.scale.yaml -f compose.cpu-period.yaml up -d --build postgres redis migrate api-1 api-2 api-3 api-4 nginx +for i in 1 2 3 4; do docker inspect mtusi2026lab3-api-$i-1 --format '{{.Name}} NanoCpus={{.HostConfig.NanoCpus}} CpuPeriod={{.HostConfig.CpuPeriod}} CpuQuota={{.HostConfig.CpuQuota}}'; done +python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/demo-4-c16-period200.json +``` + +При корректной конфигурации каждая реплика имеет `NanoCpus=0`, `CpuPeriod=200000`, `CpuQuota=100000`, то есть 0,5 CPU. Для повторения методики выполнить три прогона с разными именами выходных файлов. + +### 7. Возврат к основной конфигурации после демонстрации + +```bash +docker compose -f compose.yaml -f compose.scale.yaml -f compose.cpu-period.yaml down +API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 api-2 nginx +docker compose -f compose.yaml -f compose.scale.yaml ps +curl -i http://localhost:8080/health/ready +``` + +Для обычной остановки без удаления данных: + +```bash +docker compose down +``` + +`docker compose down -v` применять только при намеренном удалении учебной базы и volumes. При защите удобно показать сначала работающие две реплики, затем `X-Instance-Id`, проверки `make`, failover и результаты масштабирования; полные 60-секундные серии можно воспроизвести по приведённым командам при необходимости. diff --git a/compose.cpu-period.yaml b/compose.cpu-period.yaml new file mode 100644 index 00000000..81162246 --- /dev/null +++ b/compose.cpu-period.yaml @@ -0,0 +1,21 @@ + +services: + api-1: + cpus: !reset null + cpu_period: 200000 + cpu_quota: 100000 + + api-2: + cpus: !reset null + cpu_period: 200000 + cpu_quota: 100000 + + api-3: + cpus: !reset null + cpu_period: 200000 + cpu_quota: 100000 + + api-4: + cpus: !reset null + cpu_period: 200000 + cpu_quota: 100000 diff --git a/compose.scale.yaml b/compose.scale.yaml new file mode 100644 index 00000000..eb41db03 --- /dev/null +++ b/compose.scale.yaml @@ -0,0 +1,36 @@ + +services: + api-1: + cpus: ${API_CPUS:-1.0} + mem_limit: ${API_MEMORY:-512m} + + api-2: + cpus: ${API_CPUS:-1.0} + mem_limit: ${API_MEMORY:-512m} + + api-3: + extends: + service: api-1 + file: compose.yaml + environment: + INSTANCE_ID: api-3 + cpus: ${API_CPUS:-1.0} + mem_limit: ${API_MEMORY:-512m} + + api-4: + extends: + service: api-1 + file: compose.yaml + environment: + INSTANCE_ID: api-4 + cpus: ${API_CPUS:-1.0} + mem_limit: ${API_MEMORY:-512m} + + nginx: + volumes: + - ./infra/scale/nginx-${API_REPLICAS:-2}.conf:/etc/nginx/nginx.conf:ro + depends_on: !override + api-1: + condition: service_healthy + + diff --git a/evidence/scale/api-1-cpu-after.txt b/evidence/scale/api-1-cpu-after.txt new file mode 100644 index 00000000..5c2c2f7b --- /dev/null +++ b/evidence/scale/api-1-cpu-after.txt @@ -0,0 +1,3 @@ +nr_periods 8378 +nr_throttled 3207 +throttled_time 270000128500 diff --git a/evidence/scale/api-1-cpu-before.txt b/evidence/scale/api-1-cpu-before.txt new file mode 100644 index 00000000..83d15123 --- /dev/null +++ b/evidence/scale/api-1-cpu-before.txt @@ -0,0 +1,3 @@ +nr_periods 7410 +nr_throttled 2675 +throttled_time 222356681100 diff --git a/evidence/scale/api-2-cpu-after.txt b/evidence/scale/api-2-cpu-after.txt new file mode 100644 index 00000000..7a250c79 --- /dev/null +++ b/evidence/scale/api-2-cpu-after.txt @@ -0,0 +1,3 @@ +nr_periods 8371 +nr_throttled 2898 +throttled_time 237731735800 diff --git a/evidence/scale/api-2-cpu-before.txt b/evidence/scale/api-2-cpu-before.txt new file mode 100644 index 00000000..d1638f3a --- /dev/null +++ b/evidence/scale/api-2-cpu-before.txt @@ -0,0 +1,3 @@ +nr_periods 7403 +nr_throttled 2551 +throttled_time 203403537000 diff --git a/evidence/scale/api-3-cpu-after.txt b/evidence/scale/api-3-cpu-after.txt new file mode 100644 index 00000000..6e1b33d7 --- /dev/null +++ b/evidence/scale/api-3-cpu-after.txt @@ -0,0 +1,3 @@ +nr_periods 8357 +nr_throttled 2976 +throttled_time 242442862500 diff --git a/evidence/scale/api-3-cpu-before.txt b/evidence/scale/api-3-cpu-before.txt new file mode 100644 index 00000000..1ed68b68 --- /dev/null +++ b/evidence/scale/api-3-cpu-before.txt @@ -0,0 +1,3 @@ +nr_periods 7391 +nr_throttled 2576 +throttled_time 209050114200 diff --git a/evidence/scale/api-4-cpu-after.txt b/evidence/scale/api-4-cpu-after.txt new file mode 100644 index 00000000..fb05ada4 --- /dev/null +++ b/evidence/scale/api-4-cpu-after.txt @@ -0,0 +1,3 @@ +nr_periods 8378 +nr_throttled 2920 +throttled_time 235549876300 diff --git a/evidence/scale/api-4-cpu-before.txt b/evidence/scale/api-4-cpu-before.txt new file mode 100644 index 00000000..e45f5c45 --- /dev/null +++ b/evidence/scale/api-4-cpu-before.txt @@ -0,0 +1,3 @@ +nr_periods 7414 +nr_throttled 2556 +throttled_time 203469227700 diff --git a/evidence/scale/charts/latency.png b/evidence/scale/charts/latency.png new file mode 100644 index 0000000000000000000000000000000000000000..945d745bc7334e26c949d31578100b6df68d6835 GIT binary patch literal 35278 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 literal 0 HcmV?d00001 diff --git a/evidence/scale/charts/throughput.png b/evidence/scale/charts/throughput.png new file mode 100644 index 0000000000000000000000000000000000000000..8eea9f5d350ad2924f24b18744e331a32e42663b GIT binary patch literal 32820 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 Date: Thu, 15 Oct 2026 22:50:18 +0300 Subject: [PATCH 4/7] =?UTF-8?q?=D0=98=D1=81=D0=BF=D1=80=D0=B0=D0=B2=D0=BB?= =?UTF-8?q?=D0=B5=D0=BD=20=D0=BA=D0=BE=D0=B4=20=D0=BE=D1=88=D0=B8=D0=B1?= =?UTF-8?q?=D0=BA=D0=B8=20unavailable=20=D0=B8=D0=B7=20pr=20=D0=BB=D0=B0?= =?UTF-8?q?=D0=B1=D1=8B=202?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/main.py | 7 +++---- src/sessions.py | 2 +- 2 files changed, 4 insertions(+), 5 deletions(-) diff --git a/src/main.py b/src/main.py index e68ecc6d..0560594a 100644 --- a/src/main.py +++ b/src/main.py @@ -1,6 +1,5 @@ from datetime import datetime, timedelta, timezone from uuid import UUID, uuid4 -import socket import os import re @@ -178,7 +177,7 @@ async def database_exception_handler( status_code=503, content={ "error": { - "code": "service_unavailable", + "code": "unavailable", "message": "Database unavailable", "request_id": request_id, } @@ -197,7 +196,7 @@ async def database_connection_exception_handler( status_code=503, content={ "error": { - "code": "service_unavailable", + "code": "unavailable", "message": "Database unavailable", "request_id": request_id, } @@ -264,7 +263,7 @@ async def health_ready(): if not database_ready or not session_store_ready: raise APIError( status_code=503, - code="service_unavailable", + code="unavailable", message="Service dependencies unavailable", ) diff --git a/src/sessions.py b/src/sessions.py index 45339a25..6c522cbe 100644 --- a/src/sessions.py +++ b/src/sessions.py @@ -37,7 +37,7 @@ redis_client = Redis.from_url( def session_store_unavailable() -> APIError: return APIError( status_code=503, - code="service_unavailable", + code="unavailable", message="Session store unavailable", ) -- 2.54.0 From 1ed7710973d5c2bc438a318567ae163f8a575f6a Mon Sep 17 00:00:00 2001 From: Stanislav Travkin <23+casablancawastaken@noreply.gitea.privcloud.tech> Date: Fri, 16 Oct 2026 00:52:11 +0300 Subject: [PATCH 5/7] =?UTF-8?q?=D0=9E=D0=B1=D0=BD=D0=BE=D0=B2=D0=B8=D1=82?= =?UTF-8?q?=D1=8C=20REPORT.md?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/REPORT.md b/REPORT.md index 58c926e0..7d9e7489 100644 --- a/REPORT.md +++ b/REPORT.md @@ -641,7 +641,7 @@ PostgreSQL, Redis и Nginx не масштабировались вместе с По результатам исследования для данной нагрузки выбрана конфигурация с двумя API-репликами по 1 CPU и 512 MiB RAM. Она обеспечивает наибольшую пропускную способность среди проверенных вариантов без увеличения суммарного бюджета ресурсов. -Таким образом, горизонтальное масштабирование необходимо оценивать экспериментально: увеличение числа реплик само по себе не гарантирует повышения производительности.(.venv) casablanca@CASABLANCA:~/mtuci/high_load_apps/mtusi2026lab3$ +Таким образом, горизонтальное масштабирование необходимо оценивать экспериментально: увеличение числа реплик само по себе не гарантирует повышения производительности. ## Команды для демонстрации -- 2.54.0 From 8d9dfc2da658b68499c5397992e890e5b8b7f8e0 Mon Sep 17 00:00:00 2001 From: casablanca Date: Thu, 22 Oct 2026 17:18:24 +0300 Subject: [PATCH 6/7] =?UTF-8?q?=D1=84=D0=B8=D0=BA=D1=81=20=D0=B8=D0=B7=20?= =?UTF-8?q?=D0=BF=D1=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 136 +++++++++++++++--- compose.yaml | 10 +- evidence/scale/growing/replicas-1-run1.json | 17 +++ evidence/scale/growing/replicas-1-run2.json | 17 +++ evidence/scale/growing/replicas-1-run3.json | 17 +++ evidence/scale/growing/replicas-1-warmup.json | 17 +++ evidence/scale/growing/replicas-2-run1.json | 17 +++ evidence/scale/growing/replicas-2-run2.json | 17 +++ evidence/scale/growing/replicas-2-run3.json | 17 +++ evidence/scale/growing/replicas-2-warmup.json | 17 +++ evidence/scale/growing/replicas-4-run1.json | 17 +++ evidence/scale/growing/replicas-4-run2.json | 17 +++ evidence/scale/growing/replicas-4-run3.json | 17 +++ evidence/scale/growing/replicas-4-warmup.json | 17 +++ evidence/scale/optimization/after-run1.json | 17 +++ evidence/scale/optimization/after-run2.json | 17 +++ evidence/scale/optimization/after-run3.json | 17 +++ evidence/scale/optimization/after-warmup.json | 17 +++ evidence/scale/optimization/before-run1.json | 17 +++ evidence/scale/optimization/before-run2.json | 17 +++ evidence/scale/optimization/before-run3.json | 17 +++ .../scale/optimization/before-warmup.json | 17 +++ scripts/run_growing_scale.sh | 28 ++++ scripts/run_optimization.sh | 65 +++++++++ scripts/summarize_growing_scale.py | 17 +++ src/cursor.py | 28 +++- src/main.py | 31 ++-- src/repositories.py | 71 +++++---- tests/test_review_regressions.py | 52 +++++++ 29 files changed, 716 insertions(+), 62 deletions(-) create mode 100644 evidence/scale/growing/replicas-1-run1.json create mode 100644 evidence/scale/growing/replicas-1-run2.json create mode 100644 evidence/scale/growing/replicas-1-run3.json create mode 100644 evidence/scale/growing/replicas-1-warmup.json create mode 100644 evidence/scale/growing/replicas-2-run1.json create mode 100644 evidence/scale/growing/replicas-2-run2.json create mode 100644 evidence/scale/growing/replicas-2-run3.json create mode 100644 evidence/scale/growing/replicas-2-warmup.json create mode 100644 evidence/scale/growing/replicas-4-run1.json create mode 100644 evidence/scale/growing/replicas-4-run2.json create mode 100644 evidence/scale/growing/replicas-4-run3.json create mode 100644 evidence/scale/growing/replicas-4-warmup.json create mode 100644 evidence/scale/optimization/after-run1.json create mode 100644 evidence/scale/optimization/after-run2.json create mode 100644 evidence/scale/optimization/after-run3.json create mode 100644 evidence/scale/optimization/after-warmup.json create mode 100644 evidence/scale/optimization/before-run1.json create mode 100644 evidence/scale/optimization/before-run2.json create mode 100644 evidence/scale/optimization/before-run3.json create mode 100644 evidence/scale/optimization/before-warmup.json create mode 100755 scripts/run_growing_scale.sh create mode 100755 scripts/run_optimization.sh create mode 100644 scripts/summarize_growing_scale.py create mode 100644 tests/test_review_regressions.py diff --git a/REPORT.md b/REPORT.md index 7d9e7489..432a67ce 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,8 +1,9 @@ +```` # Отчёт — лабораторная 3 - Автор, группа: Станислав Травкин, БВТ2304 - Целевая оценка: 5 -- Текущий этап: реализованы и исследованы критерии оценок 3, 4 и 5; выполняется финальная проверка +- Текущий этап: реализованы и исследованы критерии оценок 3, 4 и 5; - Выбранный трек оценки 5: цена масштабирования - Commit/PR: будет указан после публикации - Использованные источники: документация Docker Compose, FastAPI, SQLAlchemy, Alembic, PostgreSQL, Redis, Nginx; материалы лабораторной работы @@ -58,6 +59,7 @@ make test-persistence ACTION_SCRIPT=./scripts/restart.sh make test-failover ACTION_SCRIPT=./scripts/stop-one.sh python3 tests/test_concurrent_idempotency.py python3 tests/test_failover_concurrent_idempotency.py +python3 tests/test_review_regressions.py ``` Для локальных Python-проверок требуется установить зависимости из `requirements-dev.txt`, если они ещё не установлены. @@ -152,20 +154,18 @@ PostgreSQL хранит постоянные данные приложения ### Ограничения ресурсов -Для каждой API-реплики заданы ограничения: +В основной конфигурации для каждой API-реплики установлены 1 CPU и 512 MiB RAM. После замечания преподавателя ограничения добавлены также ко всем инфраструктурным сервисам. Фактические значения проверены командой `docker inspect` (поле `HostConfig`): -- CPU: 1 -- RAM: 512 MiB +| Сервис | CPU | RAM | `NanoCpus` | `Memory`, байт | +|---|---:|---:|---:|---:| +| PostgreSQL | 1 | 768 MiB | 1000000000 | 805306368 | +| Redis | 0,5 | 256 MiB | 500000000 | 268435456 | +| Migrate | 1 | 512 MiB | 1000000000 | 536870912 | +| API-1 | 1 | 512 MiB | 1000000000 | 536870912 | +| API-2 | 1 | 512 MiB | 1000000000 | 536870912 | +| Nginx | 0,5 | 256 MiB | 500000000 | 268435456 | -Проверка через `docker inspect` подтвердила: - -- `NanoCpus = 1000000000` -- `Memory = 536870912` -- `StopTimeout = 15` - -Ограничения применяются к каждой реплике отдельно. При изменении количества реплик суммарный ресурсный бюджет также изменяется, если не корректировать лимиты. - -Для исследования цены масштабирования на оценку 5 потребуется зафиксировать общий бюджет CPU/RAM для сравниваемых конфигураций. +Сервис `migrate` завершился с кодом 0; заданные ограничения подтверждены и для его завершившегося контейнера. Для API также задан `stop_grace_period: 15s`. При масштабировании API общий бюджет изменяется, если лимиты каждой реплики сохраняются. Поэтому проведены две серии: с фиксированным суммарным бюджетом и с растущим бюджетом. ### Секреты и сетевой доступ @@ -203,7 +203,10 @@ API, PostgreSQL и Redis не публикуют порты на хосте. В | Failover `api-2` | `make test-failover` | PASS, восстановление за 1,339 с | `evidence/failover-grade4-second.txt` | | Идемпотентность при отказе | `python3 tests/test_failover_concurrent_idempotency.py` | 20 запросов, 1 сообщение, PASS | `evidence/failover-concurrent-idempotency.txt` | | Rolling replacement | Поочерёдное пересоздание API под нагрузкой | 16927 успешных запросов, 1 ошибка | `evidence/load-rolling.json` | -| Ограничения CPU/RAM | `docker inspect` | 1 CPU и 512 MiB на реплику | Результат проверки | +| Ограничения CPU/RAM | `docker inspect` для шести сервисов | Все значения `NanoCpus` и `Memory` ненулевые; таблица выше | Вывод проверки 22.10.2026 | +| Регрессии по замечаниям | `python3 tests/test_review_regressions.py` | PASS: UTF-8 Basic Auth, двоеточие в пароле, курсор чатов, последняя страница, некорректный курсор | Вывод проверки 22.10.2026 | +| Растущий бюджет 1/2/4 | `./scripts/run_growing_scale.sh` | 289,590 / 425,950 / 601,701 RPS, по три прогона, ошибок 0 | `evidence/scale/growing/` | +| Оптимизация «до/после» | `./scripts/run_optimization.sh` | 4 → 2 реплики при 2 CPU / 1024 MiB; RPS +6,2%, p95 −29,3%, p99 −42,1%, ошибок 0 | `evidence/scale/optimization/` | | Закрытые внутренние порты | `docker compose ps` | На хост опубликован только порт Nginx | Результат проверки | | Корректное завершение | `docker compose stop api-1` | Штатное завершение Uvicorn | Логи контейнера | @@ -627,11 +630,75 @@ PostgreSQL, Redis и Nginx не масштабировались вместе с Результаты сохранены в `evidence/scale/replicas-4-c16-period200.json`, `evidence/scale/replicas-4-c16-period200-repeat.json` и `evidence/scale/replicas-4-c16-period200-repeat2.json`. +### Вторая серия: растущий суммарный бюджет CPU и RAM + +Для отделения влияния числа реплик от влияния выделенных ресурсов проведена дополнительная серия. В отличие от основной серии с фиксированным бюджетом, каждая API-реплика получает 1 CPU и 512 MiB RAM. PostgreSQL, Redis и Nginx остаются общими компонентами, их лимиты не увеличиваются. Использован скрипт `./scripts/run_growing_scale.sh`. + +| API-реплик | CPU на реплику | RAM на реплику | Общий CPU API | Общая RAM API | +|---|---:|---:|---:|---:| +| 1 | 1 | 512 MiB | 1 | 512 MiB | +| 2 | 1 | 512 MiB | 2 | 1024 MiB | +| 4 | 1 | 512 MiB | 4 | 2048 MiB | + +Для каждого варианта: 16 конкурентных клиентов, 15 секунд прогрева, затем три измерения по 60 секунд; запросы `POST` на создание сообщений, закрытая модель нагрузки, без автоматических повторных попыток. Между вариантами Compose-стенд пересоздавался без `down -v`. Все API-реплики становились `healthy`. Итоговые средние и стандартные отклонения вычислены по трём прогонам. + +| API-реплик | Средний RPS | Стандартное отклонение RPS | Средний p95 | Средний p99 | Ошибок за три прогона | +|---|---:|---:|---:|---:|---:| +| 1 | 289,590 | 3,160 | 72,661 мс | 106,882 мс | 0 | +| 2 | 425,950 | 4,614 | 63,237 мс | 93,203 мс | 0 | +| 4 | 601,701 | 4,421 | 41,706 мс | 79,650 мс | 0 | + +При переходе от 1 к 2 репликам средний RPS увеличился на 47,1%; от 2 к 4 — на 41,3%; от 1 к 4 — на 107,8%. Средний p95 при переходе от 1 к 4 репликам уменьшился на 42,6%. Это подтверждает положительный эффект добавления API-ресурсов в данной серии, но не доказывает линейного масштабирования: при четырёхкратном CPU-бюджете RPS вырос примерно в 2,08 раза. + +В первой серии общий бюджет API составлял 2 CPU и 1024 MiB для всех вариантов, поэтому там сравнивалась **цена распределения фиксированных ресурсов**. В этой серии бюджет API увеличивался пропорционально числу реплик, поэтому она показывает **эффект добавления ресурсов**. Числа RPS между сериями нельзя использовать как строгое сравнение «до/после» изменения приложения: менялись ресурсные лимиты и состояние экспериментального окружения. + +Доказательства: JSON-файлы измерений в `evidence/scale/growing/`, вывод `./scripts/run_growing_scale.sh` и агрегирование `python3 scripts/summarize_growing_scale.py`. Исходные JSON-файлы должны быть включены в коммит вместе с отчётом. + +### Контрольный эксперимент «до/после»: оптимизация числа реплик + +После неудачного эксперимента с изменением CPU-периода выполнен отдельный контрольный эксперимент по выбору числа API-реплик. Проверялась гипотеза, что при фиксированном суммарном бюджете уменьшение числа реплик с четырёх до двух повысит пропускную способность и снизит задержки. Это **оптимизация конфигурации развёртывания**, а не изменение кода приложения. + +В обеих конфигурациях суммарный бюджет API равен 2 CPU и 1024 MiB RAM. Код приложения, генератор нагрузки, число клиентов и лимиты инфраструктурных сервисов не менялись. При переключении пересоздавались контейнеры, но Docker volumes не удалялись; менялись число API-реплик, распределение их квот и список upstream-серверов Nginx. + +| Условие | До оптимизации | После оптимизации | +|---|---:|---:| +| API-реплики | 4 | 2 | +| CPU на реплику | 0,5 | 1 | +| RAM на реплику | 256 MiB | 512 MiB | +| Суммарный бюджет API | 2 CPU / 1024 MiB | 2 CPU / 1024 MiB | +| Конкурентные клиенты | 16 | 16 | +| Прогрев | 15 с | 15 с | +| Основные измерения | 3 × 60 с | 3 × 60 с | + +Использована закрытая модель нагрузки `POST`-запросами на создание сообщений без автоматических повторных попыток. Для каждой конфигурации выполнены прогрев и три отдельных измерения. + +| Метрика | До: 4 реплики | После: 2 реплики | Изменение | +|---|---:|---:|---:| +| RPS, прогон 1 | 403,177 | 417,559 | — | +| RPS, прогон 2 | 392,746 | 416,933 | — | +| RPS, прогон 3 | 386,841 | 421,396 | — | +| Средний RPS | 394,255 | 418,629 | +6,2% | +| Средний p95 | 91,445 мс | 64,615 мс | −29,3% | +| Средний p99 | 165,019 мс | 95,539 мс | −42,1% | +| Ошибок за три прогона | 0 | 0 | — | + +**Подтверждённое улучшение:** при переходе от четырёх к двум репликам средний RPS вырос на 6,2%, средний p95 уменьшился на 29,3%, а средний p99 — на 42,1%. Во всех шести основных прогонах ошибок не зафиксировано. При этом каждый из трёх прогонов конфигурации «после» показал больший RPS, чем любой из трёх прогонов «до». + +Результат согласуется с гипотезой о преимуществах двух реплик при ограниченном бюджете, но конкретный вклад CPU throttling, планировщика и других накладных расходов в этом контрольном эксперименте отдельно не измерялся. Результаты отличаются по абсолютному RPS от ранней серии с фиксированным бюджетом; сравнивать их напрямую как единый эксперимент некорректно из-за возможных изменений состояния стенда и базы данных. Вывод «до/после» основан только на шести прогонах новой контрольной серии. + +Исходные JSON-файлы: `evidence/scale/optimization/before-run1.json` — `before-run3.json` и `after-run1.json` — `after-run3.json`; файлы прогрева хранятся в том же каталоге. Скрипт `scripts/run_optimization.sh` воспроизводит эксперимент и восстанавливает обычную конфигурацию с двумя репликами. Испытание проведено в одном локальном окружении при 16 клиентах; результат не следует обобщать на все нагрузки и оборудование. + +### Сопоставление с предыдущими экспериментами + +В исходной серии с фиксированным бюджетом конфигурация с двумя репликами также оказалась быстрее четырёх (220,996 против 104,084 RPS). Однако это отдельная серия с иными абсолютными результатами; её нельзя объединять с новым контрольным экспериментом при расчёте процента улучшения. + +Во второй серии с растущим бюджетом четыре реплики достигли 601,701 RPS при 4 CPU и 2048 MiB RAM суммарно. Поэтому преимущество двух реплик относится к **фиксированному бюджету**, а не к любым условиям масштабирования. Эксперимент с изменением CPU-периода остался отрицательным (−17,4% RPS) и не рассматривается как успешная оптимизация. + ### Итоговые выводы -В работе исследована цена горизонтального масштабирования API при фиксированном суммарном бюджете 2 CPU и 1024 MiB RAM. +В работе исследована цена горизонтального масштабирования API в двух режимах: при фиксированном суммарном бюджете 2 CPU и 1024 MiB RAM и при увеличении бюджета от 1 CPU / 512 MiB до 4 CPU / 2048 MiB. -При 16 конкурентных клиентах конфигурация с двумя репликами обеспечила максимальную среднюю пропускную способность среди проверенных вариантов — 220,996 RPS. Это приблизительно на 53,8% больше, чем у одной реплики, и на 112,3% больше, чем у четырёх. +В исходной серии с фиксированным бюджетом при 16 конкурентных клиентах конфигурация с двумя репликами обеспечила максимальную среднюю пропускную способность — 220,996 RPS. Это приблизительно на 53,8% больше, чем у одной реплики, и на 112,3% больше, чем у четырёх. При этом одна реплика показала наименьшую среднюю задержку p99 — 158,606 мс. Следовательно, оптимальный выбор зависит от требований к пропускной способности и задержкам. @@ -639,9 +706,9 @@ PostgreSQL, Redis и Nginx не масштабировались вместе с Попытка оптимизации путём увеличения периода CPU-квоты со 100 до 200 мс при сохранении общего бюджета оказалась неэффективной: RPS снизился на 17,4%. -По результатам исследования для данной нагрузки выбрана конфигурация с двумя API-репликами по 1 CPU и 512 MiB RAM. Она обеспечивает наибольшую пропускную способность среди проверенных вариантов без увеличения суммарного бюджета ресурсов. +По результатам исследования для данной нагрузки выбрана конфигурация с двумя API-репликами по 1 CPU и 512 MiB RAM. В отдельном контрольном эксперименте «до/после» при том же суммарном бюджете она обеспечила 418,629 RPS против 394,255 RPS у четырёх реплик (+6,2%) и снизила средние p95 и p99 на 29,3% и 42,1% соответственно. Это подтверждённое конфигурационное улучшение без увеличения общего бюджета API. -Таким образом, горизонтальное масштабирование необходимо оценивать экспериментально: увеличение числа реплик само по себе не гарантирует повышения производительности. +Во второй серии с растущим бюджетом средний RPS вырос с 289,590 (1 реплика) до 601,701 (4 реплики), без ошибок за девять измерений. Таким образом, горизонтальное масштабирование необходимо оценивать экспериментально: увеличение числа реплик само по себе не гарантирует повышения производительности, а выделение дополнительных ресурсов способно изменить результат. ## Команды для демонстрации @@ -806,7 +873,36 @@ python3 tests/load.py --duration 60 --concurrency 16 --output evidence/scale/dem При корректной конфигурации каждая реплика имеет `NanoCpus=0`, `CpuPeriod=200000`, `CpuQuota=100000`, то есть 0,5 CPU. Для повторения методики выполнить три прогона с разными именами выходных файлов. -### 7. Возврат к основной конфигурации после демонстрации +### 7. Воспроизведение серии с растущим бюджетом + +```bash +./scripts/run_growing_scale.sh +python3 scripts/summarize_growing_scale.py +``` + +Скрипт последовательно запускает 1, 2 и 4 API-реплики с лимитами 1 CPU и 512 MiB на реплику, выполняет прогрев и три измерения по 60 секунд. Результаты сохраняются в `evidence/scale/growing/`. После завершения восстанавливается основная конфигурация двух реплик. Команда пересоздаёт контейнеры, поэтому её следует выполнять на учебном стенде. + +### 8. Воспроизведение контрольной оптимизации «до/после» + +```bash +./scripts/run_optimization.sh +``` + +Скрипт сравнивает четыре реплики по 0,5 CPU / 256 MiB и две реплики по 1 CPU / 512 MiB при одинаковом общем бюджете 2 CPU / 1024 MiB. Для каждой конфигурации выполняются 15 секунд прогрева и три измерения по 60 секунд с 16 клиентами. Результаты сохраняются в `evidence/scale/optimization/`. После эксперимента восстанавливаются две API-реплики. Скрипт пересоздаёт контейнеры без удаления volumes и предназначен для учебного стенда. + +### 9. Регрессионные тесты по замечаниям + +```bash +python3 tests/test_review_regressions.py +for service in postgres redis migrate api-1 api-2 nginx; do + echo "=== $service ===" + docker inspect "$(docker compose ps -aq "$service")" --format 'CPU: {{.HostConfig.NanoCpus}}, RAM: {{.HostConfig.Memory}} bytes' +done +``` + +Регрессионный тест проверяет UTF-8 Basic Auth с двоеточием в пароле, переход между страницами списка чатов, отсутствие курсора на последней странице и отклонение некорректного курсора. Команда `docker inspect` подтверждает ограничения всех сервисов. + +### 10. Возврат к основной конфигурации после демонстрации ```bash docker compose -f compose.yaml -f compose.scale.yaml -f compose.cpu-period.yaml down @@ -822,3 +918,5 @@ docker compose down ``` `docker compose down -v` применять только при намеренном удалении учебной базы и volumes. При защите удобно показать сначала работающие две реплики, затем `X-Instance-Id`, проверки `make`, failover и результаты масштабирования; полные 60-секундные серии можно воспроизвести по приведённым командам при необходимости. + +```` \ No newline at end of file diff --git a/compose.yaml b/compose.yaml index a91b71ee..23d7d67e 100644 --- a/compose.yaml +++ b/compose.yaml @@ -39,6 +39,8 @@ services: timeout: 3s retries: 10 restart: unless-stopped + cpus: 1.0 + mem_limit: 768m redis: image: redis:8.2.2 @@ -56,6 +58,8 @@ services: timeout: 3s retries: 10 restart: unless-stopped + cpus: 0.5 + mem_limit: 256m migrate: build: @@ -68,6 +72,8 @@ services: postgres: condition: service_healthy restart: "no" + cpus: 1.0 + mem_limit: 512m api-1: <<: *api @@ -97,6 +103,8 @@ services: - api-1 - api-2 restart: unless-stopped + cpus: 0.5 + mem_limit: 256m secrets: postgres_password: @@ -108,4 +116,4 @@ secrets: volumes: postgres_data: - redis_data: \ No newline at end of file + redis_data: diff --git a/evidence/scale/growing/replicas-1-run1.json b/evidence/scale/growing/replicas-1-run1.json new file mode 100644 index 00000000..db117b39 --- /dev/null +++ b/evidence/scale/growing/replicas-1-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.038, + "concurrency": 16, + "successful_requests": 17175, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 286.068, + "successful_latency_ms": { + "p50": 52.594, + "p95": 81.865, + "p99": 108.938 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-1-run2.json b/evidence/scale/growing/replicas-1-run2.json new file mode 100644 index 00000000..8cb3635c --- /dev/null +++ b/evidence/scale/growing/replicas-1-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.042, + "concurrency": 16, + "successful_requests": 17543, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 292.177, + "successful_latency_ms": { + "p50": 52.781, + "p95": 69.305, + "p99": 105.621 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-1-run3.json b/evidence/scale/growing/replicas-1-run3.json new file mode 100644 index 00000000..0a07f3bf --- /dev/null +++ b/evidence/scale/growing/replicas-1-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.047, + "concurrency": 16, + "successful_requests": 17445, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 290.524, + "successful_latency_ms": { + "p50": 52.874, + "p95": 66.813, + "p99": 106.086 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-1-warmup.json b/evidence/scale/growing/replicas-1-warmup.json new file mode 100644 index 00000000..67beb9db --- /dev/null +++ b/evidence/scale/growing/replicas-1-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.039, + "concurrency": 16, + "successful_requests": 4643, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 308.737, + "successful_latency_ms": { + "p50": 49.524, + "p95": 68.017, + "p99": 99.238 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-2-run1.json b/evidence/scale/growing/replicas-2-run1.json new file mode 100644 index 00000000..40140d14 --- /dev/null +++ b/evidence/scale/growing/replicas-2-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.024, + "concurrency": 16, + "successful_requests": 25283, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 421.214, + "successful_latency_ms": { + "p50": 40.975, + "p95": 64.203, + "p99": 94.122 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-2-run2.json b/evidence/scale/growing/replicas-2-run2.json new file mode 100644 index 00000000..2503334d --- /dev/null +++ b/evidence/scale/growing/replicas-2-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.037, + "concurrency": 16, + "successful_requests": 25588, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 426.204, + "successful_latency_ms": { + "p50": 40.434, + "p95": 63.728, + "p99": 93.727 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-2-run3.json b/evidence/scale/growing/replicas-2-run3.json new file mode 100644 index 00000000..c433733c --- /dev/null +++ b/evidence/scale/growing/replicas-2-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.04, + "concurrency": 16, + "successful_requests": 25843, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 430.432, + "successful_latency_ms": { + "p50": 36.673, + "p95": 61.779, + "p99": 91.761 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-2-warmup.json b/evidence/scale/growing/replicas-2-warmup.json new file mode 100644 index 00000000..fab09d67 --- /dev/null +++ b/evidence/scale/growing/replicas-2-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.038, + "concurrency": 16, + "successful_requests": 7179, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 477.394, + "successful_latency_ms": { + "p50": 31.008, + "p95": 58.811, + "p99": 74.541 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-4-run1.json b/evidence/scale/growing/replicas-4-run1.json new file mode 100644 index 00000000..e5de2d50 --- /dev/null +++ b/evidence/scale/growing/replicas-4-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.025, + "concurrency": 16, + "successful_requests": 35821, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 596.766, + "successful_latency_ms": { + "p50": 24.158, + "p95": 43.446, + "p99": 84.503 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-4-run2.json b/evidence/scale/growing/replicas-4-run2.json new file mode 100644 index 00000000..39c80568 --- /dev/null +++ b/evidence/scale/growing/replicas-4-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.026, + "concurrency": 16, + "successful_requests": 36198, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 603.038, + "successful_latency_ms": { + "p50": 24.296, + "p95": 41.592, + "p99": 78.952 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-4-run3.json b/evidence/scale/growing/replicas-4-run3.json new file mode 100644 index 00000000..0e12e9d8 --- /dev/null +++ b/evidence/scale/growing/replicas-4-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.028, + "concurrency": 16, + "successful_requests": 36335, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 605.3, + "successful_latency_ms": { + "p50": 24.214, + "p95": 40.08, + "p99": 75.496 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/growing/replicas-4-warmup.json b/evidence/scale/growing/replicas-4-warmup.json new file mode 100644 index 00000000..ac8fa495 --- /dev/null +++ b/evidence/scale/growing/replicas-4-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.026, + "concurrency": 16, + "successful_requests": 9974, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 663.761, + "successful_latency_ms": { + "p50": 21.623, + "p95": 38.696, + "p99": 85.055 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/after-run1.json b/evidence/scale/optimization/after-run1.json new file mode 100644 index 00000000..6fc76ffe --- /dev/null +++ b/evidence/scale/optimization/after-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.037, + "concurrency": 16, + "successful_requests": 25069, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 417.559, + "successful_latency_ms": { + "p50": 37.705, + "p95": 63.254, + "p99": 94.489 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/after-run2.json b/evidence/scale/optimization/after-run2.json new file mode 100644 index 00000000..d4c16537 --- /dev/null +++ b/evidence/scale/optimization/after-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.038, + "concurrency": 16, + "successful_requests": 25032, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 416.933, + "successful_latency_ms": { + "p50": 40.359, + "p95": 65.787, + "p99": 102.35 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/after-run3.json b/evidence/scale/optimization/after-run3.json new file mode 100644 index 00000000..4c3c322c --- /dev/null +++ b/evidence/scale/optimization/after-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.039, + "concurrency": 16, + "successful_requests": 25300, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 421.396, + "successful_latency_ms": { + "p50": 39.572, + "p95": 64.804, + "p99": 89.779 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/after-warmup.json b/evidence/scale/optimization/after-warmup.json new file mode 100644 index 00000000..a55d4f28 --- /dev/null +++ b/evidence/scale/optimization/after-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.034, + "concurrency": 16, + "successful_requests": 7049, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 468.855, + "successful_latency_ms": { + "p50": 33.257, + "p95": 55.415, + "p99": 74.659 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/before-run1.json b/evidence/scale/optimization/before-run1.json new file mode 100644 index 00000000..a3328af6 --- /dev/null +++ b/evidence/scale/optimization/before-run1.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.098, + "concurrency": 16, + "successful_requests": 24230, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 403.177, + "successful_latency_ms": { + "p50": 20.095, + "p95": 90.688, + "p99": 177.425 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/before-run2.json b/evidence/scale/optimization/before-run2.json new file mode 100644 index 00000000..ca2e76b4 --- /dev/null +++ b/evidence/scale/optimization/before-run2.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.024, + "concurrency": 16, + "successful_requests": 23574, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 392.746, + "successful_latency_ms": { + "p50": 21.246, + "p95": 90.636, + "p99": 155.902 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/before-run3.json b/evidence/scale/optimization/before-run3.json new file mode 100644 index 00000000..edcc5240 --- /dev/null +++ b/evidence/scale/optimization/before-run3.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 60.0, + "elapsed_seconds": 60.097, + "concurrency": 16, + "successful_requests": 23248, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 386.841, + "successful_latency_ms": { + "p50": 22.844, + "p95": 93.01, + "p99": 161.73 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/evidence/scale/optimization/before-warmup.json b/evidence/scale/optimization/before-warmup.json new file mode 100644 index 00000000..f76957f9 --- /dev/null +++ b/evidence/scale/optimization/before-warmup.json @@ -0,0 +1,17 @@ +{ + "lab": 3, + "workload": "closed-loop POST messages; no automatic retries", + "requested_duration_seconds": 15.0, + "elapsed_seconds": 15.075, + "concurrency": 16, + "successful_requests": 6116, + "failed_requests": 0, + "error_ratio": 0.0, + "successful_rps": 405.708, + "successful_latency_ms": { + "p50": 19.709, + "p95": 88.349, + "p99": 172.728 + }, + "note": "Latency percentiles cover successes only. Timeouts/errors are counted separately; closed-loop has coordinated omission and client overhead." +} diff --git a/scripts/run_growing_scale.sh b/scripts/run_growing_scale.sh new file mode 100755 index 00000000..3b60c287 --- /dev/null +++ b/scripts/run_growing_scale.sh @@ -0,0 +1,28 @@ +#!/usr/bin/env bash +set -euo pipefail +cd "$(dirname "$0")/.." +mkdir -p evidence/scale/growing +for replicas in 1 2 4; do + export API_REPLICAS="$replicas" + export API_CPUS=1.0 + export API_MEMORY=512m + docker compose -f compose.yaml -f compose.scale.yaml down + services=(postgres redis migrate nginx) + for ((i=1;i<=replicas;i++)); do services+=("api-$i"); done + docker compose -f compose.yaml -f compose.scale.yaml up -d --build "${services[@]}" + for ((attempt=1;attempt<=60;attempt++)); do + if curl --fail --silent http://localhost:8080/health/ready >/dev/null; then break; fi + sleep 2 + done + curl --fail --silent http://localhost:8080/health/ready >/dev/null + for ((i=1;i<=replicas;i++)); do + docker compose -f compose.yaml -f compose.scale.yaml ps "api-$i" + done + python3 tests/load.py --duration 15 --concurrency 16 --output "evidence/scale/growing/replicas-${replicas}-warmup.json" + for run in 1 2 3; do + python3 tests/load.py --duration 60 --concurrency 16 --output "evidence/scale/growing/replicas-${replicas}-run${run}.json" + done +done +API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m docker compose -f compose.yaml -f compose.scale.yaml down +API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m docker compose -f compose.yaml -f compose.scale.yaml up -d --build postgres redis migrate api-1 api-2 nginx +python3 scripts/summarize_growing_scale.py diff --git a/scripts/run_optimization.sh b/scripts/run_optimization.sh new file mode 100755 index 00000000..bde0b4f1 --- /dev/null +++ b/scripts/run_optimization.sh @@ -0,0 +1,65 @@ +#!/usr/bin/env bash +set -euo pipefail + +cd "$(dirname "$0")/.." +mkdir -p evidence/scale/optimization + +run_case() { + local name="$1" + local replicas="$2" + local cpus="$3" + local memory="$4" + + export API_REPLICAS="$replicas" + export API_CPUS="$cpus" + export API_MEMORY="$memory" + + echo "=== $name: $replicas replicas, $cpus CPU and $memory per replica ===" + + docker compose -f compose.yaml -f compose.scale.yaml down + + services=(postgres redis migrate nginx) + for ((i=1; i<=replicas; i++)); do + services+=("api-$i") + done + + docker compose -f compose.yaml -f compose.scale.yaml up -d --build "${services[@]}" + + ready=0 + for ((attempt=1; attempt<=60; attempt++)); do + if curl --fail --silent http://localhost:8080/health/ready >/dev/null; then + ready=1 + break + fi + sleep 2 + done + + if ((ready == 0)); then + echo "ERROR: API readiness timeout" >&2 + exit 1 + fi + + python3 tests/load.py \ + --duration 15 \ + --concurrency 16 \ + --output "evidence/scale/optimization/${name}-warmup.json" + + for run in 1 2 3; do + python3 tests/load.py \ + --duration 60 \ + --concurrency 16 \ + --output "evidence/scale/optimization/${name}-run${run}.json" + done +} + +run_case before 4 0.5 256m +run_case after 2 1.0 512m + +API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m \ + docker compose -f compose.yaml -f compose.scale.yaml down + +API_REPLICAS=2 API_CPUS=1.0 API_MEMORY=512m \ + docker compose -f compose.yaml -f compose.scale.yaml up -d --build \ + postgres redis migrate api-1 api-2 nginx + +echo "=== Optimization experiment completed ===" diff --git a/scripts/summarize_growing_scale.py b/scripts/summarize_growing_scale.py new file mode 100644 index 00000000..be7b0dd8 --- /dev/null +++ b/scripts/summarize_growing_scale.py @@ -0,0 +1,17 @@ +import json +import statistics +from pathlib import Path + +root = Path('evidence/scale/growing') +print('Growing budget: 1/2/4 replicas, each 1 CPU and 512 MiB, 16 clients, 60 seconds, 3 runs') +for replicas in (1, 2, 4): + files = [root / f'replicas-{replicas}-run{i}.json' for i in (1, 2, 3)] + if not all(p.exists() for p in files): + print(f'{replicas}: INCOMPLETE (measurements not yet run)') + continue + data = [json.loads(p.read_text()) for p in files] + values = [x['successful_rps'] for x in data] + errors = sum(x['failed_requests'] for x in data) + print(f'{replicas}: mean RPS={statistics.mean(values):.3f}, stdev={statistics.stdev(values):.3f}, ' + f'mean p95={statistics.mean(x["successful_latency_ms"]["p95"] for x in data):.3f} ms, ' + f'mean p99={statistics.mean(x["successful_latency_ms"]["p99"] for x in data):.3f} ms, errors={errors}') diff --git a/src/cursor.py b/src/cursor.py index 16702905..23dfb48b 100644 --- a/src/cursor.py +++ b/src/cursor.py @@ -57,4 +57,30 @@ def decode_cursor(cursor: str) -> tuple[UUID, datetime, UUID]: binascii.Error, json.JSONDecodeError, ) as exc: - raise ValueError("Invalid cursor") from exc \ No newline at end of file + raise ValueError("Invalid cursor") from exc + + +def encode_chat_cursor(user_id: UUID, created_at: datetime, chat_id: UUID) -> str: + data = { + "user_id": str(user_id), + "created_at": created_at.isoformat(), + "chat_id": str(chat_id), + } + raw = json.dumps(data, separators=(",", ":")).encode("utf-8") + return base64.urlsafe_b64encode(raw).decode("ascii") + + +def decode_chat_cursor(cursor: str) -> tuple[UUID, datetime, UUID]: + try: + raw = base64.b64decode(cursor.encode("ascii"), altchars=b"-_", validate=True) + data = json.loads(raw.decode("utf-8")) + if not isinstance(data, dict) or set(data) != {"user_id", "created_at", "chat_id"}: + raise ValueError("Invalid cursor") + user_id = UUID(data["user_id"]) + created_at = datetime.fromisoformat(data["created_at"]) + chat_id = UUID(data["chat_id"]) + if created_at.tzinfo is None or created_at.utcoffset() is None: + raise ValueError("Invalid cursor") + return user_id, created_at, chat_id + except (ValueError, TypeError, KeyError, UnicodeError, binascii.Error, json.JSONDecodeError) as exc: + raise ValueError("Invalid cursor") from exc diff --git a/src/main.py b/src/main.py index 0560594a..0295542b 100644 --- a/src/main.py +++ b/src/main.py @@ -2,14 +2,14 @@ from datetime import datetime, timedelta, timezone from uuid import UUID, uuid4 import os import re +import base64 +import binascii from fastapi import Depends, FastAPI, Request, Header from fastapi.exceptions import RequestValidationError from fastapi.responses import JSONResponse from fastapi.security import ( HTTPAuthorizationCredentials, - HTTPBasic, - HTTPBasicCredentials, HTTPBearer, ) from sqlalchemy.exc import IntegrityError, SQLAlchemyError @@ -50,7 +50,6 @@ async def lifespan(app: FastAPI): app = FastAPI(lifespan=lifespan) INSTANCE_ID = os.getenv("INSTANCE_ID") or str(uuid4()) -basic_security = HTTPBasic(auto_error=False) bearer_security = HTTPBearer(auto_error=False) @@ -300,22 +299,32 @@ async def get_me( status_code=201, ) async def create_auth_session( - credentials: HTTPBasicCredentials | None = Depends(basic_security), + authorization: str | None = Header(default=None), session: AsyncSession = Depends(get_db_session), ): + credentials = None + if authorization is not None: + scheme, separator, encoded = authorization.partition(" ") + if separator and scheme.lower() == "basic": + try: + decoded = base64.b64decode(encoded.strip(), validate=True).decode("utf-8") + if ":" in decoded: + credentials = decoded.split(":", 1) + except (ValueError, UnicodeError, binascii.Error): + pass if credentials is None: raise APIError( status_code=401, code="unauthorized", message="Unauthorized", headers={ - "WWW-Authenticate": 'Basic realm="messenger"', + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"', }, ) user_credentials = await get_user_credentials_by_username( session, - credentials.username, + credentials[0], ) if user_credentials is None: @@ -324,20 +333,20 @@ async def create_auth_session( code="unauthorized", message="Unauthorized", headers={ - "WWW-Authenticate": 'Basic realm="messenger"', + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"', }, ) if not verify_password( user_credentials.password_hash, - credentials.password, + credentials[1], ): raise APIError( status_code=401, code="unauthorized", message="Unauthorized", headers={ - "WWW-Authenticate": 'Basic realm="messenger"', + "WWW-Authenticate": 'Basic realm="messenger", charset="UTF-8"', }, ) @@ -401,6 +410,7 @@ async def create_chat_endpoint( ) async def get_chats( limit: int = 50, + cursor: str | None = None, current_user: User = Depends(get_current_user), session: AsyncSession = Depends(get_db_session), ) -> ChatPage: @@ -415,6 +425,7 @@ async def get_chats( session=session, current_user_id=current_user.id, limit=limit, + cursor=cursor, ) @@ -514,4 +525,4 @@ async def get_messages_endpoint( current_user_id=current_user.id, limit=limit, cursor=cursor, - ) \ No newline at end of file + ) diff --git a/src/repositories.py b/src/repositories.py index f7b6c335..f0020c69 100644 --- a/src/repositories.py +++ b/src/repositories.py @@ -8,7 +8,7 @@ from sqlalchemy.ext.asyncio import AsyncSession from src.models import Chat, ChatPage, CreateChat, CreateUser, User, CreateMessage, Message, MessagePage from src.security import hash_password from src.errors import APIError -from src.cursor import decode_cursor, encode_cursor +from src.cursor import decode_cursor, encode_cursor, decode_chat_cursor, encode_chat_cursor async def create_user( @@ -269,33 +269,48 @@ async def list_chats( session: AsyncSession, current_user_id: UUID, limit: int, + cursor: str | None = None, ) -> ChatPage: - chats_result = await session.execute( + cursor_created_at = None + cursor_chat_id = None + if cursor is not None: + try: + cursor_user_id, cursor_created_at, cursor_chat_id = decode_chat_cursor(cursor) + except ValueError as exc: + raise APIError(status_code=400, code="invalid_request", message="Invalid cursor") from exc + if cursor_user_id != current_user_id: + raise APIError(status_code=400, code="invalid_request", message="Invalid cursor") + + result = await session.execute( text( """ - SELECT - c.id, - c.title, - c.created_at + SELECT c.id, c.title, c.created_at FROM chats AS c - JOIN chat_members AS cm - ON cm.chat_id = c.id + JOIN chat_members AS cm ON cm.chat_id = c.id WHERE cm.user_id = :current_user_id + AND ( + CAST(:cursor_created_at AS timestamptz) IS NULL + OR (c.created_at, c.id) > ( + CAST(:cursor_created_at AS timestamptz), + CAST(:cursor_chat_id AS uuid) + ) + ) ORDER BY c.created_at, c.id - LIMIT :limit + LIMIT :fetch_limit """ ), { "current_user_id": current_user_id, - "limit": limit, + "cursor_created_at": cursor_created_at, + "cursor_chat_id": cursor_chat_id, + "fetch_limit": limit + 1, }, ) - - chat_rows = chats_result.all() - + rows = result.all() + has_more = len(rows) > limit + page_rows = rows[:limit] items = [] - - for chat_row in chat_rows: + for chat_row in page_rows: members_result = await session.execute( text( """ @@ -305,29 +320,23 @@ async def list_chats( ORDER BY user_id """ ), - { - "chat_id": chat_row.id, - }, + {"chat_id": chat_row.id}, ) - - member_ids = [ - UUID(str(row.user_id)) - for row in members_result - ] - items.append( Chat( id=UUID(str(chat_row.id)), title=chat_row.title, - member_ids=member_ids, + member_ids=[UUID(str(row.user_id)) for row in members_result], created_at=chat_row.created_at, ) ) - - return ChatPage( - items=items, - next_cursor=None, - ) + next_cursor = None + if has_more: + last = page_rows[-1] + next_cursor = encode_chat_cursor( + current_user_id, last.created_at, UUID(str(last.id)) + ) + return ChatPage(items=items, next_cursor=next_cursor) async def create_message( @@ -643,4 +652,4 @@ async def get_messages( return MessagePage( items=items, next_cursor=next_cursor, - ) \ No newline at end of file + ) diff --git a/tests/test_review_regressions.py b/tests/test_review_regressions.py new file mode 100644 index 00000000..4ee97ada --- /dev/null +++ b/tests/test_review_regressions.py @@ -0,0 +1,52 @@ +import base64 +import json +import os +import time +import urllib.error +import urllib.parse +import urllib.request + +BASE_URL = os.environ.get('BASE_URL', 'http://localhost:8080') + + +def request(method, path, body=None, token=None, basic=None, expected=200): + headers = {} + if body is not None: + headers['Content-Type'] = 'application/json' + if token: + headers['Authorization'] = 'Bearer ' + token + if basic: + headers['Authorization'] = 'Basic ' + base64.b64encode(basic.encode('utf-8')).decode('ascii') + data = json.dumps(body, ensure_ascii=False).encode('utf-8') if body is not None else None + req = urllib.request.Request(BASE_URL + path, data=data, headers=headers, method=method) + try: + with urllib.request.urlopen(req, timeout=15) as response: + status = response.status + result = response.read() + except urllib.error.HTTPError as exc: + status = exc.code + result = exc.read() + assert status == expected, f'{method} {path}: expected {expected}, got {status}: {result!r}' + return json.loads(result) if result else None + + +def main(): + username = 'review_' + str(time.time_ns())[-16:] + password = 'Пример:пароля-12345' + user = request('POST', '/api/v1/users', {'username': username, 'display_name': 'Проверка', 'password': password}, expected=201) + session = request('POST', '/api/v1/auth/sessions', basic=username + ':' + password, expected=201) + assert session['user']['id'] == user['id'] + token = session['token'] + first = request('POST', '/api/v1/chats', {'title': 'Первый', 'member_ids': [user['id']]}, token=token, expected=201) + second = request('POST', '/api/v1/chats', {'title': 'Второй', 'member_ids': [user['id']]}, token=token, expected=201) + page1 = request('GET', '/api/v1/chats?limit=1', token=token) + assert len(page1['items']) == 1 and page1['next_cursor'], page1 + page2 = request('GET', '/api/v1/chats?limit=1&cursor=' + urllib.parse.quote(page1['next_cursor']), token=token) + assert len(page2['items']) == 1 and page2['next_cursor'] is None, page2 + assert [page1['items'][0]['id'], page2['items'][0]['id']] == [first['id'], second['id']] + request('GET', '/api/v1/chats?limit=1&cursor=invalid', token=token, expected=400) + print('PASS: UTF-8 Basic Auth, colon in password, chat cursor, last page, invalid cursor') + + +if __name__ == '__main__': + main() -- 2.54.0 From e8c13abe10d7fe7af9d11028a0d46d1614efe6c2 Mon Sep 17 00:00:00 2001 From: casablanca Date: Thu, 22 Oct 2026 17:29:03 +0300 Subject: [PATCH 7/7] =?UTF-8?q?=D1=84=D0=B8=D0=BA=D1=81=20=D1=84=D0=BE?= =?UTF-8?q?=D1=80=D0=BC=D0=B0=D1=82=D0=B8=D1=80=D0=BE=D0=B2=D0=B0=D0=BD?= =?UTF-8?q?=D0=B8=D1=8F=20REPORT?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- REPORT.md | 2 -- 1 file changed, 2 deletions(-) diff --git a/REPORT.md b/REPORT.md index 432a67ce..14462011 100644 --- a/REPORT.md +++ b/REPORT.md @@ -1,4 +1,3 @@ -```` # Отчёт — лабораторная 3 - Автор, группа: Станислав Травкин, БВТ2304 @@ -919,4 +918,3 @@ docker compose down `docker compose down -v` применять только при намеренном удалении учебной базы и volumes. При защите удобно показать сначала работающие две реплики, затем `X-Instance-Id`, проверки `make`, failover и результаты масштабирования; полные 60-секундные серии можно воспроизвести по приведённым командам при необходимости. -```` \ No newline at end of file -- 2.54.0