create tasks from 5

This commit is contained in:
EgorAnti
2026-11-03 20:49:07 +03:00
parent 6a4cd9534f
commit d235571a52
18 changed files with 1071 additions and 97 deletions
+13 -4
View File
@@ -4,7 +4,7 @@ CA_FILE ?=
ACTION_SCRIPT ?=
TLS_ARGS = $(if $(CA_FILE),--ca-file "$(CA_FILE)",)
.PHONY: help check validate test test-idempotency load test-persistence test-failover test-failover-each test-rolling
.PHONY: help check validate test test-idempotency load test-persistence test-failover test-failover-each test-rolling swarm-up test-node-failover swarm-down
help:
@echo "check: offline structure; validate: full OpenAPI (requirements-dev.txt); test: running API; load: synthetic writes"
@@ -19,7 +19,7 @@ test:
$(PYTHON) tests/smoke.py --base-url "$(BASE_URL)" $(TLS_ARGS)
test-idempotency:
$(PYTHON) tests/idempotency_concurrent.py --base-url "$(BASE_URL)" $(TLS_ARGS)
$(PYTHON) student_tests/idempotency_concurrent.py --base-url "$(BASE_URL)" $(TLS_ARGS)
load:
$(PYTHON) tests/load.py --base-url "$(BASE_URL)" $(TLS_ARGS)
@@ -31,7 +31,16 @@ test-failover:
$(PYTHON) tests/resilience.py --mode failover --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-failover-each:
$(PYTHON) tests/failover_each.py --action-script "$(ACTION_SCRIPT)" --restore-script "$(RESTORE_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
$(PYTHON) student_tests/failover_each.py --action-script "$(ACTION_SCRIPT)" --restore-script "$(RESTORE_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
test-rolling:
$(PYTHON) tests/rolling_update.py --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
$(PYTHON) student_tests/rolling_update.py --action-script "$(ACTION_SCRIPT)" --base-url "$(BASE_URL)" $(TLS_ARGS)
swarm-up:
powershell -NoProfile -ExecutionPolicy Bypass -File scripts/swarm-lab-up.ps1
test-node-failover:
$(PYTHON) student_tests/node_failover.py --base-url "http://localhost:18080" --output "evidence/node-failover.json"
swarm-down:
powershell -NoProfile -ExecutionPolicy Bypass -File scripts/swarm-lab-down.ps1
+28
View File
@@ -97,6 +97,34 @@ Nginx обновляет Docker DNS раз в 2 секунды. Сетевой
`Idempotency-Key` делает такой retry безопасным. Для остальных POST параметр
`non_idempotent` не включён, чтобы не размножать пользователей или чаты.
## Отказ узла: отдельный трёхузловой Swarm-стенд
Дополнительные студенческие проверки находятся в `student_tests/`; исходные
тесты курса в `tests/` не перемещаются, Spring-тесты остаются в `src/test/java`.
Для трека отказа узла добавлен одноразовый локальный стенд из трёх настоящих
Docker daemons в privileged DinD-контейнерах: manager и два workers. Он не
заменяет основной Compose-стенд и использует отдельный порт `18080`.
```powershell
make swarm-up
make test-node-failover PYTHON=python
make swarm-down
```
`swarm-up` строит образы из текущего исходного кода, публикует их в одноразовый
локальный registry, доступный всем узлам,
создаёт overlay network, отдельно выполняет миграцию и запускает API с двумя
replicas и `max_replicas_per_node=1`. Тест выбирает worker с API-задачей и
жёстко останавливает весь Docker daemon этого узла. Swarm должен создать новую
API-задачу на свободном узле; через LB одновременно выполняются чтения/записи,
после чего проверяются старые и подтверждённые во время отказа сообщения.
Защищён только API worker. PostgreSQL, Redis и Nginx закреплены на manager;
PostgreSQL использует локальный volume и не реплицирован. Потеря manager/DB
узла не переживается и в отчёте не заявляется. Один manager также означает
SPOF control plane; DinD underlay и физический host остаются SPOF эксперимента.
## Что сделать
1. Выберите Compose + Nginx/HAProxy/Traefik либо Docker Swarm. Для выбранного варианта дайте одну последовательность запуска.
+382 -90
View File
@@ -1,18 +1,82 @@
# Отчёт — лабораторная 3
# Отчёт по лабораторной работе №3
- Автор, группа: TODO
- Целевая оценка: 4
- Commit/PR: TODO после публикации
- Помощь ИИ: проектирование Compose/Nginx, общей идемпотентности и тестов; решения проверяются командами ниже.
**Тема:** горизонтальное масштабирование, балансировка и отказоустойчивость API
## Запуск из чистого clone
**Автор:** Антипин Егор Иванович, БПИ2301
Требуются Docker Engine с Compose v2, `make` и Python 3.9+. Единственная
последовательность запуска:
**Целевая оценка:** 5
**Выбранный трек уровня 5:** трек 2 — «Отказ узла»
**Commit/PR:** работа проверена в локальной копии; ссылку следует указать после публикации репозитория.
## 1. Цель работы
Цель — запустить несколько взаимозаменяемых экземпляров API за одной публичной
точкой входа и сохранить корректность приложения при остановке отдельной
реплики. Сессии, сообщения и результаты идемпотентных операций не должны
зависеть от памяти или локального диска API.
Для уровня 5 дополнительно проверяется потеря целого Docker-узла. Реализованы
два стенда:
1. основной Compose-стенд с Nginx и двумя API-репликами;
2. отдельный трёхузловой Swarm-стенд для переноса API после потери worker-узла.
## 2. Использованные технологии
- Java 23, Spring Boot 4.1.1;
- PostgreSQL 16.4 — источник истины;
- Redis 7.4 — общий необязательный cache-aside кэш;
- Nginx 1.27.4 — единственная публичная точка входа и балансировщик;
- Docker Compose v2 — основной стенд;
- Docker Swarm и Docker-in-Docker — эксперимент с отказом узла;
- Flyway — версионирование схемы;
- Python 3.9+ — black-box и нагрузочные сценарии.
Приложение собирается из исходного кода текущего репозитория. Готовый образ
серверной части преподавателя не используется.
## 3. Архитектура основного стенда
```text
клиент -> localhost:8080 -> Nginx -> API replica 1/2 -> PostgreSQL
|
+-----------> Redis (необязательный кэш)
```
Nginx — единственный сервис, публикующий порт на host. API, PostgreSQL и Redis
доступны только во внутренней Docker-сети `backend`. У сервиса `api` нет
`container_name`, поэтому один Compose-service масштабируется параметром
`--scale api=2`.
### 3.1. Роли компонентов
| Роль | Service / образ | Health/readiness | Хранилище | Порт и сеть | Credentials |
| --- | --- | --- | --- | --- | --- |
| Публичный LB | `nginx`, `nginx:1.27.4-bookworm` | `nginx -t`, каждые 2 s | нет | `127.0.0.1:8080 -> 80`, `backend` | не требуются |
| API | `api`, локальный `hla-lab3-api:local` | `GET /health/ready`, каждые 2 s | нет | только `8080/backend` | параметры БД из `.env` через environment |
| Миграции | `migrate`, тот же образ API | one-shot, код завершения | нет | `backend` | те же параметры БД |
| Источник истины | `postgres`, `postgres:16.4-bookworm` | `pg_isready`, каждые 2 s | `postgres-data` | только `5432/backend` | `DATABASE_PASSWORD` из `.env` |
| Общий кэш | `redis`, `redis:7.4-bookworm` | `redis-cli ping`, каждые 2 s | `redis-data`, AOF everysec | только `6379/backend` | наружу порт не открыт |
PostgreSQL хранит пользователей, Bearer-сессии, чаты, членство, сообщения и
`message_idempotency`. Поэтому следующий запрос одного пользователя может
попасть на другую API-реплику без повторного входа. Redis не является
источником корректности: при cache miss или недоступности Redis приложение
читает данные из PostgreSQL.
Постоянные volumes подключены только к PostgreSQL и Redis. API и Nginx
stateless и могут быть удалены и созданы заново.
## 4. Воспроизводимый запуск Compose + Nginx
Требуются Docker Engine с Compose v2, `make` и Python 3.9+.
```sh
cp .env.example .env
# заменить DATABASE_PASSWORD в .env локальным случайным значением
docker compose --env-file .env config --quiet
docker compose --env-file .env build api
docker compose --env-file .env up -d postgres redis
docker compose --env-file .env run --rm migrate
@@ -20,118 +84,346 @@ docker compose --env-file .env up -d --scale api=2 api nginx
curl --fail http://localhost:8080/health/ready
```
Миграции выполняются отдельным one-shot процессом до реплик. В каждой API
реплике `FLYWAY_ENABLED=false`. Повторная миграция согласуется таблицей истории
Flyway и её блокировкой. Для обновления сначала выполняется обратно совместимая
миграция, затем реплики заменяются по одной.
Это единая последовательность запуска. Миграции выполняются отдельным
one-shot сервисом до API. Во всех обычных API-репликах установлено
`FLYWAY_ENABLED=false`, поэтому реплики не соревнуются за схему. Повторный
запуск `migrate` безопасен: Flyway сверяет таблицу истории и не повторяет уже
применённые версии.
Безопасная остановка сохраняет данные:
Обычная остановка сохраняет данные:
```sh
docker compose --env-file .env stop
```
Намеренное удаление учебных данных (только после явного решения оператора):
Удаление учебных данных выполняется только осознанно:
```sh
docker compose --env-file .env down --volumes
```
## Архитектура и корректность
`.env` не должен попадать в Git. Для production вместо него требуется secret
manager или Docker secrets.
Путь запроса: клиент → `nginx:80` → `api:8080` × 2 → PostgreSQL. Redis — общий
необязательный cache пользователей; cache miss/отказ приводит к чтению из
PostgreSQL. Сессии, пользователи, чаты, сообщения и идемпотентность хранятся в
PostgreSQL и не зависят от памяти/диска конкретной API-реплики.
## 5. Балансировка Nginx
Nginx 1.27.4 использует Docker DNS resolver `127.0.0.11`, TTL 2 s,
`least_conn`, `max_fails=1`, `fail_timeout=2s` и до двух upstream-попыток. Sticky
session отсутствует. API-порты на host не публикуются. Readiness каждые 2 s
проверяет Spring `ACCEPTING_TRAFFIC`, PostgreSQL и наличие V3-таблицы. При
SIGTERM Spring graceful shutdown имеет 10 s, Compose — 12 s, Nginx connect
timeout — 500 ms, read/send timeout — 4 s. Максимум обнаружения зависшего
backend — 4 s; с двумя последовательными timeout-попытками запрос завершается
примерно за 8.5 s. Docker health имеет period 2 s и timeout 2 s.
Конфигурация находится в `infra/nginx.conf`. Upstream задаётся DNS-именем
`api:8080`. Встроенный Docker DNS `127.0.0.11` возвращает адреса актуальных
Compose-реплик. `resolve` и `resolver ... valid=2s` обновляют список адресов
без reload с TTL 2 секунды.
Прозрачный `non_idempotent` retry разрешён только для endpoint сообщений:
обязательный `Idempotency-Key` и общая PostgreSQL-транзакция делают повтор
безопасным. Другие POST автоматически после начала отправки не повторяются.
Алгоритм `least_conn` выбирает живую реплику с наименьшим числом активных
соединений. Реплика с длинными запросами временно получает меньше новой работы.
`X-Instance-Id` создаётся один раз на жизнь процесса из hostname контейнера.
Это позволяет доказать прохождение запросов через разные процессы и точно
сопоставить выбранный ID контейнеру в `scripts/stop-one.sh`.
Sticky session не используется. Она закрепляла бы клиента за одной репликой и
скрывала ошибочное локальное состояние. Здесь запросы одного Bearer-пользователя
могут проходить через разные реплики. `X-Instance-Id`, равный hostname
процесса, позволяет это наблюдать.
## Общая идемпотентность
Параметры upstream:
Область ключа: `(user_id, POST, canonical chat path, Idempotency-Key)`. Перед
проверкой/созданием сервис берёт transaction-scoped PostgreSQL advisory lock от
этой области. Затем в одной транзакции он проверяет SHA-256 семантического body,
создаёт `messages` и `message_idempotency`. Поэтому конкурентные запросы через
разные реплики сериализуются, а побочный эффект и результат коммитятся атомарно.
Тот же body возвращает исходные 201/Message; другой body даёт 409. Записи моложе
24 часов не удаляются. Возможная 64-битная коллизия advisory-lock только лишний
раз сериализует разные ключи: полная область всё равно проверяется primary key.
- `max_fails=1`: одной сетевой ошибки достаточно для временного исключения;
- `fail_timeout=2s`: ошибочный peer исключается на 2 секунды;
- `proxy_connect_timeout=500ms`;
- `proxy_read_timeout=4s` и `proxy_send_timeout=4s`;
- максимум две upstream-попытки.
## Воспроизводимые проверки
Для зависшего backend максимальное время первичного обнаружения — 4 секунды.
Две последовательные timeout-попытки завершают запрос примерно за 8,5 секунды.
Ошибка соединения определяется быстрее — в пределах 500 ms на попытку. Это
укладывается в требование возобновить новые операции не позднее 10 секунд.
| Критерий | Команда | Ожидаемый результат |
| --- | --- | --- |
| Контракт | `make test` | `PASS` |
| Один ключ через разные реплики | `make test-idempotency` | 32 ответа, ≥2 instance ID, 1 message |
| Отказ выбранной реплики | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | чтение/запись восстанавливаются ≤10 s |
| Обе реплики по очереди | `make test-failover-each ACTION_SCRIPT=... RESTORE_SCRIPT=...` | RPS/errors/recovery для каждой реплики |
| Поочерёдная замена | `make test-rolling ACTION_SCRIPT=scripts/rolling-update.sh` | запись продолжается при замене обеих реплик |
| Сохранность и сессия | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | прежний token и данные доступны |
| Конфигурация | `docker compose --env-file .env config --quiet` | exit 0 |
Nginx OSS использует пассивную runtime-проверку upstream: Docker readiness не
допускает ранний операторский запуск публичного маршрута, а отказ уже
работающего backend обнаруживается запросом и указанными таймерами.
Перед action-тестами:
## 6. Readiness и graceful shutdown
```sh
chmod +x scripts/stop-one.sh scripts/restart.sh
`GET /health/live` подтверждает, что процесс работает. `GET /health/ready`
проверяет:
1. Spring `ReadinessState.ACCEPTING_TRAFFIC`;
2. доступ к PostgreSQL;
3. наличие таблицы `message_idempotency`, то есть применение V3.
Ping Redis прогревает соединение, но ошибка Redis не делает API неготовым,
поскольку Redis — необязательный кэш.
Docker вызывает readiness каждые 2 s, timeout — 2 s, start period — 45 s.
Перед завершением Spring переводит приложение из `ACCEPTING_TRAFFIC`,
прекращает приём новой работы и завершает принятую. В `application.yml`
установлены `server.shutdown=graceful` и
`timeout-per-shutdown-phase=10s`; Compose даёт API 12 s через
`stop_grace_period`. У Nginx `worker_shutdown_timeout=10s` и такой же
`stop_grace_period`.
## 7. Общая идемпотентность сообщений
Для `POST /api/v1/chats/{chatId}/messages` обязателен `Idempotency-Key`.
Область ключа:
```text
(user_id, HTTP method, canonical request path, Idempotency-Key)
```
Для локального запуска из Windows предоставлены эквивалентные
`scripts/stop-one.cmd` и `scripts/restart.cmd`.
В общей PostgreSQL-транзакции API вычисляет SHA-256 семантического тела и
получает transaction-scoped advisory lock:
После каждого failover восстановить две реплики и повторить со второй:
```sh
docker compose --env-file .env up -d --scale api=2 api
make test-failover ACTION_SCRIPT=scripts/stop-one.sh
```sql
SELECT pg_advisory_xact_lock(hashtextextended(scope, 0));
```
Фактический эксперимент 2026-11-03 сохранён в
`evidence/failover-each-2026-11-03.json`,
`evidence/rolling-update-2026-11-03.json` и сводке
`evidence/level4-2026-11-03.md`. Последовательные отказы двух реплик дали
10.839/10.014 успешных операций в секунду, 0 ошибок и восстановление
1.306/2.672 s. Параллельная проверка одного idempotency key: 32 запроса через
две реплики создали одно сообщение.
Advisory-блокировка — именованная блокировка PostgreSQL, которой управляет
приложение. `pg_advisory_xact_lock` действует до конца транзакции. Одинаковый
ключ с разных API-реплик сериализуется общей БД. Затем сервис:
Rolling replacement под четырьмя потоками записи занял 115.800 s. Наблюдались
четыре instance ID, 12,147 успешных записей и 177 ошибок: 67.439 successful RPS,
error ratio 1.4362%, p50/p95/p99 успешных запросов 37.729/189.374/215.986 ms.
Ошибки не скрывались клиентским retry. Это closed-loop опыт на одном host;
percentiles не включают ошибки и подвержены coordinated omission.
1. ищет запись в `message_idempotency`;
2. при совпадающем SHA-256 возвращает ранее созданное сообщение;
3. при другом теле отвечает `409 Conflict`;
4. при новом ключе создаёт `messages` и `message_idempotency` в одной
транзакции.
### Ресурсы, storage и обновление
Сообщение и запись идемпотентности фиксируются атомарно. Если клиент не получил
ответ, он безопасно повторяет запрос с тем же ключом через любую реплику.
Записи живут не менее 24 часов. Коллизия 64-битного хеша advisory lock только
лишний раз сериализует разные ключи: полная область проверяется primary key.
Каждая API-реплика ограничена 0.75 CPU и 768 MiB, Nginx — 0.25 CPU и 128 MiB.
Только Nginx публикует host port. Постоянные volumes принадлежат только
PostgreSQL и Redis; API/Nginx остаются stateless. `container_name` отсутствует.
Nginx разрешает `non_idempotent` retry только для endpoint сообщения. Тело
буферизуется, а общая идемпотентность делает повтор безопасным. Остальные POST
после начала отправки автоматически не повторяются.
`scripts/rolling-update.*` удаляет и заменяет по одной исходной API-реплике,
ожидая health новой перед следующей. V3 является additive-миграцией: создаёт
новую таблицу/индекс, не меняя lab2-таблицы. Старая версия продолжает работать,
пока новая схема уже применена. Новая версия требует V3 для readiness.
Автоматический downgrade схемы не поддерживается; rollback приложения оставляет
Результат `student_tests/idempotency_concurrent.py`: 32 одновременных запроса с
одним ключом прошли через два `X-Instance-Id` и создали ровно одно сообщение.
## 8. Проверка отказа API-реплик
`scripts/stop-one.sh` (Windows: `stop-one.cmd`) получает наблюдаемый
`X-Instance-Id`, сопоставляет его hostname контейнера и останавливает выбранную
API-реплику. Нагрузка идёт только через Nginx.
```sh
chmod +x scripts/stop-one.sh scripts/restore-api.sh
make test-failover-each \
ACTION_SCRIPT=scripts/stop-one.sh \
RESTORE_SCRIPT=scripts/restore-api.sh
```
Предыдущая реплика восстанавливается и снова наблюдается через LB до остановки
следующей. В Windows используются одноимённые `.cmd`-скрипты.
Фактические результаты 03.11.2026:
| Реплика | Чтения | Записи | Ошибки | Successful RPS | Первая успешная операция после stop |
| --- | ---: | ---: | ---: | ---: | ---: |
| `170796a1dad0` | 81 | 82 | 0 | 10,839 | 1,306 s |
| `feb12e05fd43` | 75 | 76 | 0 | 10,014 | 2,672 s |
Обе реплики до опытов были видны по `X-Instance-Id`. Во время отказа
продолжались чтения и идемпотентные записи, подтверждённые сообщения остались
доступны. Raw-результат: `evidence/failover-each-2026-11-03.json`.
## 9. Persistence и сохранение сессии
```sh
make test-persistence ACTION_SCRIPT=scripts/restart.sh
```
`restart.sh` перезапускает зависимости без удаления volumes, выполняет
однократную миграцию и поднимает две API-реплики. Тест использует созданный до
рестарта Bearer token и проверяет прежние данные. Корректность обеспечивает
PostgreSQL, а не память API и не Redis.
## 10. Ресурсы и изоляция
- каждая Compose API-реплика: 0,75 CPU и 768 MiB;
- Nginx: 0,25 CPU и 128 MiB;
- API не публикует host port;
- volumes есть только у PostgreSQL и Redis;
- `container_name` отсутствует;
- API/Nginx не имеют состояния, необходимого для корректности.
В Swarm PostgreSQL ограничен 1 CPU/768 MiB, Redis — 0,25 CPU/256 MiB.
## 11. Rolling update под нагрузкой
`scripts/rolling-update.sh` по очереди заменяет каждую исходную API-реплику и
ждёт readiness новой. Одновременно `student_tests/rolling_update.py` держит
четыре закрытых потока записи:
```sh
make test-rolling ACTION_SCRIPT=scripts/rolling-update.sh
```
Фактический опыт 03.11.2026:
- нагрузка — 180,118 s, замена — 115,800 s;
- наблюдались четыре `X-Instance-Id`: две старые и две новые реплики;
- 12 147 успешных записей и 177 ошибок;
- successful RPS — 67,439; error ratio — 1,4362%;
- latency успешных запросов: p50 37,729 ms, p95 189,374 ms,
p99 215,986 ms.
Ошибки не скрыты клиентским retry. Это closed-loop измерение на одном host;
percentiles не включают ошибки и подвержены coordinated omission. Raw:
`evidence/rolling-update-2026-11-03.json`.
V3 обратно совместима: она только добавляет таблицу и индекс. Старая версия
работает после применения V3, новая не становится ready до появления V3.
Автоматический downgrade не реализован; rollback приложения оставит
неиспользуемую V3-таблицу.
## Ограничения
## 12. Уровень 5: отказ целого узла
Стенд переживает отказ одного API-процесса, но PostgreSQL, Nginx и Docker host
остаются SPOF. Redis не является источником корректности. Nginx OSS использует
пассивную, а не активную upstream-проверку; Docker health/readiness предотвращает
первичный старт до готовности, а runtime-отказ обнаруживается первой ошибкой и
DNS/passive таймерами. Секрет в `.env` допустим только для локальной учебной
машины; для production нужен secret manager/Compose secrets.
### 12.1. Гипотеза
Если две stateless API-задачи распределены по разным Swarm-узлам, есть
свободный узел, а общий PostgreSQL работает, потеря worker с API приведёт к
созданию новой задачи на живом узле. Через Nginx продолжатся чтение и запись, а
подтверждённые данные сохранятся.
Гипотеза не утверждает выживание узла PostgreSQL: БД не реплицирована.
### 12.2. Топология и образы
Одноразовый стенд содержит три независимых Docker daemon в privileged DinD:
`hla-swarm-manager`, `hla-swarm-worker1`, `hla-swarm-worker2`.
API имеет две задачи, `endpoint_mode: dnsrr` и
`max_replicas_per_node: 1`. Третий узел оставляет место для переноса. Nginx
обращается к `tasks.hla-app_api:8080` через overlay DNS.
`scripts/swarm-lab-up.ps1` собирает API и Nginx из текущего репозитория,
публикует `hla-swarm-registry:5000/hla-lab3-*:swarm` в одноразовый registry и
разворачивает образы на узлах по digest. Затем создаётся overlay network,
разворачивается state stack, отдельно выполняется migration job и запускается
app stack.
```powershell
make swarm-up
make test-node-failover PYTHON=python
make swarm-down
```
Swarm Nginx доступен на `http://localhost:18080`, отдельно от Compose на 8080.
### 12.3. Методика
`student_tests/node_failover.py`:
1. проверяет не менее двух API tasks и instance ID;
2. создаёт контрольное сообщение;
3. находит worker, реально выполняющий API task;
4. жёстко останавливает весь внешний DinD-контейнер worker;
5. 30 s выполняет через Nginx чтения и идемпотентные записи;
6. проверяет новую task ID на другом узле и новый `X-Instance-Id`;
7. читает контрольное и все подтверждённые сообщения;
8. возвращает worker и ждёт `Ready`.
### 12.4. Результат
03.11.2026 полностью остановлен `hla-swarm-worker2`.
| Параметр | Результат |
| --- | --- |
| Старая task | `sesmka0dxn5k` на `hla-swarm-worker2` |
| Новая task | `pke5uf5okm69` на `hla-swarm-worker1` |
| Instance ID до | `1726221ff80d`, `edb5532a721e` |
| Instance ID после | `1726221ff80d`, `81c7197f2bfe` |
| Успешные чтения / записи | 165 / 166 |
| Ошибки | 0 |
| Первая успешная операция | 1,796 s |
| Successful RPS | 11,033 |
| Полное время с возвратом узла | 73,763 s |
| Подтверждённые данные сохранены | да |
API-задача реально перенесена между Docker daemon. Контрольное сообщение и все
подтверждённые во время отказа операции сохранились. Результаты:
`evidence/node-failover-2026-11-03.json` и
`evidence/node-failover-2026-11-03.md`.
В JSON записано `database_node_failed=false`: узел БД не падал, и выживание
PostgreSQL не заявляется.
### 12.5. Оставшиеся SPOF
| SPOF | Причина | Что требуется для production |
| --- | --- | --- |
| Nginx | одна задача на manager | несколько LB за внешним L4/VIP или managed LB |
| PostgreSQL | одна реплика на manager | репликация, автоматический failover, проверка RPO/RTO |
| Redis | одна реплика | Sentinel/Cluster, если требуется HA кэша |
| Swarm control plane | один manager | 3 или 5 manager-узлов для Raft quorum |
| Storage | локальные volumes manager | реплицированное/сетевое хранилище и fencing |
| Underlay/host | DinD на одном компьютере | разные hosts и резервирование сети |
Доказан failover API-worker при живом state/LB-узле. Потеря manager, DB, LB,
storage или физического host не переживается и не заявляется.
## 13. Команды проверок и доказательства
Дополнительные проверки находятся в `student_tests`; исходные тесты курса — в
`tests`, Spring-тесты — в `src/test/java`.
| Требование | Команда / доказательство | Результат |
| --- | --- | --- |
| Структура и синтаксис | `make check` | PASS |
| Основной API через LB | `make test` | PASS |
| Общая идемпотентность | `make test-idempotency` | 32 запроса, 2 реплики, 1 сообщение |
| Persistence | `make test-persistence ACTION_SCRIPT=scripts/restart.sh` | прежние token и данные доступны |
| Выбранная реплика | `make test-failover ACTION_SCRIPT=scripts/stop-one.sh` | чтение/запись продолжаются |
| Каждая реплика | `make test-failover-each ...` | 0 ошибок, recovery 1,306/2,672 s |
| Rolling update | `make test-rolling ...` | 4 instance ID, 12 147 успешных записей |
| Потеря worker | `make test-node-failover` | task перенесена, 0 ошибок, данные сохранены |
| Compose config | `docker compose --env-file .env config --quiet` | exit 0 |
Сводка уровня 4: `evidence/level4-2026-11-03.md`. Числа опытов сохранены в
машиночитаемых JSON в `evidence/`.
На Windows Python может использовать cp1251. Для чтения UTF-8 OpenAPI:
```powershell
$env:PYTHONUTF8='1'
make test PYTHON=python
```
## 14. Соответствие критериям
### Уровень 3
- `compose.yaml`, две API-реплики, одна публичная точка, общие БД и сессии;
- запросы одного пользователя идут на разные `X-Instance-Id` без нового login;
- отказ любой API-реплики проверен при чтении и записи;
- конкурентный повтор `Idempotency-Key` не создаёт дубль;
- smoke, persistence и failover выполняются через LB.
### Уровень 4
- readiness, DNS refresh, timeouts и graceful shutdown согласованы;
- обе реплики остановлены по очереди с RPS, errors и recovery;
- заданы CPU/RAM limits, API-порты не опубликованы, `container_name` нет;
- rolling replacement проверен под нагрузкой;
- миграция запускается отдельно и является additive/backward-compatible.
### Уровень 5, трек «Отказ узла»
- создано три Docker-узла;
- потерян узел, реально выполнявший API task;
- Swarm создал новую task на другом daemon;
- чтение/запись продолжались, данные сохранились;
- разобраны SPOF LB, DB, control plane и storage;
- отказ DB не проверялся и не заявлен.
## 15. Ограничения
Измерения выполнены локально на Windows с Docker Desktop. DinD даёт отдельные
Docker daemon и реальный Swarm rescheduling, но не моделирует отключение разных
физических серверов. Результаты нагрузки зависят от host и не являются
production benchmark. Nginx OSS использует пассивное runtime-исключение. TLS и
внешний HA ingress в лабораторный стенд не входят.
## 16. Использование ИИ и внешней помощи
ИИ использовался для обсуждения Compose/Nginx, readiness/graceful shutdown,
общей идемпотентности, дополнительных сценариев `student_tests`, Swarm-опыта и
редактирования отчёта. Поведение подтверждено запускаемыми тестами и raw JSON.
Заимствованный прикладной код стороннего сервера не использовался; применены
стандартные open-source зависимости из build-файлов проекта.
+3 -3
View File
@@ -9,7 +9,7 @@ used Nginx at `http://localhost:8080`; API ports were not published.
Command:
```text
python tests/failover_each.py --action-script scripts/stop-one.cmd \
python student_tests/failover_each.py --action-script scripts/stop-one.cmd \
--restore-script scripts/restore-api.cmd --window 15 \
--output evidence/failover-each-2026-11-03.json
```
@@ -24,7 +24,7 @@ stopped. Confirmed messages remained readable after both failures.
## Shared idempotency
`python tests/idempotency_concurrent.py` passed: 32 concurrent requests with
`python student_tests/idempotency_concurrent.py` passed: 32 concurrent requests with
one key used two API instance IDs and created exactly one message.
## Sequential replacement under load
@@ -32,7 +32,7 @@ one key used two API instance IDs and created exactly one message.
Command:
```text
python tests/rolling_update.py --action-script scripts/rolling-update.cmd \
python student_tests/rolling_update.py --action-script scripts/rolling-update.cmd \
--duration 180 --concurrency 4 \
--output evidence/rolling-update-2026-11-03.json
```
+42
View File
@@ -0,0 +1,42 @@
{
"scenario": "hard loss of one Swarm worker",
"failed_node": "hla-swarm-worker2",
"old_task_id": "sesmka0dxn5k",
"tasks_before": [
{
"task_id": "zmboecjxvdyn",
"node": "hla-swarm-manager"
},
{
"task_id": "sesmka0dxn5k",
"node": "hla-swarm-worker2"
}
],
"tasks_after_relocation": [
{
"task_id": "zmboecjxvdyn",
"node": "hla-swarm-manager"
},
{
"task_id": "pke5uf5okm69",
"node": "hla-swarm-worker1"
}
],
"instance_ids_before": [
"1726221ff80d",
"edb5532a721e"
],
"instance_ids_after": [
"1726221ff80d",
"81c7197f2bfe"
],
"successful_reads": 165,
"successful_writes": 166,
"failed_attempts": 0,
"first_recovery_seconds": 1.796,
"successful_rps": 11.033,
"experiment_seconds_including_rejoin": 73.763,
"confirmed_data_preserved": true,
"database_node_failed": false,
"note": "PostgreSQL, Nginx, manager quorum and local volumes are not protected by this experiment."
}
+33
View File
@@ -0,0 +1,33 @@
# Swarm worker-node failover — 2026-11-03
Topology: one Swarm manager and two workers, implemented as three privileged
Docker-in-Docker daemons. Two API tasks used `max_replicas_per_node=1`. Nginx,
PostgreSQL and Redis remained on the live manager. Images were pulled by nodes
from the disposable local registry by digest.
Command:
```text
python student_tests/node_failover.py --base-url http://localhost:18080 \
--window 30 --output evidence/node-failover-2026-11-03.json
```
Observed result:
- Hard-stopped node: `hla-swarm-worker2` (the entire nested Docker daemon).
- Old API task: `sesmka0dxn5k` on `worker2`.
- Replacement API task: `pke5uf5okm69` on `worker1`.
- Other API task remained on manager.
- Instance IDs changed from `1726221ff80d` / `edb5532a721e` to
`1726221ff80d` / `81c7197f2bfe`.
- Successful reads: 165; successful writes: 166; failed attempts: 0.
- First successful operation after node-stop started: 1.796 s.
- Successful operations per second during the 30 s window: 11.033.
- The pre-failure confirmed message and every response-confirmed in-flight
message remained readable.
- The stopped worker rejoined in `Ready` state after the experiment.
Protected scope: loss of one worker carrying an API task while manager/state
remain alive. Not protected and not claimed: PostgreSQL node loss, manager
quorum loss, Nginx loss, local-volume loss, underlay loss, or physical host
loss. `database_node_failed` is explicitly `false` in the raw JSON.
+13
View File
@@ -39,3 +39,16 @@ lab2. Поэтому старая версия может продолжать
замены, но новая версия не станет ready до применения V3. Автоматический
downgrade схемы не реализован; rollback приложения оставляет неиспользуемую
таблицу V3.
## Swarm node-failover topology
`swarm/stack.state.yaml` и `swarm/stack.app.yaml` описывают дополнительный
трёхузловой стенд. API имеет две задачи, `max_replicas_per_node=1` и доступный
третий узел для переноса. Nginx использует `tasks.hla-app_api` через overlay DNS.
State и LB намеренно закреплены на единственном manager, чтобы граница опыта
была явной. Защищаемая зависимость — процесс API на worker: при потере worker
Swarm переносит задачу, а сессии/сообщения остаются в PostgreSQL на живом
manager. PostgreSQL не реплицирован, его volume локален; потеря DB/manager не
переживается. Также остаются SPOF: Nginx, manager quorum, локальные volumes,
Docker underlay и физический host, на котором запущена учебная DinD-модель.
+19
View File
@@ -0,0 +1,19 @@
$ErrorActionPreference = 'Continue'
if (Test-Path variable:PSNativeCommandUseErrorActionPreference) {
$PSNativeCommandUseErrorActionPreference = $false
}
$nodes = @('hla-swarm-manager', 'hla-swarm-worker1', 'hla-swarm-worker2', 'hla-swarm-registry')
foreach ($node in $nodes) {
$existing = (& docker ps --all --filter "name=^/${node}$" --format '{{.Names}}')
if ($existing -eq $node) {
docker rm --force $node | Out-Null
if ($LASTEXITCODE -ne 0) { throw "Cannot remove $node" }
}
}
$existingNetwork = (& docker network ls --filter 'name=^hla-swarm-underlay$' --format '{{.Name}}')
if ($existingNetwork -eq 'hla-swarm-underlay') {
docker network rm hla-swarm-underlay | Out-Null
if ($LASTEXITCODE -ne 0) { throw 'Cannot remove hla-swarm-underlay' }
}
Write-Output 'Removed the disposable three-node Swarm lab and its nested volumes.'
+138
View File
@@ -0,0 +1,138 @@
$ErrorActionPreference = 'Continue'
if (Test-Path variable:PSNativeCommandUseErrorActionPreference) {
$PSNativeCommandUseErrorActionPreference = $false
}
$projectDir = Split-Path -Parent $PSScriptRoot
Set-Location $projectDir
$manager = 'hla-swarm-manager'
$nodes = @($manager, 'hla-swarm-worker1', 'hla-swarm-worker2')
$network = 'hla-swarm-underlay'
$registry = 'hla-swarm-registry'
function Invoke-Checked {
param([Parameter(ValueFromRemainingArguments = $true)][string[]]$Command)
$executable = $Command[0]
$arguments = if ($Command.Length -gt 1) {
$Command[1..($Command.Length - 1)]
} else {
@()
}
& $executable @arguments
if ($LASTEXITCODE -ne 0) {
throw "Command failed: $($Command -join ' ')"
}
}
function Wait-InnerDocker([string]$Node) {
$deadline = (Get-Date).AddSeconds(90)
do {
& docker exec $Node docker info *> $null
if ($LASTEXITCODE -eq 0) { return }
Start-Sleep -Seconds 2
} while ((Get-Date) -lt $deadline)
throw "Docker daemon did not start in $Node"
}
function Wait-Service([string]$Service, [string]$Expected, [int]$Seconds = 180) {
$deadline = (Get-Date).AddSeconds($Seconds)
do {
$replicas = (& docker exec $manager docker service ls `
--filter "name=$Service" --format '{{.Replicas}}' 2>$null | Select-Object -First 1)
if ($replicas -like "$Expected*") { return }
Start-Sleep -Seconds 2
} while ((Get-Date) -lt $deadline)
throw "Service $Service did not reach $Expected replicas"
}
foreach ($node in $nodes) {
$existing = (& docker ps --all --filter "name=^/${node}$" --format '{{.Names}}')
if ($existing -eq $node) {
throw "Container $node already exists. Run scripts/swarm-lab-down.ps1 first."
}
}
$existingRegistry = (& docker ps --all --filter "name=^/${registry}$" --format '{{.Names}}')
if ($existingRegistry -eq $registry) {
throw "Container $registry already exists. Run scripts/swarm-lab-down.ps1 first."
}
$envValues = @{}
Get-Content -LiteralPath '.env' | ForEach-Object {
if ($_ -match '^\s*([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)\s*$') {
$envValues[$matches[1]] = $matches[2].Trim('"', "'")
}
}
$password = $envValues['DATABASE_PASSWORD']
if ([string]::IsNullOrWhiteSpace($password)) { throw 'DATABASE_PASSWORD is missing from .env' }
$database = if ($envValues['DATABASE_NAME']) { $envValues['DATABASE_NAME'] } else { 'messenger' }
$user = if ($envValues['DATABASE_USER']) { $envValues['DATABASE_USER'] } else { 'messenger' }
$existingNetwork = (& docker network ls --filter "name=^${network}$" --format '{{.Name}}')
if ($existingNetwork -ne $network) { Invoke-Checked docker network create $network }
Invoke-Checked docker run --detach --name $registry --hostname $registry `
--network $network --publish 127.0.0.1:15000:5000 registry:2
Invoke-Checked docker run --privileged --detach --name $manager --hostname $manager `
--network $network --publish 127.0.0.1:18080:8080 `
--volume "${projectDir}:/project:ro" --env DOCKER_TLS_CERTDIR= docker:28-dind `
--storage-driver=overlay2 --insecure-registry=${registry}:5000
foreach ($worker in $nodes[1..2]) {
Invoke-Checked docker run --privileged --detach --name $worker --hostname $worker `
--network $network --env DOCKER_TLS_CERTDIR= docker:28-dind `
--storage-driver=overlay2 --insecure-registry=${registry}:5000
}
foreach ($node in $nodes) { Wait-InnerDocker $node }
$managerIp = (& docker inspect --format `
'{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' $manager).Trim()
Invoke-Checked docker exec $manager docker swarm init --advertise-addr $managerIp
$token = (& docker exec $manager docker swarm join-token --quiet worker).Trim()
foreach ($worker in $nodes[1..2]) {
Invoke-Checked docker exec $worker docker swarm join --token $token "$managerIp`:2377"
}
Invoke-Checked docker exec $manager docker node update `
--label-add hla.state=true --label-add hla.lb=true $manager
Invoke-Checked docker compose --env-file .env build api
Invoke-Checked docker tag hla-lab3-api:local localhost:15000/hla-lab3-api:swarm
Invoke-Checked docker build --file swarm/nginx.Dockerfile `
--tag localhost:15000/hla-lab3-nginx:swarm .
Invoke-Checked docker push localhost:15000/hla-lab3-api:swarm
Invoke-Checked docker push localhost:15000/hla-lab3-nginx:swarm
Invoke-Checked docker exec --env "DATABASE_PASSWORD=$password" `
--env "DATABASE_NAME=$database" --env "DATABASE_USER=$user" `
$manager docker stack deploy --compose-file /project/swarm/stack.state.yaml hla-state
Wait-Service 'hla-state_postgres' '1/1'
Wait-Service 'hla-state_redis' '1/1'
Invoke-Checked docker exec $manager docker service create --name hla-migrate `
--mode replicated-job --replicas 1 --max-concurrent 1 `
--network hla-state_backend --constraint node.labels.hla.state==true `
--restart-condition on-failure --restart-delay 3s `
--env "DATABASE_URL=jdbc:postgresql://hla-state_postgres:5432/$database" `
--env "DATABASE_USER=$user" --env "DATABASE_PASSWORD=$password" `
--env FLYWAY_ENABLED=true --env MIGRATE_ONLY=true `
--env SPRING_MAIN_WEB_APPLICATION_TYPE=none `
hla-swarm-registry:5000/hla-lab3-api:swarm
$deadline = (Get-Date).AddSeconds(180)
do {
$state = (& docker exec $manager docker service ps hla-migrate `
--no-trunc --format '{{.CurrentState}}' | Select-Object -First 1)
if ($state -like 'Complete*') { break }
Start-Sleep -Seconds 2
} while ((Get-Date) -lt $deadline)
if ($state -notlike 'Complete*') { throw 'Migration job did not complete' }
Invoke-Checked docker exec $manager docker service rm hla-migrate
Invoke-Checked docker exec --env "DATABASE_PASSWORD=$password" `
--env "DATABASE_NAME=$database" --env "DATABASE_USER=$user" `
$manager docker stack deploy --compose-file /project/swarm/stack.app.yaml hla-app
Wait-Service 'hla-app_api' '2/2'
Wait-Service 'hla-app_nginx' '1/1'
Write-Output 'Swarm lab is ready at http://localhost:18080'
Invoke-Checked docker exec $manager docker node ls
Invoke-Checked docker exec $manager docker service ps hla-app_api
+11
View File
@@ -0,0 +1,11 @@
# Student-owned tests
This directory contains additional experiments written for this implementation.
The course-provided black-box suite remains in `tests/`; Spring tests remain in
`src/test/java`.
- `idempotency_concurrent.py` — one key through multiple API replicas.
- `failover_each.py` — sequential process failover of both Compose replicas.
- `rolling_update.py` — sequential replacement under write load.
- `node_failover.py` — hard loss of one worker in the disposable three-node
Swarm lab, task relocation and confirmed-data verification.
@@ -4,10 +4,13 @@ import json
import os
from pathlib import Path
import subprocess
import sys
import time
import uuid
from urllib.parse import quote
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, arguments, check, run
@@ -1,8 +1,12 @@
#!/usr/bin/env python3
"""Prove that one idempotency scope is shared across API replicas."""
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
import sys
import uuid
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, arguments, check, run
+182
View File
@@ -0,0 +1,182 @@
#!/usr/bin/env python3
"""Hard-stop one Swarm worker and prove API task relocation and data safety."""
import json
import atexit
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
import subprocess
import sys
import time
import uuid
from urllib.parse import quote
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, arguments, check, run
def command(*parts, timeout=30):
result = subprocess.run(
parts, capture_output=True, text=True, timeout=timeout)
check(result.returncode == 0, 'command failed: ' + ' '.join(parts[:3]))
return result.stdout.strip()
def api_tasks(manager):
output = command(
'docker', 'exec', manager, 'docker', 'service', 'ps', 'hla-app_api',
'--filter', 'desired-state=running',
'--format', '{{.ID}}\t{{.Node}}\t{{.CurrentState}}')
result = []
for line in output.splitlines():
fields = line.split('\t')
if len(fields) == 3 and fields[2].startswith('Running'):
result.append({'task_id': fields[0], 'node': fields[1]})
return result
def history(client, actor, chat_id):
path = '/api/v1/chats/' + chat_id + '/messages?limit=100'
result = []
for _ in range(1000):
page = client.call('GET', path, actor=actor, schema='MessagePage')['json']
result.extend(page['items'])
if page['next_cursor'] is None:
return result
path = ('/api/v1/chats/' + chat_id + '/messages?limit=100&cursor='
+ quote(page['next_cursor'], safe=''))
raise Failure('history pagination exceeded safety bound')
def observe(client, actor, attempts=40):
def request(_):
local = Client(client.base, timeout=2)
return local.call(
'GET', '/api/v1/users/me', actor=actor, schema='User')
with ThreadPoolExecutor(max_workers=16) as pool:
responses = list(pool.map(request, range(attempts)))
return {response['headers']['X-Instance-Id'] for response in responses}
def restore_worker(manager, node):
subprocess.run(
['docker', 'start', node], stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL, timeout=30)
deadline = time.monotonic() + 90
status = ''
while time.monotonic() < deadline:
result = subprocess.run(
['docker', 'exec', manager, 'docker', 'node', 'ls',
'--filter', 'name=' + node, '--format', '{{.Status}}'],
capture_output=True, text=True, timeout=30)
status = result.stdout.strip()
if result.returncode == 0 and status == 'Ready':
return True
time.sleep(2)
return False
def main():
def configure(parser):
parser.add_argument('--manager-container', default='hla-swarm-manager')
parser.add_argument('--window', type=float, default=30)
parser.add_argument('--output', default=None)
args = arguments('Swarm worker loss and API relocation', configure)
check(15 <= args.window <= 120, 'window must be 15..120 seconds')
client = Client(args.base_url, args.ca_file, timeout=2)
alice, bob, _, chat = client.bootstrap()
before_instances = observe(client, alice)
check(len(before_instances) >= 2, 'expected two API instances before node loss')
before_tasks = api_tasks(args.manager_container)
check(len(before_tasks) == 2, 'expected two running API tasks')
candidates = [task for task in before_tasks
if task['node'].startswith('hla-swarm-worker')]
check(bool(candidates), 'no API task is running on a worker node')
victim = candidates[0]
confirmed_before = client.message(
alice, chat, 'confirmed-before-node-loss-' + uuid.uuid4().hex)['json']
started = time.monotonic()
command('docker', 'stop', '--time', '1', victim['node'], timeout=15)
restore_at_exit = lambda: restore_worker(args.manager_container, victim['node'])
atexit.register(restore_at_exit)
first_recovery = None
reads = writes = failures = 0
confirmed_during = []
key = uuid.uuid4().hex
text = 'during-node-loss-' + key
while time.monotonic() - started < args.window:
try:
if (reads + writes) % 2 == 0:
response = client.message(alice, chat, text, key=key)
confirmed_during.append(response['json'])
writes += 1
key = uuid.uuid4().hex
text = 'during-node-loss-' + key
else:
client.call('GET', '/api/v1/users/me', actor=bob, schema='User')
reads += 1
if first_recovery is None:
first_recovery = time.monotonic() - started
except Failure:
failures += 1
time.sleep(0.05)
deadline = time.monotonic() + 90
after_tasks = []
while time.monotonic() < deadline:
after_tasks = api_tasks(args.manager_container)
if (len(after_tasks) == 2
and all(task['node'] != victim['node'] for task in after_tasks)
and any(task['task_id'] != victim['task_id'] for task in after_tasks)):
break
time.sleep(2)
check(len(after_tasks) == 2, 'API service did not return to two tasks')
check(all(task['node'] != victim['node'] for task in after_tasks),
'API task was not relocated away from failed node')
check(first_recovery is not None and first_recovery <= 10,
'API did not recover within 10 seconds')
stored = history(client, bob, chat['id'])
stored_ids = {message['id'] for message in stored}
check(confirmed_before['id'] in stored_ids,
'pre-failure confirmed message was lost')
check(all(message['id'] in stored_ids for message in confirmed_during),
'message confirmed during node loss was lost')
check(restore_worker(args.manager_container, victim['node']),
'failed worker did not rejoin the Swarm')
atexit.unregister(restore_at_exit)
after_instances = observe(client, alice, attempts=96)
check(len(after_instances - before_instances) >= 1,
'replacement API process was not visible through X-Instance-Id')
elapsed = time.monotonic() - started
report = {
'scenario': 'hard loss of one Swarm worker',
'failed_node': victim['node'],
'old_task_id': victim['task_id'],
'tasks_before': before_tasks,
'tasks_after_relocation': after_tasks,
'instance_ids_before': sorted(before_instances),
'instance_ids_after': sorted(after_instances),
'successful_reads': reads,
'successful_writes': writes,
'failed_attempts': failures,
'first_recovery_seconds': round(first_recovery, 3),
'successful_rps': round((reads + writes) / args.window, 3),
'experiment_seconds_including_rejoin': round(elapsed, 3),
'confirmed_data_preserved': True,
'database_node_failed': False,
'note': ('PostgreSQL, Nginx, manager quorum and local volumes are not '
'protected by this experiment.'),
}
output = json.dumps(report, ensure_ascii=False, indent=2)
if args.output:
destination = Path(args.output)
destination.parent.mkdir(parents=True, exist_ok=True)
destination.write_text(output + '\n', encoding='utf-8')
print(output)
if __name__ == '__main__':
run(main)
@@ -6,9 +6,12 @@ import math
import os
from pathlib import Path
import subprocess
import sys
import threading
import time
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure, arguments, check, run
+3
View File
@@ -0,0 +1,3 @@
FROM nginx:1.27.4-bookworm
COPY swarm/nginx.conf /etc/nginx/nginx.conf
HEALTHCHECK --interval=2s --timeout=2s --retries=15 CMD nginx -t
+59
View File
@@ -0,0 +1,59 @@
worker_processes auto;
worker_shutdown_timeout 10s;
events {
worker_connections 1024;
}
http {
access_log /var/log/nginx/access.log;
error_log /var/log/nginx/error.log warn;
resolver 127.0.0.11 valid=2s ipv6=off;
resolver_timeout 1s;
upstream api_backend {
zone api_backend 64k;
least_conn;
server tasks.hla-app_api:8080 resolve max_fails=1 fail_timeout=2s;
keepalive 32;
}
server {
listen 80;
server_name _;
location = /nginx-health {
default_type application/json;
return 200 '{"status":"ok"}';
}
location ~ ^/api/v1/chats/[0-9a-fA-F-]+/messages$ {
proxy_pass http://api_backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_request_buffering on;
proxy_connect_timeout 500ms;
proxy_send_timeout 4s;
proxy_read_timeout 4s;
proxy_next_upstream error timeout http_502 http_503 http_504 non_idempotent;
proxy_next_upstream_tries 2;
}
location / {
proxy_pass http://api_backend;
proxy_http_version 1.1;
proxy_set_header Connection "";
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header X-Forwarded-Proto $scheme;
proxy_connect_timeout 500ms;
proxy_send_timeout 4s;
proxy_read_timeout 4s;
proxy_next_upstream error timeout http_502 http_503 http_504;
proxy_next_upstream_tries 2;
}
}
}
+75
View File
@@ -0,0 +1,75 @@
version: "3.9"
services:
api:
image: hla-swarm-registry:5000/hla-lab3-api:swarm
environment:
APP_HOST: 0.0.0.0
APP_PORT: 8080
DATABASE_URL: jdbc:postgresql://hla-state_postgres:5432/${DATABASE_NAME:-messenger}
DATABASE_USER: ${DATABASE_USER:-messenger}
DATABASE_PASSWORD: ${DATABASE_PASSWORD:?DATABASE_PASSWORD is required}
DATABASE_POOL_SIZE: 10
DATABASE_MIN_IDLE: 2
DATABASE_QUERY_TIMEOUT_SECONDS: 5
DATABASE_TRANSACTION_TIMEOUT_SECONDS: 5
REDIS_HOST: hla-state_redis
REDIS_PORT: 6379
REDIS_CONNECT_TIMEOUT: 1s
REDIS_COMMAND_TIMEOUT: 500ms
SESSION_TTL_SECONDS: 3600
USER_CACHE_TTL_SECONDS: 300
IDEMPOTENCY_TTL_SECONDS: 86400
FLYWAY_ENABLED: "false"
healthcheck:
test: ["CMD", "curl", "--fail", "--silent", "http://localhost:8080/health/ready"]
interval: 2s
timeout: 2s
retries: 20
start_period: 45s
networks: [backend]
deploy:
replicas: 2
endpoint_mode: dnsrr
placement:
max_replicas_per_node: 1
restart_policy:
condition: on-failure
delay: 2s
update_config:
parallelism: 1
order: start-first
monitor: 15s
failure_action: rollback
rollback_config:
parallelism: 1
order: stop-first
resources:
limits:
cpus: "0.75"
memory: 768M
nginx:
image: hla-swarm-registry:5000/hla-lab3-nginx:swarm
ports:
- target: 80
published: 8080
protocol: tcp
mode: ingress
networks: [backend]
deploy:
replicas: 1
placement:
constraints:
- node.labels.hla.lb == true
restart_policy:
condition: on-failure
resources:
limits:
cpus: "0.25"
memory: 128M
networks:
backend:
external: true
name: hla-state_backend
+60
View File
@@ -0,0 +1,60 @@
version: "3.9"
services:
postgres:
image: postgres:16.4-bookworm
environment:
POSTGRES_DB: ${DATABASE_NAME:-messenger}
POSTGRES_USER: ${DATABASE_USER:-messenger}
POSTGRES_PASSWORD: ${DATABASE_PASSWORD:?DATABASE_PASSWORD is required}
volumes:
- postgres-data:/var/lib/postgresql/data
healthcheck:
test: ["CMD-SHELL", "pg_isready -U $${POSTGRES_USER} -d $${POSTGRES_DB}"]
interval: 2s
timeout: 2s
retries: 30
networks: [backend]
deploy:
replicas: 1
placement:
constraints:
- node.labels.hla.state == true
restart_policy:
condition: on-failure
resources:
limits:
cpus: "1.00"
memory: 768M
redis:
image: redis:7.4-bookworm
command: ["redis-server", "--appendonly", "yes", "--appendfsync", "everysec"]
volumes:
- redis-data:/data
healthcheck:
test: ["CMD", "redis-cli", "ping"]
interval: 2s
timeout: 2s
retries: 30
networks: [backend]
deploy:
replicas: 1
placement:
constraints:
- node.labels.hla.state == true
restart_policy:
condition: on-failure
resources:
limits:
cpus: "0.25"
memory: 256M
networks:
backend:
driver: overlay
attachable: true
volumes:
postgres-data:
redis-data: