лаба на 4

This commit is contained in:
2026-10-15 01:15:29 +03:00
parent d3bb55ba09
commit 666c13cd5a
12 changed files with 498 additions and 34 deletions
+315 -30
View File
@@ -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.
После завершения испытания реплика восстанавливалась перед следующим экспериментом.
| Сценарий | Продолжительность | Успешные запросы | Ошибки | 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.
@@ -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
+4
View File
@@ -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.
+4
View File
@@ -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.
+17
View File
@@ -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."
}
+17
View File
@@ -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."
}
+17
View File
@@ -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."
}
+17
View File
@@ -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."
}
+7 -2
View File
@@ -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 {
+1
View File
@@ -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
+11 -2
View File
@@ -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)
@@ -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)