Files
mtusi2026lab3/REPORT.md
T
2026-10-15 19:44:46 +03:00

34 KiB
Raw Blame History

Отчёт — лабораторная 3

  • Автор, группа: Гаджиев Нухбала, БВТ2303
  • Целевая оценка; выбранный трек 5, если нужен: 4, трек 5 не выбран
  • Commit/PR: mtusi2026/mtusi2026lab3#9
  • Использованные источники, библиотеки и помощь ИИ: всё из lab2 (FastAPI, uvicorn, pydantic, psycopg 3 + psycopg-pool, argon2-cffi, valkey-py; версии в requirements.txt); образы haproxy:3.2.25-alpine, python:3.12.8-slim-bookworm, postgres:17.10-bookworm, valkey/valkey:8.1.9; документация HAProxy 3.2 (resolvers, server-template, http-check, retries, observe), Docker Compose (deploy.replicas и resources, depends_on с condition, healthcheck), PostgreSQL (INSERT ... ON CONFLICT, уникальные ограничения). ИИ использовался как вспомогательный ресурс: для оценки решения, написания комментариев к коду и составления текстовых документов.

Запуск из чистого clone

Проверял на Windows 11 в Git Bash: Docker Desktop (Docker 29.6.2, Compose 5.3.1 — evidence/stack.txt), Python 3 (нужен только для тестов, только стандартная библиотека), GNU Make. Образы закреплены в compose.yaml и Dockerfile: haproxy:3.2.25-alpine, python:3.12.8-slim-bookworm (основа образа API), postgres:17.10-bookworm, valkey/valkey:8.1.9. Перед запуском остановить стенд lab2 (docker compose -p mtusi-lab2 down из любой папки), иначе занят порт 8080.

git clone https://gitea.privcloud.tech/ng14/mtusi2026lab3.git && cd mtusi2026lab3
git checkout solution/bvt2303-gadzhiev
cp .env.example .env
sed -i 's/\r$//' .env                  # только Windows: убрать \r из .env
sh scripts/init-secrets.sh             # secrets/ со случайными паролями (каталог в .gitignore)
docker compose up -d --build --wait    # migrate -> 2 реплики api -> lb; ждёт healthy
make ps                                # api x2, lb, postgres, valkey: healthy; migrate: Exited (0)

make check PYTHON=python
make test PYTHON=python
make test-failover ACTION_SCRIPT=scripts/stop-one.cmd PYTHON=python     # Linux/macOS: scripts/stop-one.sh
make restore PYTHON=python                                             # вернуть реплику и дождаться её в HAProxy
make test-persistence ACTION_SCRIPT=scripts/restart.cmd PYTHON=python  # Linux/macOS: scripts/restart.sh

Собственные проверки (каждая печатает PASS/OK, вывод сохранён в evidence/): make student-test, race, db-test, expiry, failure-valkey, failure-postgres, failure-valkey-pause, cache-stats, explain (как в lab2) и новые make failover, persistence, failover-metrics, load-profile, rolling-update, check-stack, report-tables (с PYTHON=python на Windows). Все тесты ходят на http://127.0.0.1:8080 — это балансировщик.

Миграции применяет одноразовый сервис migrate при каждом docker compose up, отдельной команды нет. Для новой версии их можно применить заранее: docker compose run --rm migrate. Действие оператора одно: один раз создать секреты (sh scripts/init-secrets.sh), значения не выводятся и не попадают в Git.

Безопасная остановка: make down (контейнеры удаляются, volume pgdata остаётся). Намеренное удаление учебных данных: docker compose down -v, затем rm -rf secrets и заново sh scripts/init-secrets.sh.

Почему у hook два варианта: тест запускает hook напрямую, без shell, а Python на Windows не запускает .sh (WinError 193). Поэтому есть scripts/stop-one.cmd и scripts/restart.cmd для Windows и .sh для Linux/macOS. Логика stop-one одна (scripts/stop_one.py), оба варианта вызывают её. Остановленную реплику hook оставляет остановленной, вернуть её: make restore PYTHON=python (docker compose up -d --wait, затем ожидание, пока HAProxy снова возьмёт в работу все реплики).

Архитектура и решения

клиент --HTTP--> lb: HAProxy 3.2, 127.0.0.1:8080 (единственная точка входа; :8404 — статистика)
                  |  round robin, без привязки клиента к реплике
                  +--> api-1 --+
                  +--> api-2 --+--> postgres: пользователи, чаты, сообщения, ключи идемпотентности, сессии (volume pgdata)
                               +--> valkey: общий кэш сессий (без persistence)
migrate (одноразовый): применяет migrations/*.sql до старта api и завершается с кодом 0
сети: edge (lb <-> api) и backend (api, migrate <-> postgres, valkey; internal — без выхода наружу)
Роль Сервис Версия Health / готовность Volume Сеть / порт Credentials
Балансировщик lb haproxy:3.2.25-alpine /lb-health на :8404 (есть куда отправить запрос) нет edge; 127.0.0.1:8080, :8081, :8404 не нужны
API ×2 api (deploy.replicas: 2) образ из Dockerfile (python:3.12.8-slim-bookworm) /health/ready: Docker раз в 5 с, HAProxy раз в 1 с нет edge + backend, портов наружу нет /run/secrets/database_url, cache_url
Миграции migrate тот же образ завершается с кодом 0 нет backend только database_url
База данных postgres postgres:17.10-bookworm pg_isready pgdata backend, 5432 POSTGRES_PASSWORD_FILE
Кэш сессий valkey valkey/valkey:8.1.9 valkey-cli ping (пользователь health) нет backend, 6379 ACL из secrets/valkey_users.acl

Что перенесено из lab2: весь код API (src/messenger), миграции 001–003, свои тесты, Dockerfile, compose.yaml, конфиг Valkey, scripts/init-secrets.sh, restart-скрипты. Данные и сессии и так лежали в PostgreSQL, кэш — в Valkey, поэтому в памяти реплики нет ничего, от чего зависит правильность ответа, и реплики взаимозаменяемы.

Что изменено в lab3:

  • compose.yaml: две реплики api без ports и container_name, балансировщик lb, одноразовый migrate, лимиты CPU/RAM у всех контейнеров, две сети. API с коротким TTL (api-short-ttl, только для make expiry) тоже доступен лишь через балансировщик (:8081).
  • infra/haproxy/haproxy.cfg: список реплик HAProxy берёт из DNS Docker (имя api -> IP всех запущенных реплик, перечитывается раз в 2 с), поэтому сам замечает остановленные и новые реплики. Sticky session нет.
  • X-Instance-Id в каждом ответе (middleware в api.py) — hostname контейнера, то есть его короткий ID. По заголовку контейнер сразу находится в make ps, а scripts/stop_one.py останавливает именно его.
  • Обязательный Idempotency-Key у POST сообщения (api.py, store.add_message, migrations/004_message_idempotency.sql).
  • Миграции больше не применяет API: это делает python -m messenger.migrate (сервис migrate). Реплика при старте только ждёт, пока схема станет актуальной (db.wait_for_schema).
  • Остановка по SIGTERM в два шага (__main__.py, DrainingServer).
  • Кэш сессий стал по-настоящему общим: у записей общее поколение sess:gen в Valkey (в lab2 поколение было своё у каждого процесса, это было записано в ограничениях lab2).

Идемпотентность. Ключ и SHA-256 тела запроса хранятся прямо в строке сообщения. Уникальное ограничение (chat_id, sender_id, idempotency_key) — это область ключа из контракта: пользователь + чат (метод и путь у ключа всегда POST .../messages). Запись — один INSERT ... ON CONFLICT DO NOTHING, поэтому сообщение и «запомненный результат» сохраняются атомарно, одной строкой. Ключ уже есть: то же тело (сравнивается хеш разобранного JSON, пробелы и порядок полей не важны) — тот же 201 и то же сообщение, другое тело — 409. Если два запроса с одним ключом пришли одновременно на разные реплики, PostgreSQL заставляет второй INSERT ждать конца транзакции первого, после чего второй читает готовую строку. Повтор снова проверяет сессию (middleware, 401) и членство в чате (404). Ответы 400/404/503 ничего не сохраняют, после них тот же ключ можно использовать. Ключ хранится столько же, сколько сообщение (удаления в API нет), то есть не меньше 24 ч.

Балансировщик, проверки и отказ реплики:

  • HAProxy раз в 1 с запрашивает /health/ready у каждой реплики (при смене состояния раз в 0,5 с, timeout check 1s). 2 неудачи подряд — реплика выведена, 2 удачи — возвращена. Худший случай для зависшей реплики: 1 + 1 + 0,5 + 1 ≈ 3,5 с. Ещё два пути быстрее: observe layer4 выводит реплику после первой же ошибки соединения у живого запроса, а DNS Docker перестаёт отдавать IP остановленного контейнера (HAProxy замечает за 2–4 с).
  • Плановая остановка (docker stop, SIGTERM): реплика сразу отвечает 503 на /health/ready, но ещё 3 с обслуживает запросы (SHUTDOWN_DRAIN_SECONDS); HAProxy за это время выводит её. Потом uvicorn закрывает приём и доделывает начатые запросы (не дольше 8 с: ожидание пула 3 с + statement_timeout 5 с). Docker ждёт 15 с (stop_grace_period), затем SIGKILL. Hook ждёт не дольше 8 с, поэтому укладывается в 10 с теста.
  • Таймауты согласованы снизу вверх: запрос к БД ≤ 8 с < timeout server 15s в HAProxy < 15 с stop_grace_period; timeout connect 1s.
  • HAProxy повторяет запрос только при ошибке соединения (запрос ещё не ушёл) и на другой реплике (retries 2, option redispatch). Уже отправленный POST сам не повторяет: это делает клиент с тем же Idempotency-Key.
  • Запросы получают только реплики, прошедшие проверку готовности, резервных серверов без проверки нет. Если не готова ни одна реплика (например, недоступна PostgreSQL), балансировщик сам отвечает 503 и запрос до API не передаёт, даже если реплика могла бы ответить из кэша. Ответы самого балансировщика (503, 502, 504) отдаются в формате ошибки контракта с X-Request-Id; X-Instance-Id у них нет, потому что ни одна реплика их не создавала.

Миграции. migrate запускается после healthy PostgreSQL, применяет новые файлы (учёт в schema_migrations, pg_advisory_lock от двух одновременных запусков) и завершается. api стартует только после его успешного завершения (depends_on: condition: service_completed_successfully). Миграция 004 только добавляет столбцы, которые могут быть NULL, поэтому совместима с уже работающей версией: старый код пишет сообщения без ключа. Порядок обновления: сначала docker compose run --rm migrate, потом замена реплик по одной (make rolling-update).

Сессии и общий кэш. Источник истины — таблица sessions в PostgreSQL. Valkey — общий для всех реплик кэш «hash токена -> пользователь», запись положила одна реплика — используют все. Отзыв после сбоя Valkey для нескольких реплик: каждая запись помечена поколением, текущее поколение лежит в Valkey (sess:gen) и читается тем же запросом MGET, что и запись. Каждая реплика раз в 1 с проверяет Valkey. Реплика, заметившая сбой, перестаёт пользоваться кэшем, а когда Valkey вернулся, сначала записывает новое поколение и только потом включает кэш. Записи до сбоя (в том числе запись сессии, отозванной во время сбоя) после этого не доверяет ни одна реплика: проверка идёт в PostgreSQL, там сессия отозвана — 401.

Соответствие .env.example:

Переменная Что делает в этом решении
APP_HOST, APP_PORT, APP_ENV где слушает uvicorn (0.0.0.0:8080), APP_ENV пишется в лог
SESSION_TTL_SECONDS срок жизни сессии (3600; у api-short-ttl — 2)
DATABASE_URL_FILE, CACHE_URL_FILE пути к секретам с адресами PostgreSQL и Valkey (/run/secrets/...)
SESSION_STORE=postgres источник истины сессий — PostgreSQL, Valkey — кэш
API_REPLICAS число реплик api (deploy.replicas в compose.yaml), по умолчанию 2
IDEMPOTENCY_TTL_SECONDS не используется: ключ хранится вместе с сообщением бессрочно (это не меньше 24 ч)
SHUTDOWN_DRAIN_SECONDS, GRACEFUL_SHUTDOWN_SECONDS остановка по SIGTERM: 3 с ухода из балансировки, затем до 8 с на начатые запросы
CACHE_CHECK_INTERVAL_SECONDS как часто каждая реплика проверяет Valkey (1 с)
SESSION_CACHE_TTL_SECONDS, DB_, CACHE_ как в lab2: TTL записи в кэше, размер пулов и таймауты

Доказательства критериев

Критерий README Команда/сценарий Наблюдаемый результат Файл доказательства
Публичный smoke make test PASS: lab3 public API scenario (в том числе повтор с ключом, 409, 400 без ключа) evidence/test.txt
Структура skeleton и контракт не изменены make check PASS: offline skeleton structure evidence/check.txt
Замечание к MR: резервные слоты fallback без проверки обходили readiness убраны из infra/haproxy/haproxy.cfg; make failure-postgres; make check-stack PostgreSQL остановлена: HAProxy за 2,5–2,8 с вывел обе реплики (изнутри контейнеров live 200, ready 503); /users/me с действующим токеном из кэша через LB — 503 от балансировщика без X-Instance-Id, до реплики не дошёл; запись не сохранилась; check-stack: в backend нет резервных серверов и серверов без проверки. На старом конфиге тот же тест падает (/users/me — 200) evidence/failure-postgres.txt, evidence/stack.txt
3: стенд в compose.yaml, одна команда; ≥2 API, одна точка входа, общая БД и общий кэш сессий docker compose up -d --build --wait; make check-stack 2 реплики api без портов; опубликован только lb на 127.0.0.1; одна postgres и один valkey evidence/stack.txt
3: запросы одного пользователя обслуживают разные реплики без повторного входа (X-Instance-Id) make student-test (test_one_session_is_served_by_every_replica), make demo 20 запросов с одним токеном — 2 разных X-Instance-Id по 10 раз; это ID запущенных контейнеров api evidence/student-test.txt
3: доступ через LB — основной маршрут все тесты на BASE_URL=http://127.0.0.1:8080 (HAProxy) порт наружу есть только у lb evidence/stack.txt
3: можно остановить любую одну реплику; ≤10 с — новые чтения/записи; подтверждённое на месте; ошибки измерены make failover (публичный test-failover для каждой реплики по очереди) PASS 2 раза; observed_instances_before 2; failed_attempts и first_recovery_seconds — в JSON-строке теста; остановлен именно контейнер из X-Instance-Id, остальные не тронуты evidence/failover.txt
3: повтор с тем же Idempotency-Key без дублей, включая конкурентный повтор и смену реплики make idempotency (входит в student-test); make failover повтор через другую реплику — тот же 201 и то же сообщение; 20 одновременных через 2 реплики — 1 сообщение; в failover-тесте дублей нет evidence/student-test.txt, evidence/failover.txt
3: make test, persistence и failover проходят; в failover ≥2 реплики make test; make persistence; make failover все PASS; observed_instances_before = 2 evidence/test.txt, persistence.txt, failover.txt
3: hook перезапуска реально перезапускает процессы make persistence (публичный test-persistence + время старта контейнеров) у api ×2, postgres, valkey и lb тот же ID и новое время старта; данные и прежний токен на месте evidence/persistence.txt
3: в API нет локальных сессий и данных test_logout_applies_on_every_replica, test_write_on_one_replica_read_on_another logout через одну реплику — 401 на обеих; запись через одну — сразу видна через другую evidence/student-test.txt
3: миграции отдельно и согласованно, не гонкой реплик сервис migrate; docker compose logs migrate api; make db-test «Миграции применены: 001…004» только в логе migrate, у реплик «Схема БД актуальна»; повторный migrate ничего не применяет evidence/stack.txt, evidence/db-test.txt
3: Swarm — выбран Compose, отдельная сборка образа для узлов не нужна —
3: возможности lab1/lab2 сохранены make student-test, race, db-test, expiry, failure-valkey, failure-postgres, failure-valkey-pause, explain — через балансировщик все PASS/OK; student-test: Ran 36 tests, OK; db-test: 7 тестов OK evidence/*.txt
4: health/readiness, таймауты и SIGTERM согласованы; LB исключает недоступную реплику; период проверок и время обнаружения infra/haproxy/haproxy.cfg, src/messenger/__main__.py; make failover-metrics проверка раз в 1 с (0,5 с при смене), 2 неудачи; худший случай ≈ 3,5 с; при docker stop реплика уходит из LB до выхода; измеренное время — в таблице ниже evidence/failover-metrics.txt
4: каждая реплика остановлена по очереди с восстановлением; RPS, ошибки, время восстановления make failover-metrics (stop и kill для каждой реплики) таблица ниже; потерь и дублей нет; остановленная реплика после остановки не отвечала evidence/failover-metrics.json
4: общая идемпотентность параллельными запросами с одним ключом make idempotency; make db-test 20 одновременных через 2 реплики — 1 сообщение; 10 разных тел — 201 ×1, 409 ×9; в БД 20 потоков — 1 строка evidence/student-test.txt, evidence/db-test.txt
4: CPU/RAM-лимиты; API без портов; секреты и хранилища общие только где нужно; нет container_name make check-stack PASS: лимиты у всех контейнеров; порты только у lb и только на 127.0.0.1; секреты по сервисам; postgres и valkey только во внутренней сети evidence/stack.txt
4: rolling update под нагрузкой make rolling-update 2 реплики заменены новой версией по одной; ошибки, RPS и задержки — ниже evidence/rolling-update.json
4: миграции однократно и совместимы с работающей версией сервис migrate; make db-test (test_old_version_insert_without_key_still_works); make rolling-update 004 только добавляет столбцы с NULL; INSERT без ключа, как в lab2, работает после 004; в rolling update migrate запускается один раз до замены реплик evidence/db-test.txt, evidence/rolling-update.txt
lab2-замечание для нескольких реплик: общий кэш и отзыв токена после сбоя Valkey make student-test (test_session_cache_is_shared_between_replicas); make failure-valkey-pause 10 запросов через 2 реплики — промахов кэша 0; после pause → logout → unpause отозванный токен всегда 401 evidence/student-test.txt, evidence/failure-valkey-pause.txt
Выбранный трек 5 — не выбран —

Эксперименты и отказы

Ноутбук: AMD Ryzen 7 4700U (8 ядер), 7,4 ГБ памяти, Windows 11, Docker Desktop. Лимиты контейнеров (compose.yaml): api — 1 CPU и 512 МиБ каждая реплика, postgres — 1 CPU и 512 МиБ, lb и valkey — по 0,5 CPU и 128 МиБ. Данные синтетические, их создают сами тесты. Нагрузка — простой closed-loop генератор на той же машине, поэтому RPS ограничен и клиентом, и лимитами CPU: это не предельная пропускная способность стенда. Под нагрузкой каждая реплика API упирается в свой лимит 1 CPU (около 100 % в таблице CPU/RAM), поэтому после остановки одной реплики число записей в секунду падает примерно вдвое: вся нагрузка ложится на оставшуюся. Это ожидаемо и не ошибка: запросы продолжают обслуживаться, потерь нет, после возврата реплики RPS восстанавливается.

Остановка каждой реплики под нагрузкой (make failover-metrics, evidence/failover-metrics.json): 4 потока пишут сообщения без пауз, 1 читает историю, timeout клиента 2 с, неподтверждённая запись повторяется с тем же ключом; 3 с до отказа и 10 с после. stop = docker stop (SIGTERM, плановая остановка), kill = docker kill (SIGKILL, авария).

Реплика Отказ Вывод из LB, с Ошибок (коды) Ошибки закончились через, с Записей/с до → после p95 записи после, мс Возврат в LB после docker start, с Потери / дубли
1c773748bc05 stop 1.16 0 (-) 0.0 114.7 → 65.9 125.0 4.5 0 / 0 (подтверждено 1006)
1c773748bc05 kill 0.11 1 (502: 1) 0.11 151.3 → 70.3 109.0 5.64 0 / 0 (подтверждено 1160)
aa3dac85e7ed stop 1.59 0 (-) 0.0 104.0 → 57.8 141.0 3.97 0 / 0 (подтверждено 892)
aa3dac85e7ed kill 0.25 1 (502: 1) 0.14 155.3 → 79.7 94.0 4.25 0 / 0 (подтверждено 1266)

Rolling update под той же нагрузкой (make rolling-update, evidence/rolling-update.json): версия dev → rolling-20261015-193851, 2 реплики заменены по одной за 22.38 с (1c773748bc05 → e8baa1b553a1: новая готова через 6.64 с, шаг 11.8 с; aa3dac85e7ed → db0d1f669f44: новая готова через 5.89 с, шаг 10.55 с). Записей/с до: 104.3, во время замены: 138.7; ошибок: 0 (-); p95 63.0 мс, максимум 312.0 мс; подтверждено 3867 сообщений, потерь и дублей нет.

Публичный генератор нагрузки (make load-profile = tests/load.py, closed loop, 4 потока, 30 с, 2 реплики): 130.05 успешных POST/с, ошибок 0 (доля 0.0), задержка успешных: p50 16.0 мс, p95 78.0 мс, p99 141.0 мс.

Сервис CPU, % макс. (100 % = 1 ядро) RAM макс. / лимит, МиБ
api 97.5 83 / 512
api 90.2 122 / 512
lb 24.2 20 / 128
postgres 31.1 52 / 512
valkey 9.6 8 / 128
Воздействие Что ожидаем Что наблюдали Время восстановления / потеря данных
docker stop одной реплики (по очереди каждой) реплика сама уходит из балансировки до выхода; ошибок нет ошибок всего 0 за 2 прогона; HAProxy вывел реплику не позже 1.59 с; остановленная реплика после остановки не отвечала ошибок не было; потерь и дублей 0
docker kill одной реплики (по очереди каждой) несколько 502 у запросов, начатых на ней; клиент повторяет с тем же ключом ошибок всего 2 за 2 прогона; HAProxy вывел реплику не позже 0.25 с; остановленная реплика после остановки не отвечала ошибки закончились не позже 0.14 с после отказа; потерь и дублей 0
Rolling update 2 реплик под нагрузкой замена по одной без простоя ошибок 0, записей/с 138.7 22.38 с на замену; потерь и дублей 0
Перезапуск всего стенда (make persistence, hook restart) данные и действующий токен сохраняются PASS: те же контейнеры с новым временем старта, прежний токен работает 19.6 с на весь тест (hook + готовность); потерь нет
docker compose stop valkey API работает без кэша ready 200; вход, сообщения и logout работают через PostgreSQL кэш снова включается за 1–2 с после start; потерь нет
docker compose stop postgres неготовые реплики исключены из маршрутизации, клиенту 503 HAProxy вывел обе реплики (ready 503, live 200); запрос с действующим токеном из кэша -> 503 от балансировщика, до реплики не дошёл; запись не сохранилась после start прежний токен и данные на месте; запросы во время отказа не сохранены (503)
docker compose pause valkey, logout, unpause отозванный токен не оживает ни на одной реплике после unpause отозванный токен всегда 401 поколение кэша сменилось после возвращения Valkey; отзыв не потерян

Ограничения и следующие шаги

  • Выдерживается отказ одной реплики API. Не выдерживается отказ единственных lb, postgres, valkey (без Valkey API работает, но медленнее) и всей машины: стенд на одном узле, это единые точки отказа.
  • При аварийной остановке реплики (SIGKILL) запросы, начатые на ней, получают 502 от HAProxy. Клиент повторяет POST сообщения с тем же ключом, дублей нет; HAProxy сам такие запросы не повторяет.
  • Первый запрос после внезапной остановки Valkey ждёт около 4 с (на нём обнаруживается сбой: подключение к пропавшему контейнеру на Docker Desktop), следующие идут без кэша сразу (10–30 мс), evidence/failure-valkey.txt.
  • Создание чата и регистрация по контракту не идемпотентны: их повтор после timeout может создать второй чат (регистрация получит 409).
  • Миграция 004 строит уникальный индекс: на большой таблице это заблокировало бы запись в messages. Для большой базы нужен CREATE UNIQUE INDEX CONCURRENTLY отдельным шагом; на учебной базе это доли секунды.
  • Rolling update сделан скриптом: Compose сам не заменяет реплики по одной (в Swarm это update_config: order: start-first).
  • X-Instance-Id раскрывает ID контейнера; в lab7 его нужно заменить случайным alias.
  • Ключи идемпотентности хранятся вместе с сообщениями бессрочно, индекс растёт вместе с числом сообщений.
  • Общее поколение кэша закрывает сценарий «отзыв во время сбоя Valkey» для всех реплик, которые заметили сбой. Если сбой Valkey короче интервала проверки (1 с) и logout пришёлся ровно на него, реплика, не заметившая сбой, теоретически может до следующей проверки другой реплики (≤ 1 с) доверять старой записи.
  • Если PostgreSQL недоступна, через балансировщик недоступно всё, включая /health/live (готовых реплик нет, HAProxy отвечает 503). Что сами реплики живы, видно изнутри контейнеров и по статистике HAProxy.
  • API подключается к PostgreSQL владельцем базы, Basic идёт по HTTP — только для локального стенда (минимальные права и TLS — lab7).