This commit is contained in:
Nurlygayanova Ekaterina
2026-11-05 17:56:30 +03:00
parent 0ab3a341aa
commit 1c95e2e68e
178 changed files with 21135 additions and 17 deletions
+95
View File
@@ -0,0 +1,95 @@
#!/bin/sh
# Публичный тест отказа для каждой реплики по очереди, с восстановлением между прогонами.
# Какую реплику остановить, выбирает тест, поэтому прогоны идут, пока не будет остановлена
# каждая (не больше MAX_RUNS). Результат: evidence/failover.txt
#
# Запуск из любого каталога при поднятом стенде: sh scripts/failover-evidence.sh
# Настройки через окружение: MAX_RUNS (лимит прогонов), BASE_URL (адрес балансировщика).
# Код выхода: 0, если остановлена и восстановлена каждая реплика, иначе 1.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Общие функции: compose, wait_lb_up (ждёт реплики в LB), git_state (текущий коммит).
. scripts/lb-lib.sh
# Файл с результатом; при каждом запуске перезаписывается.
OUT=evidence/failover.txt
# Лимит прогонов, чтобы цикл не шёл бесконечно, если тест не выберет какую-то реплику.
MAX_RUNS=${MAX_RUNS:-8}
# Порт берём из .env, если он там задан (при нескольких значениях последнее), иначе 8080.
PORT=$(sed -n 's/^API_PUBLISH_PORT=//p' .env | tail -n 1)
BASE_URL=${BASE_URL:-http://localhost:${PORT:-8080}}
# Имена работающих API-контейнеров по одному в строке. Остановленные compose ps не показывает,
# поэтому разница двух таких списков показывает, какая реплика остановлена.
api_names() { compose ps --format '{{.Name}}' api | sort; }
# Основная логика; весь её вывод попадает в файл результата (см. конец скрипта).
run() {
# Шапка доказательства: время и версия кода.
echo "# Failover $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
# Исходный список реплик: с ним сравниваем после каждого отказа.
all=$(api_names)
total=$(echo "$all" | wc -l | tr -d ' ')
echo "реплики: $(echo "$all" | tr '\n' ' ')"
# Healthy контейнера мало: тест должен начаться, когда все реплики видит сам LB.
wait_lb_up "$total" || return 1
# covered — реплики, которые уже останавливались; run_no — номер прогона.
covered=""
run_no=0
while [ "$run_no" -lt "$MAX_RUNS" ]; do
run_no=$((run_no + 1))
echo "## прогон $run_no"
# Тест останавливает реплику, ответившую на его первое сообщение. Число запросов до
# него постоянно, и round-robin выбирал бы одну и ту же реплику, поэтому сдвигаем очередь.
# Каждый прогон делает на один запрос больше предыдущего.
i=0
while [ "$i" -lt "$run_no" ]; do
curl -fsS -o /dev/null "$BASE_URL/health/live"
i=$((i + 1))
done
# Публичный тест: останавливает реплику через stop-one.sh и в это время отправляет
# сообщения. Проверяет восстановление записи за 10 с, сохранность данных и отсутствие дублей.
python3 tests/resilience.py --mode failover --action-script scripts/stop-one.sh --base-url "$BASE_URL" || return 1
# Какой контейнер пропал из работающих: это независимая проверка, а не слова теста.
# grep -vxF оставляет строки из исходного списка, которых нет в текущем.
stopped=$(echo "$all" | grep -vxF "$(api_names)" || true)
[ -n "$stopped" ] || { echo "реплика не была остановлена"; return 1; }
echo "остановлен контейнер: $stopped"
# Состояние контейнера от Docker: статус, код выхода и время остановки.
docker inspect -f ' {{.Name}} status={{.State.Status}} exit={{.State.ExitCode}} finished={{.State.FinishedAt}}' "$stopped"
echo "работают: $(api_names | tr '\n' ' ')"
# Отказ должен затронуть только API: зависимости продолжают работать.
echo "БД, сессии, LB: $(compose ps --format '{{.Service}}={{.State}}' postgres valkey lb | tr '\n' ' ')"
# Добавить реплику в covered, если её там ещё нет.
echo "$covered" | grep -qxF "$stopped" || covered=$(printf '%s\n%s' "$covered" "$stopped")
# Запустить остановленную реплику и дождаться, пока LB снова увидит все реплики.
compose up -d --wait >/dev/null 2>&1 || { echo "восстановление не удалось"; return 1; }
wait_lb_up "$total" || return 1
echo "восстановлено реплик: $total"
# Какие реплики ещё не останавливались. Если таких нет, проверка пройдена.
missing=$(echo "$all" | grep -vxF "$covered" || true)
if [ -z "$missing" ]; then
echo "PASS: остановлена и восстановлена каждая реплика, прогонов: $run_no"
return 0
fi
done
# Лимит прогонов исчерпан, а часть реплик так и не была остановлена.
echo "FAIL: за $MAX_RUNS прогонов не остановлены: $missing"
return 1
}
mkdir -p evidence
status=0
# Вызов через || отключает set -e внутри run, поэтому в ней ошибки обрабатываются через
# return 1. Код запоминаем, чтобы вывести файл на экран и при неудаче.
run > "$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+90
View File
@@ -0,0 +1,90 @@
#!/bin/sh
# 4: под постоянной нагрузкой по очереди роняет каждую API-реплику, восстанавливая
# предыдущую. Показывает RPS, ошибки и время восстановления, потери и дубли записей.
#
# Запуск из любого каталога: sh scripts/failover-load.sh stop (SIGTERM, штатное завершение)
# sh scripts/failover-load.sh kill (SIGKILL, аварийное падение)
# Настройка через окружение: CONCURRENCY (число клиентов, по умолчанию 16).
# Результат: evidence/level4/failover-<режим>.txt и .json. Файлы перезаписываются.
# Данные синтетические. Расписание рассчитано на 2 реплики: сводка считает фазы только для них.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Общие функции: compose, ожидание LB и контейнера, запуск loadgen, отсчёт времени замера.
. scripts/lb-lib.sh
# Режим отказа: первый аргумент, по умолчанию stop. Он же подкоманда docker: docker stop или docker kill.
MODE=${1:-stop}
# Любое другое значение отклоняем: оно попало бы прямо в команду docker.
case "$MODE" in
stop | kill) ;;
*) echo "usage: $0 stop|kill" >&2; exit 2 ;;
esac
CONCURRENCY=${CONCURRENCY:-16}
DIR=evidence/level4
OUT=$DIR/failover-$MODE.txt
# Основная логика; весь её вывод попадает в файл результата (см. конец скрипта).
run() {
# Шапка доказательства: режим, время и версия кода.
echo "# Failover под нагрузкой, режим $MODE, $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
# Поднять стенд, если он не запущен.
compose up -d --wait >/dev/null 2>&1 || return 1
# Запоминаем ID контейнеров: по ним же реплики запускаются обратно.
ids=$(compose ps -q api)
total=$(echo "$ids" | wc -l | tr -d ' ')
# Healthy контейнера мало: нагрузка должна начаться, когда все реплики видит сам LB.
wait_lb_up "$total" || return 1
echo "реплик: $total, профиль: concurrency=$CONCURRENCY, запись 20%, замер 60 с, прогрев 5 с"
# Фактические лимиты реплик от Docker: без них RPS нельзя сравнивать. $ids без кавычек
# намеренно: каждый ID должен стать отдельным аргументом.
docker inspect -f '{{.Name}} cpus={{.HostConfig.NanoCpus}} memory={{.HostConfig.Memory}}' $ids
# Запустить генератор в фоне и дождаться начала замера: от него отсчитывается время t.
# /evidence — каталог внутри контейнера loadgen, он смонтирован из ./evidence проекта.
start_loadgen -duration 60s -warmup 5s -concurrency "$CONCURRENCY" -label "failover-$MODE" \
-out "/evidence/level4/failover-$MODE.json" || return 1
# Секунда замера, на которой роняем очередную реплику. Расписание: отказ на 10 и 32 с,
# запуск на 20 и 42 с. Эти же секунды заданы в failover-summary.py: менять только вместе.
at=10
for id in $ids; do
name=$(docker inspect -f '{{.Name}}' "$id")
sleep_until "$at"
echo "t=$(elapsed)s docker $MODE $name"
# Отказ реплики. docker stop блокируется, пока реплика не завершит запросы и не выйдет,
# поэтому в режиме stop время следующей строки — конец docker stop, а не момент вывода из LB.
docker "$MODE" "$id" >/dev/null
# Дождаться, пока LB оставит на одну реплику меньше.
wait_lb_up "$((total - 1))" || return 1
echo "t=$(elapsed)s LB вывел реплику; работает реплик: $(lb_up_count)"
# Реплика лежит до 10-й секунды от начала своего отказа, затем запускается.
sleep_until "$((at + 10))"
docker start "$id" >/dev/null
echo "t=$(elapsed)s docker start $name"
# Восстановление считается завершённым, когда реплику снова видит LB.
wait_lb_up "$total" || return 1
echo "t=$(elapsed)s LB вернул реплику; работает реплик: $(lb_up_count)"
# Следующий отказ — только после полного восстановления этой реплики:
# в каждый момент отказывает не больше одной.
wait_healthy "$id" || return 1
at=$((at + 22))
done
echo "## результат loadgen"
# Дождаться конца нагрузки и вывести итог. Генератор сам сверяет историю сообщений и
# завершается с ошибкой, если нашёл потерянные записи или дубли.
finish_loadgen || return 1
echo "## сводка по фазам"
# RPS до отказа, при одной реплике и после возврата, время восстановления, ошибки.
python3 scripts/failover-summary.py "$DIR/failover-$MODE.json"
}
mkdir -p "$DIR"
status=0
# Вызов через || отключает set -e внутри run, поэтому в ней ошибки обрабатываются через
# return 1. Код запоминаем, чтобы вывести файл на экран и при неудаче.
run >"$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+51
View File
@@ -0,0 +1,51 @@
#!/usr/bin/env python3
"""Сводка результата loadgen: RPS по фазам отказа и время возврата к исходной ёмкости.
Секунды отказов берутся из расписания failover-load.sh: отказ на 10 и 32 с, запуск на 20 и 42 с."""
# Запуск: python3 scripts/failover-summary.py evidence/level4/failover-stop.json
# Вызывается в конце failover-load.sh. Только читает JSON и печатает сводку.
# Рассчитан на 2 отказа по расписанию выше: при другом числе реплик сводка будет неверной.
import json
import statistics
import sys
# Результат loadgen: путь передаётся первым аргументом.
data = json.load(open(sys.argv[1], encoding='utf8'))
# Посекундная шкала замера: номер секунды -> число успешных запросов и число ошибок.
ok = {s['t']: s['ok'] for s in data['timeline']}
errors = {s['t']: s['err'] for s in data['timeline']}
# Исходная ёмкость: средний RPS за первые 10 секунд, пока работают все реплики.
base = statistics.mean(ok[t] for t in range(0, 10))
# Средний RPS на секундах от a включительно до b не включая.
def mean(a, b):
return round(statistics.mean(ok[t] for t in range(a, b)))
print('исходный RPS (0-9 с): %d' % round(base))
# Фазы отказа: секунда отказа, секунда запуска реплики и секунда конца наблюдения
# (начало следующего отказа или конец 60-секундного замера). Реплики нумеруются с 1.
for number, (fail, start, stable) in enumerate(((10, 20, 32), (32, 42, 60)), 1):
# Первая секунда после отказа, где RPS ниже 75% исходного: ёмкость заметно упала.
# None, если RPS так и не опустился ниже порога.
half = next((t for t in range(fail, start) if ok[t] < base * 0.75), None)
# Первая секунда после запуска, где RPS снова не ниже 90% исходного: ёмкость вернулась.
# None, если до конца фазы RPS не вернулся.
back = next((t for t in range(start, stable) if ok[t] >= base * 0.9), None)
# RPS при одной реплике считается с 3-й секунды после отказа, а RPS после возврата —
# со 2-й секунды после запуска: переходные секунды исказили бы среднее.
# Окно ошибок сдвинуто на секунду назад: часы скрипта и генератора расходятся до 1 с.
# Конец окна тоже сдвинут, поэтому окна двух реплик стыкуются и не считают ошибку дважды.
print('реплика %d: RPS при одной реплике %d, ёмкость упала на %s с, вернулась на %s с (через %s с после docker start), '
'RPS после возврата %d, ошибок в окне %d' % (
number, mean(fail + 3, start), half, back, back - start if back is not None else '-',
mean(start + 2, stable), sum(errors[t] for t in range(fail - 1, stable - 1))))
# Итоги всего замера, которые loadgen уже посчитал сам: печатаются без пересчёта.
# Секунды, в которые не было ни одного успешного запроса (полная недоступность).
print('секунд без единого успеха: %d' % data['seconds_without_success'])
# Ошибки по типам и записи, подтверждённые только после повтора с тем же ключом идемпотентности.
print('ошибки: %s; записей подтверждено после повтора: %d' % (data['errors'], data['writes_confirmed_after_retry']))
# Эпизоды ошибок: начало, длительность и количество.
print('инциденты: %s' % json.dumps(data['error_incidents'], ensure_ascii=False))
# Сверка истории с подтверждёнными записями: потери и дубли.
print('проверка истории: %s' % json.dumps(data['verify'], ensure_ascii=False))
+40
View File
@@ -0,0 +1,40 @@
#!/bin/sh
# Замеры обнаружения отказа и graceful shutdown. Результат: evidence/failure-detection.txt
#
# Запуск из любого каталога при поднятом стенде с двумя репликами:
# sh scripts/failure-detection-evidence.sh
# Сами замеры выполняет scripts/failure-detection.py, здесь только запуск и сохранение вывода.
# Реплики и Valkey на время замеров останавливаются, затем восстанавливаются. Файл перезаписывается.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Общие функции: здесь нужна git_state (текущий коммит).
. scripts/lb-lib.sh
OUT=evidence/failure-detection.txt
# Основная логика; весь её вывод попадает в файл результата (см. конец скрипта).
run() {
# Шапка доказательства: время и версия кода.
echo "# Failure detection $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
# Настройки LB, при которых сняты замеры: период проверок, число неудач и таймауты.
# Без них измеренное время обнаружения не с чем сравнить.
grep -E 'default-server|timeout (connect|check|server|http-request|http-keep-alive)' infra/haproxy/haproxy.cfg | sed 's/^ *//'
# Сценарии замеров:
# stop — docker stop (SIGTERM) под трафиком: когда LB вывел реплику, есть ли ошибки;
# kill — docker kill (SIGKILL) под трафиком: LB узнаёт об отказе по ошибкам соединения;
# pause — docker pause: зависший процесс, обнаруживается только по таймауту проверки;
# idle_kill — docker kill без трафика: обнаруживают только активные проверки;
# graceful — порядок завершения по SIGTERM при открытых запросах: все ли они завершатся;
# notready — неготовая реплика: LB выводит её, и трафик на неё не идёт;
# deps — остановка Valkey: реплики становятся неготовыми и возвращаются после его запуска.
python3 scripts/failure-detection.py stop kill pause idle_kill graceful notready deps
}
mkdir -p evidence
status=0
# Вызов через || отключает set -e внутри run. Код запоминаем, чтобы вывести файл на экран
# и при неудаче. Код run — это код python-скрипта, последней команды в функции.
run > "$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+353
View File
@@ -0,0 +1,353 @@
#!/usr/bin/env python3
"""Как LB исключает реплику: stop, kill, pause, idle_kill, graceful, notready, deps.
Стенд должен быть запущен с двумя репликами. Реплики останавливаются и восстанавливаются,
данные только синтетические. Запуск и сохранение результата: scripts/failure-detection-evidence.sh"""
# Запуск отдельных сценариев: python3 scripts/failure-detection.py stop kill
# Каждый сценарий печатает одну или несколько строк JSON. Токены и пароли не печатаются.
import collections
import json
import pathlib
import socket
import subprocess
import sys
import threading
import time
import urllib.error
import urllib.request
import uuid
# Корень проекта: docker compose должен запускаться из него.
ROOT = str(pathlib.Path(__file__).resolve().parents[1])
# Публичный адрес LB. Задан жёстко, другой порт здесь не поддерживается.
BASE = 'http://localhost:8080'
# Клиент API из публичных тестов: нужен сценарию graceful, чтобы создать пользователей и чат.
sys.path.insert(0, ROOT + '/tests')
from client import Client # noqa: E402
# Выполнить команду и вернуть её stdout. check=True: при ненулевом коде выхода будет исключение.
def sh(*a, check=True):
return subprocess.run(a, cwd=ROOT, capture_output=True, text=True, check=check).stdout.strip()
# То же для docker compose с настройками стенда.
def dc(*a, check=True):
return sh('docker', 'compose', '--env-file', '.env', *a, check=check)
# Состояния всех слотов бэкенда api по мнению LB: "UP", "UP 1/2", "DOWN 1/2", "DOWN", "MAINT".
# Берутся из CSV-статистики HAProxy, поле status имеет индекс 17. Строка BACKEND — итог, а не реплика.
def states():
csv = dc('exec', '-T', 'lb', 'wget', '-qO-', 'http://127.0.0.1:8404/stats;csv', check=False)
return [l.split(',')[17] for l in csv.splitlines()
if l.startswith('api,') and l.split(',')[1] != 'BACKEND']
# Сколько реплик полностью работают: ни одной неудачной проверки подряд.
def fully_up():
return sum(1 for s in states() if s == 'UP')
# Сколько реплик ещё получают трафик. По этому числу измеряется момент вывода реплики.
def serving():
# "UP 1/2" (one failed check) still receives traffic, so it counts as serving.
return sum(1 for s in states() if s.startswith('UP') or s.startswith('NOLB'))
# Подождать до t секунд, пока LB не покажет ровно n полностью работающих реплик.
def wait_up(n, t=60):
end = time.monotonic() + t
while time.monotonic() < end:
if fully_up() == n:
return True
time.sleep(0.3)
return False
# ID работающих API-контейнеров.
def containers():
return dc('ps', '-q', 'api').split()
# Сценарии stop, kill, pause: отказ реплики под трафиком. Измеряет, когда LB её вывел,
# сколько ошибок получили клиенты и когда реплика ответила в последний раз.
def timing(mode, target_idx):
assert wait_up(2), 'LB does not see 2 replicas'
cid = containers()[target_idx]
# X-Instance-Id содержит короткий ID контейнера: так видно, кто обслужил запрос.
short = cid[:12]
results = []
stop = threading.Event()
# Клиент трафика: запрашивает /health/live через LB и записывает кортеж
# (время начала, длительность, код или тип ошибки, какая реплика ответила).
def worker():
while not stop.is_set():
t0 = time.monotonic()
try:
with urllib.request.urlopen(BASE + '/health/live', timeout=2) as r:
results.append((t0, time.monotonic() - t0, r.status, r.headers.get('X-Instance-Id')))
except urllib.error.HTTPError as e:
results.append((t0, time.monotonic() - t0, e.code, e.headers.get('X-Instance-Id')))
except Exception as e:
results.append((t0, time.monotonic() - t0, type(e).__name__, None))
time.sleep(0.02)
# 8 параллельных клиентов и 2,5 с работы до отказа.
threads = [threading.Thread(target=worker) for _ in range(8)]
[t.start() for t in threads]
time.sleep(2.5)
t_fail = time.monotonic()
cmd = {'stop': 'stop', 'kill': 'kill', 'pause': 'pause'}[mode]
# В отдельном потоке: docker stop блокируется до конца завершения реплики, а засекать
# вывод из LB нужно уже сейчас.
threading.Thread(target=lambda: sh('docker', cmd, cid, check=False)).start()
# Опрашиваем LB до 15 с: время, через которое осталась одна обслуживающая реплика.
t_down = None
end = time.monotonic() + 15
while time.monotonic() < end:
if serving() == 1:
t_down = time.monotonic() - t_fail
break
time.sleep(0.03)
# Ещё 6 с трафика: запросы, зависшие на реплике, успевают завершиться или получить таймаут.
time.sleep(6)
stop.set()
[t.join() for t in threads]
# В расчёт идут только запросы, начатые после отказа. Ошибка — любой ответ, кроме 200.
after = [r for r in results if r[0] >= t_fail]
bad = [r for r in after if r[2] != 200]
target_hits = [r[0] - t_fail for r in after if r[3] == short]
last_err = max((r[0] + r[1] - t_fail for r in bad), default=0)
out = {
'mode': mode, 'lb_excluded_after_s': round(t_down, 2) if t_down else None,
'requests': len(after), 'errors': dict(collections.Counter(str(r[2]) for r in bad)),
'last_error_at_s': round(last_err, 2),
'last_served_by_target_s': round(max(target_hits), 2) if target_hits else None,
}
print(json.dumps(out, ensure_ascii=False), flush=True)
# Восстановление: приостановленный контейнер размораживается, остановленный запускается заново.
if mode == 'pause':
sh('docker', 'unpause', cid)
else:
dc('up', '-d', '--wait', check=False)
assert wait_up(2), 'not recovered'
return out
# Сценарий graceful: SIGTERM при открытых запросах. Запросы завершаются, порт закрывается после drain.
def graceful():
"""Requests in flight across SIGTERM must finish; the listener must close after drain."""
assert wait_up(2)
c = Client(BASE, timeout=5)
alice, bob, eve, chat = c.bootstrap()
cid = containers()[0]
short = cid[:12]
# Адрес реплики внутри сети Docker: к ней обращаемся напрямую, минуя балансировку.
ip = sh('docker', 'inspect', '-f', '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}', cid)
# 8 POST через LB с заголовками и только первыми 5 байтами тела. Сервер ждёт остаток,
# поэтому запросы остаются открытыми, сколько нужно. Round-robin делит их между репликами.
socks = []
for i in range(8):
key = uuid.uuid4().hex
body = json.dumps({'text': 'inflight-' + key}).encode()
s = socket.create_connection(('localhost', 8080), timeout=30)
head = ('POST /api/v1/chats/%s/messages HTTP/1.1\r\nHost: x\r\nAuthorization: Bearer %s\r\n'
'Content-Type: application/json\r\nIdempotency-Key: %s\r\nContent-Length: %d\r\n'
'Connection: close\r\n\r\n' % (chat['id'], alice['token'], key, len(body))).encode()
s.sendall(head + body[:5])
socks.append((s, body, key))
time.sleep(0.3)
# SIGTERM одной реплике. В отдельном потоке, потому что docker stop блокируется.
t0 = time.monotonic()
stopper = threading.Thread(target=lambda: sh('docker', 'stop', cid, check=False))
stopper.start()
# While requests are open: is the listener closed for new connections after drain?
# В течение 5 с спрашиваем readiness реплики напрямую из контейнера LB и записываем
# (время, успех, текст ошибки wget): так видно сначала 503, затем отказ в соединении.
probe = []
while time.monotonic() - t0 < 5:
r = subprocess.run(['docker', 'compose', '--env-file', '.env', 'exec', '-T', 'lb', 'wget', '-qO-', '-T', '1',
'http://%s:8080/health/ready' % ip], cwd=ROOT, capture_output=True, text=True)
probe.append((round(time.monotonic() - t0, 2), r.returncode == 0, r.stderr.strip()[:120]))
time.sleep(0.25)
# Finish bodies 5 s after SIGTERM: past drain (3 s), inside shutdown timeout.
# Досылаем остаток тел и читаем ответы: достаём код и реплику, которая ответила.
res = []
for s, body, key in socks:
s.sendall(body[5:])
for s, body, key in socks:
data = b''
try:
while True:
part = s.recv(65536)
if not part:
break
data += part
except Exception as e:
data = repr(e).encode()
head = data.split(b'\r\n\r\n')[0].decode(errors='replace')
code = head.split(' ')[1] if ' ' in head else head
inst = [l.split(':', 1)[1].strip() for l in head.split('\r\n') if l.lower().startswith('x-instance-id')]
res.append((code, inst[0] if inst else None, key))
s.close()
stopper.join()
t_stop = time.monotonic() - t0
# Из проб: когда порт перестал принимать соединения и когда readiness стал отвечать 503.
closed_at = next((p[0] for p in probe if 'refused' in p[2] or 'timed out' in p[2]), None)
ready503_at = next((p[0] for p in probe if '503' in p[2]), None)
# Запросы именно на останавливаемой реплике: главное, что здесь проверяется.
on_target = [r for r in res if r[1] == short]
# Код выхода контейнера: 0 значит штатное завершение, а не SIGKILL по истечении срока.
insp = sh('docker', 'inspect', '-f', 'status={{.State.Status}} exit={{.State.ExitCode}}', cid)
# Какие этапы завершения есть в логе приложения.
p = subprocess.run(['docker', 'logs', '--tail', '30', cid], capture_output=True, text=True)
log = p.stdout + p.stderr
msgs = [m for m in ('shutdown signal received', 'http server draining', 'http server shutting down', 'server stopped cleanly') if m in log]
# Сверка с историей: каждый ответ 201 должен соответствовать сохранённому сообщению.
items = c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages?limit=100', actor=alice, schema='MessagePage')['json']['items']
texts = {m['text'] for m in items}
print(json.dumps({
'codes': dict(collections.Counter(r[0] for r in res)),
'inflight_on_stopped_replica': len(on_target),
'on_target_codes': dict(collections.Counter(r[0] for r in on_target)),
'confirmed_saved': sum(1 for r in res if r[0] == '201' and 'inflight-' + r[2] in texts),
'listener_closed_after_s': closed_at,
'ready_503_after_s': ready503_at, 'docker_stop_took_s': round(t_stop, 2),
'container': insp, 'log_sequence': msgs,
}, ensure_ascii=False), flush=True)
dc('up', '-d', '--wait', check=False)
assert wait_up(2), 'not recovered'
# Сценарий notready: появляется новый адрес с неудачным readiness. LB не должен слать на него
# трафик ни на миг, даже до первой проверки (за это отвечает init-state down в haproxy.cfg).
def notready():
"""A new address with a failing readiness: does the LB route traffic before any check passes?"""
assert wait_up(2)
name = 'lab3-notready-probe'
sh('docker', 'rm', '-f', name, check=False)
image = 'haproxy:3.2.9-alpine'
hits = collections.Counter()
stop = threading.Event()
# Клиент трафика запрашивает несуществующий путь: настоящая реплика вернёт 404,
# а поддельная вернёт 200 с текстом FAKE. Любой счётчик 'fake' означает провал.
def worker():
while not stop.is_set():
try:
with urllib.request.urlopen(BASE + '/fake-replica-marker.txt', timeout=2) as r:
hits['fake' if b'FAKE' in r.read() else 'other'] += 1
except urllib.error.HTTPError:
hits['real_404'] += 1
except Exception:
hits['error'] += 1
time.sleep(0.005)
threads = [threading.Thread(target=worker) for _ in range(8)]
[t.start() for t in threads]
time.sleep(1)
try:
# Поддельная реплика: отдельный HAProxy в сети стенда с DNS-именем api, поэтому LB находит
# её как новую реплику. На /health/ready отвечает 503, на всё остальное 200 FAKE.
cfg = ('defaults\n mode http\n timeout connect 1s\n timeout client 10s\n timeout server 10s\n'
'frontend f\n bind :8080\n'
' http-request return status 503 content-type text/plain string NOTREADY if { path /health/ready }\n'
' http-request return status 200 content-type text/plain string FAKE\n')
sh('docker', 'run', '-d', '--name', name, '--network', 'mtusi-lab3_default', '--network-alias', 'api',
'-e', 'CFG=' + cfg, '--entrypoint', 'sh', image, '-c',
'printf "%s" "$CFG" > /tmp/h.cfg && exec haproxy -f /tmp/h.cfg')
# 8 с записываем каждую смену состояний в LB; свободные слоты (MAINT) не учитываем.
end = time.monotonic() + 8
seen_states = []
while time.monotonic() < end:
st = [x for x in states() if not x.startswith('MAINT')]
if not seen_states or seen_states[-1] != st:
seen_states.append(st)
time.sleep(0.05)
# Защита от ложного успеха: поддельная реплика действительно работает и доступна,
# а значит, отсутствие трафика на ней заслуга LB, а не её поломка.
running = sh('docker', 'inspect', '-f', '{{.State.Running}}', name)
check_ready = dc('exec', '-T', 'lb', 'sh', '-c',
'wget -S -qO- -T 2 http://%s:8080/health/ready 2>&1 | head -1; wget -qO- -T 2 http://%s:8080/x' % ((sh('docker', 'inspect', '-f', '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}', name),) * 2), check=False)
assert running == 'true' and 'FAKE' in check_ready, 'probe replica is not serving: ' + running + ' ' + check_ready
print(json.dumps({'probe_serving': True, 'state_transitions': seen_states}), flush=True)
finally:
# Поддельный контейнер удаляется в любом случае, даже при неудачной проверке.
stop.set()
[t.join() for t in threads]
sh('docker', 'rm', '-f', name, check=False)
print(json.dumps({'requests_routed': dict(hits)}, ensure_ascii=False), flush=True)
assert wait_up(2, 30), 'not recovered'
# Сценарий idle_kill (или idle_<команда docker>): отказ без трафика. Срабатывают только активные
# проверки LB, поэтому время отражает настройки inter, fall и таймауты.
def idle(mode):
assert wait_up(2)
cid = containers()[0]
t0 = time.monotonic()
sh('docker', mode, cid)
while serving() != 1 and time.monotonic() - t0 < 15:
time.sleep(0.03)
print(json.dumps({'idle_' + mode + '_excluded_after_s': round(time.monotonic() - t0, 2)}), flush=True)
if mode == 'pause':
sh('docker', 'unpause', cid)
else:
dc('up', '-d', '--wait', check=False)
assert wait_up(2), 'not recovered'
# Сценарий deps: отказ общей зависимости. Реплики живы, но не готовы, поэтому LB выводит все.
def deps():
"""Readiness зависит от общего хранилища: без Valkey обе реплики выводятся, live остаётся 200."""
assert wait_up(2)
cid = containers()[0]
sh('docker', 'compose', '--env-file', '.env', 'stop', 'valkey')
# Время, через которое LB вывел все реплики.
t0 = time.monotonic()
while serving() != 0 and time.monotonic() - t0 < 15:
time.sleep(0.05)
excluded = round(time.monotonic() - t0, 2)
# Что видит клиент через LB: ожидается 503, так как рабочих реплик нет.
try:
urllib.request.urlopen(BASE + '/health/live', timeout=3)
via_lb = 200
except urllib.error.HTTPError as e:
via_lb = e.code
# Напрямую к реплике: live должен работать, а ready нет.
ip = sh('docker', 'inspect', '-f', '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}', cid)
probe = lambda p: subprocess.run(['docker', 'compose', '--env-file', '.env', 'exec', '-T', 'lb', 'wget', '-qO-', '-T', '3',
'http://%s:8080%s' % (ip, p)], cwd=ROOT, capture_output=True, text=True)
live, ready = probe('/health/live'), probe('/health/ready')
print(json.dumps({'valkey_stopped_all_replicas_excluded_after_s': excluded, 'live_via_lb': via_lb,
'replica_live_ok': live.returncode == 0, 'replica_ready_ok': ready.returncode == 0}), flush=True)
dc('up', '-d', '--wait', check=False)
# Отсчёт идёт после завершения up --wait, то есть это не полное время восстановления
# с момента запуска Valkey, а только остаток ожидания после него.
t0 = time.monotonic()
assert wait_up(2), 'not recovered'
print(json.dumps({'valkey_restored_replicas_back_after_s': round(time.monotonic() - t0, 2)}), flush=True)
# Сценарии выполняются в порядке аргументов.
for arg in sys.argv[1:]:
if arg == 'deps':
deps()
elif arg.startswith('idle_'):
# 3 повтора: idle_kill вызывает idle('kill').
for _ in range(3):
idle(arg[5:])
elif arg == 'graceful':
graceful()
elif arg == 'notready':
notready()
else:
# stop, kill или pause: 3 повтора, отказывают реплики 0, 1 и снова 0.
for i in (0, 1, 0):
timing(arg, i)
+66
View File
@@ -0,0 +1,66 @@
#!/bin/sh
# Общая идемпотентность: параллельные POST с одним ключом через разные реплики, затем то же
# в момент отказа реплики и сверка сообщений с ключами в БД. Результат: evidence/level4/idempotency.txt
#
# Запуск из любого каталога при поднятом стенде с двумя репликами: sh scripts/idempotency-evidence.sh
# Нужны Go и Python. Реплики на время проверки останавливаются, затем восстанавливаются.
# Файл результата перезаписывается. Код выхода: 0, только если пройдены все три шага.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Общие функции: compose и git_state (текущий коммит).
. scripts/lb-lib.sh
OUT=evidence/level4/idempotency.txt
# Порт берём из .env, если он там задан (при нескольких значениях последнее), иначе 8080.
PORT=$(sed -n 's/^API_PUBLISH_PORT=//p' .env | tail -n 1)
BASE_URL=${BASE_URL:-http://localhost:${PORT:-8080}}
# Основная логика; весь её вывод попадает в файл результата (см. конец скрипта).
# Вызов через || отключает set -e внутри run, поэтому каждый шаг сам возвращает ошибку.
run() {
# Шапка доказательства: время и версия кода.
echo "# Идемпотентность $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
# Шаг 1. Гонка без отказов: тест app/e2e шлёт одинаковые запросы через обе реплики.
echo "## параллельно через обе реплики (20 раундов по 16 запросов, 3 прогона)"
for i in 1 2 3; do
# Вывод сохраняем в переменную: в конвейере с grep код выхода go test был бы потерян.
e2e_status=0
e2e_log=$(cd app && E2E_BASE_URL="$BASE_URL" go test -count=1 -v ./e2e/ 2>&1) || e2e_status=$?
# Оставляем только итоги: объём раунда и строки результата теста.
echo "$e2e_log" | grep -E 'раундов|^(--- |FAIL)' || true
[ "$e2e_status" -eq 0 ] || return 1
done
# Шаг 2. Та же гонка в момент отказа реплики, с повтором неподтверждённых запросов.
echo "## параллельно в момент отказа реплики"
python3 scripts/idempotency-under-failure.py || return 1
# Шаг 3. Независимая проверка по БД для сообщений шага 2 (текст начинается с parallel-).
# Проверять повторы самих ключей бессмысленно: их запрещает PRIMARY KEY таблицы. А вот эти
# два нарушения БД не запрещает, поэтому их может создать только ошибка в коде:
# первое число — одно и то же сообщение записано в чат больше одного раза (дубль);
# второе число — сообщение записано без ключа, то есть мимо защиты от повтора.
# Для второго числа берём только последний час: старые ключи удаляются через сутки.
echo "## дублей сообщений и сообщений без ключа в БД (должно быть 0 0)"
db_check=$(compose exec -T postgres psql -U messenger -d messenger -At -c "
select
(select count(*) from (
select chat_id, text from messages where text like 'parallel-%'
group by 1, 2 having count(*) > 1) d)
|| ' ' ||
(select count(*) from messages m
where m.text like 'parallel-%' and m.created_at > now() - interval '1 hour'
and not exists (select 1 from message_idempotency_keys k where k.message_id = m.id))") || return 1
echo "$db_check"
[ "$db_check" = "0 0" ] || return 1
}
mkdir -p evidence/level4
status=0
# Код запоминаем, чтобы вывести файл на экран и при неудаче.
run > "$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+146
View File
@@ -0,0 +1,146 @@
#!/usr/bin/env python3
"""Параллельные POST с одним Idempotency-Key в момент отказа реплики (stop или kill).
Неподтверждённый запрос клиент повторяет с тем же ключом. На каждый ключ должно быть ровно
одно сообщение, а все подтверждённые ответы одного ключа должны совпадать.
Каждая реплика отказывает по очереди и затем восстанавливается. Данные синтетические."""
# Запуск при поднятом стенде с двумя репликами: python3 scripts/idempotency-under-failure.py
# Обычно вызывается из idempotency-evidence.sh. Код выхода: 0 при PASS, 1 при FAIL.
import collections
import concurrent.futures as cf
import json
import pathlib
import subprocess
import sys
import threading
import time
import urllib.parse
import uuid
# Корень проекта: docker compose должен запускаться из него.
ROOT = pathlib.Path(__file__).resolve().parents[1]
# Клиент API из публичных тестов: проверяет ответы по схеме контракта.
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client, Failure # noqa: E402
# Публичный адрес LB. Задан жёстко, другой порт здесь не поддерживается.
BASE = 'http://localhost:8080'
# Сколько одинаковых запросов идёт одновременно на один ключ.
PARALLEL = 16
c = Client(BASE, timeout=5)
# Выполнить docker compose и вернуть stdout. Ошибку вызывающий увидит по пустому результату.
def dc(*args):
return subprocess.run(['docker', 'compose', '--env-file', '.env', *args], cwd=ROOT,
capture_output=True, text=True, check=False).stdout.strip()
# Сколько реплик LB считает рабочими: поле status (индекс 17) в CSV-статистике HAProxy.
def up_count():
csv = dc('exec', '-T', 'lb', 'wget', '-qO-', 'http://127.0.0.1:8404/stats;csv')
return sum(1 for line in csv.splitlines()
if line.startswith('api,') and line.split(',')[1] != 'BACKEND' and line.split(',')[17] == 'UP')
# Подождать до 60 с, пока LB не покажет n рабочих реплик, иначе завершить проверку ошибкой.
def wait_up(n):
end = time.monotonic() + 60
while time.monotonic() < end:
if up_count() == n:
return
time.sleep(0.3)
raise SystemExit('LB не увидел реплик: %d' % n)
# Возвращает тело подтверждённого ответа и реплику, которая ответила. tally считает ошибки
# по кодам: это запросы, результат которых клиенту неизвестен, поэтому их и повторяют.
def post_until_confirmed(actor, chat, key, text, tally):
"""Как настоящий клиент: повторяет тот же ключ и то же тело до подтверждения."""
deadline = time.monotonic() + 30
while time.monotonic() < deadline:
try:
r = c.call('POST', '/api/v1/chats/' + chat['id'] + '/messages', 201, actor=actor,
body={'text': text}, headers={'Idempotency-Key': key}, schema='Message')
return r['bytes'], r['headers']['X-Instance-Id']
except Failure as exc:
tally[str(exc).rsplit(' ', 1)[-1].strip('()')] += 1
time.sleep(0.05)
raise Failure('запрос не подтверждён за 30 с')
# Вся история чата постранично: с ней сверяется результат.
def history(actor, chat):
items, cursor = [], None
while True:
query = '?limit=100' + ('&cursor=' + urllib.parse.quote(cursor, safe='') if cursor else '')
page = c.call('GET', '/api/v1/chats/' + chat['id'] + '/messages' + query, actor=actor,
schema='MessagePage')['json']
items += page['items']
cursor = page['next_cursor']
if not cursor:
return items
# Один сценарий: 10 с гонки на ключах, на 2-й секунде реплика cid отказывает в режиме mode.
# Возвращает True, если нарушений нет.
def scenario(mode, cid):
# Отдельные пользователи и чат на сценарий: в истории только его сообщения.
actor, _, _, chat = c.bootstrap()
retried = collections.Counter()
instances = collections.Counter()
# keys — обработано ключей, mismatched — ключей с разными ответами,
# expected — тексты, которые должны оказаться в истории.
keys, mismatched = 0, 0
expected = set()
start = time.monotonic()
fired = threading.Event()
# Отказ в отдельном потоке: гонка на ключах в это время продолжается.
def fail():
time.sleep(2)
subprocess.run(['docker', mode, cid], capture_output=True, check=False)
fired.set()
threading.Thread(target=fail).start()
with cf.ThreadPoolExecutor(PARALLEL) as pool:
while time.monotonic() - start < 10:
# Каждый раунд: новый ключ и уникальный текст, по которому сообщение найдётся в истории.
key, text = uuid.uuid4().hex, 'parallel-' + uuid.uuid4().hex
expected.add(text)
# 16 одинаковых запросов одновременно; раунд ждёт подтверждения всех.
results = list(pool.map(lambda _: post_until_confirmed(actor, chat, key, text, retried), range(PARALLEL)))
keys += 1
# Все ответы одного ключа должны совпасть побайтно, иначе ключ считается нарушенным.
mismatched += len({body for body, _ in results}) != 1
instances.update(inst for _, inst in results)
# Дождаться завершения docker stop/kill, затем считать, сколько раз встречается каждый текст.
fired.wait()
copies = collections.Counter(m['text'] for m in history(actor, chat))
out = {
'mode': mode, 'replica': cid[:12], 'keys': keys, 'parallel_per_key': PARALLEL,
'retries_after_uncertain_result': dict(retried), 'instances': dict(instances),
'keys_with_different_answers': mismatched,
'messages_in_history': sum(copies.values()),
'keys_without_message': len(expected - set(copies)),
'keys_with_duplicates': sum(1 for n in copies.values() if n > 1),
}
print(json.dumps(out, ensure_ascii=False), flush=True)
# Успех: ответы совпали, нет потерь и дублей, сообщений в истории ровно столько, сколько ключей.
return not (mismatched or out['keys_without_message'] or out['keys_with_duplicates']
or out['messages_in_history'] != keys)
# Каждая реплика отказывает в обоих режимах, всего 4 сценария на двух репликах.
# docker start восстанавливает её, и следующий сценарий ждёт, пока LB увидит обе.
def main():
ok = True
for mode in ('stop', 'kill'):
wait_up(2)
for cid in dc('ps', '-q', 'api').split():
wait_up(2)
ok = scenario(mode, cid) and ok
subprocess.run(['docker', 'start', cid], capture_output=True, check=False)
wait_up(2)
print('PASS' if ok else 'FAIL')
sys.exit(0 if ok else 1)
main()
+71
View File
@@ -0,0 +1,71 @@
#!/bin/sh
# Создаёт локальные секреты стенда в каталоге secrets/ (он в .gitignore). Запускается один раз
# на чистом clone, до первого docker compose up: compose.yaml читает секреты из этих файлов.
#
# Запуск из любого каталога: sh scripts/init-secrets.sh
# Настройки через окружение: POSTGRES_USER, POSTGRES_DB (по умолчанию messenger).
# Повторный запуск безопасен: непустые файлы не перезаписываются, значения секретов не печатаются.
# Не удаляйте пароль при существующих томах: PostgreSQL задаёт пароль только при создании своего
# тома, и новый пароль с ним не совпадёт.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
DIR=secrets
# Должны совпадать с POSTGRES_USER и POSTGRES_DB сервиса postgres в compose.yaml.
DB_USER="${POSTGRES_USER:-messenger}"
DB_NAME="${POSTGRES_DB:-messenger}"
# Новые файлы и каталог сразу доступны только владельцу: секрет не открыт ни на миг.
umask 077
mkdir -p "$DIR"
# Пароль PostgreSQL: 24 случайных байта в hex. -s: файла нет или он пуст.
if [ ! -s "$DIR/postgres_password" ]; then
# hex, чтобы пароль не требовал URL-экранирования в DSN.
od -An -tx1 -N24 /dev/urandom | tr -d ' \n' > "$DIR/postgres_password"
echo "init-secrets: created $DIR/postgres_password"
fi
# Строка подключения к БД для API и migrate. Хост postgres — имя сервиса в сети Compose.
# TLS выключен: подключение идёт только внутри сети учебного стенда.
if [ ! -s "$DIR/database_url" ]; then
pw="$(cat "$DIR/postgres_password")"
printf 'postgres://%s:%s@postgres:5432/%s?sslmode=disable' "$DB_USER" "$pw" "$DB_NAME" > "$DIR/database_url"
echo "init-secrets: created $DIR/database_url"
fi
# Пароль Valkey, в котором хранятся сессии.
if [ ! -s "$DIR/valkey_password" ]; then
od -An -tx1 -N24 /dev/urandom | tr -d ' \n' > "$DIR/valkey_password"
echo "init-secrets: created $DIR/valkey_password"
fi
# Адрес хранилища сессий для API.
if [ ! -s "$DIR/cache_url" ]; then
pw="$(cat "$DIR/valkey_password")"
printf 'redis://:%s@valkey:6379/0' "$pw" > "$DIR/cache_url"
echo "init-secrets: created $DIR/cache_url"
fi
# Пароль отдельного Valkey для кэша истории (необязательный профиль). Перевод строки в кавычках
# ниже — это символ для удаления, как \n в блоках выше.
if [ ! -s "$DIR/valkey_cache_password" ]; then
od -An -tx1 -N24 /dev/urandom | tr -d '
' > "$DIR/valkey_cache_password"
echo "init-secrets: created $DIR/valkey_cache_password"
fi
# Адрес кэша истории для API.
if [ ! -s "$DIR/history_cache_url" ]; then
pw="$(cat "$DIR/valkey_cache_password")"
printf 'redis://:%s@valkey-cache:6379/0' "$pw" > "$DIR/history_cache_url"
echo "init-secrets: created $DIR/history_cache_url"
fi
# Каталог закрыт от других пользователей хоста. Сами файлы открыты на чтение: Compose монтирует
# их в контейнеры с правами хоста, а процессы там работают не от root (API — uid 100).
chmod 0700 "$DIR"
chmod 0644 "$DIR/postgres_password" "$DIR/database_url" "$DIR/valkey_password" "$DIR/cache_url" "$DIR/valkey_cache_password" "$DIR/history_cache_url"
+51
View File
@@ -0,0 +1,51 @@
#!/usr/bin/env python3
"""Ответы самого LB соответствуют контракту: схема Error и X-Request-Id, равный request_id.
Останавливает Valkey, чтобы LB вывел все реплики, и обязательно запускает его обратно.
Запуск и сохранение результата: scripts/lb-errors-evidence.sh"""
import http.client
import json
import pathlib
import subprocess
import sys
import time
ROOT = pathlib.Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import shape # noqa: E402
def dc(*args):
return subprocess.run(['docker', 'compose', '--env-file', '.env', *args], cwd=ROOT, capture_output=True, text=True)
def get(path):
conn = http.client.HTTPConnection('localhost', 8080, timeout=10)
conn.request('GET', path)
resp = conn.getresponse()
return resp.status, {k.lower(): v for k, v in resp.getheaders()}, resp.read()
def up_count():
csv = dc('exec', '-T', 'lb', 'wget', '-qO-', 'http://127.0.0.1:8404/stats;csv').stdout
return sum(1 for line in csv.splitlines()
if line.startswith('api,') and line.split(',')[1] != 'BACKEND' and line.split(',')[17].startswith('UP'))
dc('stop', 'valkey')
try:
end = time.monotonic() + 15
while up_count() and time.monotonic() < end:
time.sleep(0.2)
status, headers, body = get('/api/v1/users/me')
finally:
dc('up', '-d', '--wait')
error = json.loads(body)
shape(error, 'Error') # падает, если тело не соответствует схеме
print('статус: %d, Content-Type: %s, code: %s' % (status, headers.get('content-type'), error['error']['code']))
print('X-Request-Id есть: %s, равен request_id: %s, X-Instance-Id: %s (контракт разрешает отсутствие у ответов LB)' % (
bool(headers.get('x-request-id')), error['error']['request_id'] == headers.get('x-request-id'), headers.get('x-instance-id')))
ok = (status == 503 and 'application/json' in headers.get('content-type', '') and error['error']['code'] == 'unavailable'
and error['error']['request_id'] == headers.get('x-request-id'))
print('PASS' if ok else 'FAIL', 'ответ LB без рабочих реплик соответствует контракту')
sys.exit(0 if ok else 1)
+17
View File
@@ -0,0 +1,17 @@
#!/bin/sh
# Ответ LB без рабочих реплик по контракту. Valkey на время останавливается.
# Запуск при поднятом стенде: sh scripts/lb-errors-evidence.sh Результат: evidence/lb-errors.txt
set -eu
cd "$(dirname "$0")/.."
. scripts/lb-lib.sh
OUT=evidence/lb-errors.txt
mkdir -p evidence
status=0
{
echo "# Ответы LB $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
grep -E 'http-error status' infra/haproxy/haproxy.cfg | sed -E "s/^ *(http-error status [0-9]+).*/\1/"
python3 scripts/lb-errors-evidence.py
} >"$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+91
View File
@@ -0,0 +1,91 @@
# Общие функции скриптов отказов. Подключается через: . scripts/lb-lib.sh
# Сам по себе не запускается и ничего не делает: только объявляет функции. Вызывающий скрипт
# должен перед подключением перейти в корень проекта. В sh нет локальных переменных, поэтому
# все переменные функций (want, i, status) общие со скриптом: не храните в них важное.
# docker compose с настройками стенда: все скрипты работают с одним и тем же проектом.
compose() { docker compose --env-file .env "$@"; }
# Сколько реплик балансировщик считает рабочими.
# Читает CSV-статистику HAProxy изнутри контейнера LB: порт 8404 снаружи не опубликован.
# Поля awk: $1 — имя бэкенда, $2 — имя сервера (BACKEND — итоговая строка), $18 — статус.
# Считается только точное UP: "UP 1/2" значит, что реплика уже провалила проверку.
lb_up_count() {
compose exec -T lb wget -qO- 'http://127.0.0.1:8404/stats;csv' |
awk -F, -v n=0 '$1=="api" && $2!="BACKEND" && $18=="UP" {n++} END {print n}'
}
# Ждёт, пока LB не увидит заданное число реплик; healthy контейнера для этого недостаточно.
# Healthy проверяет Docker, а трафик направляет LB по своим проверкам. Ждём до 30 с (60 × 0,5 с).
# Подходит и для ожидания вывода реплики: нужно ровно заданное число, а не "не меньше".
wait_lb_up() {
want=$1
i=0
while [ "$i" -lt 60 ]; do
[ "$(lb_up_count)" = "$want" ] && return 0
sleep 0.5
i=$((i + 1))
done
echo "LB не увидел реплик: $want за 30 с" >&2
return 1
}
# Ждёт, пока контейнер с заданным ID или именем не станет healthy по мнению Docker, до 30 с.
wait_healthy() {
i=0
while [ "$i" -lt 60 ]; do
[ "$(docker inspect -f '{{.State.Health.Status}}' "$1")" = healthy ] && return 0
sleep 0.5
i=$((i + 1))
done
echo "контейнер не стал healthy за 30 с" >&2
return 1
}
# Запускает loadgen в фоне (LOADGEN_PID, LOADGEN_LOG) и ждёт начала замера (MEASURE_START).
# Аргументы передаются генератору как есть. Парой к ней вызывается finish_loadgen.
start_loadgen() {
# Свежая статистика делает прогоны сравнимыми.
compose exec -T postgres psql -U messenger -d messenger -q -c 'ANALYZE;' >/dev/null
# Вывод генератора идёт во временный файл: из него читается момент начала замера.
LOADGEN_LOG=$(mktemp)
compose --profile bench run --rm -T loadgen "$@" >"$LOADGEN_LOG" 2>&1 &
LOADGEN_PID=$!
# Ждём строку measure_start, которую генератор печатает после прогрева. Выходим с ошибкой,
# если процесс завершился раньше или прошло больше 2 минут (600 × 0,2 с).
i=0
while ! grep -q '^measure_start' "$LOADGEN_LOG"; do
if ! kill -0 "$LOADGEN_PID" 2>/dev/null || [ "$i" -gt 600 ]; then
cat "$LOADGEN_LOG" >&2
echo "loadgen не начал замер" >&2
return 1
fi
sleep 0.2
i=$((i + 1))
done
# Время начала замера по часам генератора: от него отсчитывается расписание отказов.
MEASURE_START=$(sed -n 's/^measure_start unix=//p' "$LOADGEN_LOG")
}
# Секунд с начала замера.
# Точность 1 с: часы скрипта и генератора могут расходиться меньше чем на секунду.
elapsed() { echo $(($(date +%s) - MEASURE_START)); }
# Ждёт секунду T от начала замера.
sleep_until() {
while [ "$(elapsed)" -lt "$1" ]; do sleep 0.2; done
}
# Ждёт конец нагрузки, печатает итог генератора без служебных строк и удаляет временный файл.
# Возвращает код выхода генератора: он ненулевой, если сверка нашла потери или дубли.
finish_loadgen() {
status=0
wait "$LOADGEN_PID" || status=$?
grep -v -E '^measure_start| Container ' "$LOADGEN_LOG"
rm -f "$LOADGEN_LOG"
return "$status"
}
# Версия кода для шапки доказательств: короткий хеш и +dirty при незакоммиченных изменениях
# в отслеживаемых файлах. Новые файлы, ещё не добавленные в Git, этот признак не учитывает.
git_state() { echo "$(git rev-parse --short HEAD)$(git diff --quiet HEAD -- . || echo +dirty)"; }
+34
View File
@@ -0,0 +1,34 @@
#!/usr/bin/env python3
"""Уровень 3: запросы одного пользователя с одной сессией обслуживают разные реплики.
Заголовок сам по себе не доказывает разные процессы, поэтому рядом печатаются ID контейнеров.
Токены не печатаются. Запуск и сохранение результата: scripts/level3-evidence.sh"""
import collections
import pathlib
import subprocess
import sys
ROOT = pathlib.Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT / 'tests'))
from client import Client # noqa: E402
REQUESTS = 20
# Один пользователь входит один раз, дальше все запросы идут с этим токеном через LB.
client = Client('http://localhost:8080')
alice, _, _, chat = client.bootstrap()
seen = collections.Counter(
client.call('GET', '/api/v1/chats/' + chat['id'] + '/messages', actor=alice)['headers']['X-Instance-Id']
for _ in range(REQUESTS))
print('запросов с одной сессией: %d, по X-Instance-Id: %s' % (REQUESTS, dict(seen)))
# Сопоставление заголовка с реальными контейнерами.
ids = subprocess.run(['docker', 'compose', '--env-file', '.env', 'ps', '-q', 'api'], cwd=ROOT,
capture_output=True, text=True, check=True).stdout.split()
containers = {cid[:12] for cid in ids}
for cid in ids:
print(subprocess.run(['docker', 'inspect', '-f', '{{.Name}} id={{.Id}} status={{.State.Status}}', cid],
capture_output=True, text=True, check=True).stdout.strip().replace(cid, cid[:12]))
ok = len(seen) >= 2 and set(seen) <= containers
print('PASS' if ok else 'FAIL', 'запросы обслужили минимум 2 реальные реплики')
sys.exit(0 if ok else 1)
+23
View File
@@ -0,0 +1,23 @@
#!/bin/sh
# Уровень 3: контракт, публичный smoke и разные реплики за одной сессией.
# Запуск при поднятом стенде: sh scripts/level3-evidence.sh Результат: evidence/level3.txt
set -eu
cd "$(dirname "$0")/.."
. scripts/lb-lib.sh
OUT=evidence/level3.txt
# Вызов через || отключает set -e внутри run, поэтому каждый шаг сам возвращает ошибку.
run() {
echo "# Уровень 3 $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
echo "## make check"
make check || return 1
echo "## make test"
make test || return 1
echo "## реплики за одной сессией"
python3 scripts/level3-evidence.py
}
mkdir -p evidence
status=0
run >"$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+209
View File
@@ -0,0 +1,209 @@
#!/usr/bin/env python3
"""Лимиты CPU/RAM, порты, секреты, хранилища и масштабирование одного Compose-service.
Сверяет файл конфигурации с тем, что реально применено в контейнерах. Значения секретов не
печатает. Масштабирует api до 4 реплик и возвращает 2. Запуск: scripts/limits-evidence.sh"""
# Четыре проверки: файл конфигурации, запущенные контейнеры, сеть хоста, масштабирование.
# Каждая отдельная проверка печатает PASS или FAIL, в конце общий ИТОГ.
# Нужен поднятый стенд с двумя репликами. Код выхода: 0, если нет ни одного FAIL.
import collections
import json
import pathlib
import re
import socket
import subprocess
import sys
import time
import urllib.request
# Корень проекта: docker compose должен запускаться из него.
ROOT = pathlib.Path(__file__).resolve().parents[1]
# Публичный адрес LB. Задан жёстко, другой порт здесь не поддерживается.
BASE = 'http://localhost:8080'
# Порт, на котором заведомо ничего не должно работать: им проверяется честность адреса.
CONTROL_PORT = 59999
# Кому какой секрет нужен: всё остальное считается лишним.
EXPECTED_SECRETS = {
'postgres': {'postgres_password'}, 'valkey': {'valkey_password'},
'valkey-cache': {'valkey_cache_password'}, 'migrate': {'database_url'},
'api': {'database_url', 'cache_url'}, 'lb': set(), 'loadgen': set(),
}
# Именованные тома есть только у хранилищ; остальные сервисы их иметь не должны.
EXPECTED_VOLUMES = {'postgres': {'pgdata'}, 'valkey': {'valkeydata'}}
# Имена проваленных проверок: по этому списку считается ИТОГ.
failed = []
# Напечатать результат одной проверки и запомнить неудачу.
def result(name, ok, detail=''):
print('PASS' if ok else 'FAIL', name, detail, flush=True)
if not ok:
failed.append(name)
# Выполнить команду и вернуть её stdout. check=True: при ненулевом коде выхода будет исключение.
def run(*args, check=True):
return subprocess.run(args, cwd=ROOT, capture_output=True, text=True, check=check).stdout.strip()
# То же для docker compose с настройками стенда.
def dc(*args, check=True):
return run('docker', 'compose', '--env-file', '.env', *args, check=check)
# Проверка 1: что написано в конфигурации. docker compose config разворачивает все переменные,
# поэтому видны итоговые значения. Профили включены, чтобы не пропустить необязательные сервисы.
def audit_config():
print('## конфигурация, все сервисы и профили')
config = json.loads(dc('--profile', 'cache', '--profile', 'bench', 'config', '--format', 'json'))
services = config['services']
for name, service in services.items():
limits = service.get('deploy', {}).get('resources', {}).get('limits', {})
ports = ['%s:%s' % (p.get('host_ip', '*'), p.get('published')) for p in service.get('ports', [])]
secrets = {s['source'] for s in service.get('secrets', [])}
volumes = {v['source'] for v in service.get('volumes', []) if v['type'] == 'volume'}
print('%-13s cpus=%-4s mem=%-5sMB ports=%-16s secrets=%s volumes=%s' % (
name, limits.get('cpus'), int(limits.get('memory', 0)) // 1048576, ','.join(ports) or '-',
','.join(sorted(secrets)) or '-', ','.join(sorted(volumes)) or '-'))
result(name + ': заданы лимиты CPU и RAM', bool(limits.get('cpus') and limits.get('memory')))
result(name + ': секреты только нужные', secrets == EXPECTED_SECRETS[name], '' if secrets == EXPECTED_SECRETS[name] else str(secrets))
result(name + ': том только свой', volumes == EXPECTED_VOLUMES.get(name, set()))
# container_name запретил бы запустить несколько реплик одного сервиса.
result(name + ': нет container_name', 'container_name' not in service)
result('API не публикует порты', not services['api'].get('ports'))
# Сервисы, у которых есть порт не на 127.0.0.1: таким должен быть только LB.
public = [n for n, s in services.items() for p in s.get('ports', []) if p.get('host_ip') != '127.0.0.1']
result('снаружи открыт только LB', public == ['lb'], str(public))
return services
# Проверка 2: что применено на самом деле. Конфигурация могла не примениться, поэтому данные
# берутся из самих контейнеров.
def audit_runtime():
print('## запущенные контейнеры')
expected_names = {'lb', 'api', 'postgres', 'valkey'}
seen = set()
for cid in dc('ps', '-q').split():
service = run('docker', 'inspect', '-f', '{{index .Config.Labels "com.docker.compose.service"}}', cid)
name = run('docker', 'inspect', '-f', '{{.Name}}', cid)
seen.add(service)
# Фактические лимиты ядра из cgroup и пик использования памяти.
cgroup = run('docker', 'exec', cid, 'sh', '-c',
'echo "cpu=$(cat /sys/fs/cgroup/cpu.max | tr " " "/") mem=$(cat /sys/fs/cgroup/memory.max) '
'peak=$(cat /sys/fs/cgroup/memory.peak 2>/dev/null)"')
# Только имена файлов секретов внутри контейнера, без содержимого.
secrets = set(run('docker', 'exec', cid, 'sh', '-c', 'ls /run/secrets 2>/dev/null || true').split())
# На каких адресах хоста опубликованы порты контейнера.
info = json.loads(run('docker', 'inspect', '-f', '{{json .NetworkSettings.Ports}}', cid))
bound = sorted({b['HostIp'] for v in info.values() if v for b in v})
# Был ли контейнер убит из-за нехватки памяти.
oom = run('docker', 'inspect', '-f', '{{.State.OOMKilled}}', cid)
print('%s %s secrets=%s bind=%s oom=%s' % (name, cgroup, ','.join(sorted(secrets)) or '-', ','.join(bound) or '-', oom))
# Значение max в cgroup означает, что лимита нет.
result(name + ': лимиты применены в cgroup', 'max/' not in cgroup and 'mem=max' not in cgroup)
result(name + ': в контейнере только нужные секреты', secrets == EXPECTED_SECRETS[service])
# Секрет не должен оказаться в окружении: его видно через docker inspect. Значения
# только сравниваются; в вывод попадают лишь имена файлов.
env = run('docker', 'inspect', '-f', '{{range .Config.Env}}{{println .}}{{end}}', cid)
leaked = [f.name for f in (ROOT / 'secrets').iterdir() if f.is_file() and f.read_text().strip() in env]
result(name + ': значения секретов не в окружении', not leaked, str(leaked) if leaked else '')
if service == 'api':
result(name + ': API без проброса порта', not bound)
elif service != 'lb':
result(name + ': порт только на 127.0.0.1', bound == ['127.0.0.1'], str(bound))
result('запущены все сервисы стенда', expected_names <= seen, str(sorted(seen)))
# Проверка 3: реальное подключение с внешних адресов хоста, а не вывод настроек.
def audit_network():
print('## доступность с внешних адресов хоста')
def is_open(host, port):
with socket.socket() as s:
s.settimeout(1)
return s.connect_ex((host, port)) == 0
# Все IPv4-адреса хоста. ifconfig есть на macOS; в Linux его может не быть.
addresses = re.findall(r'inet (\d+\.\d+\.\d+\.\d+)', run('ifconfig'))
checked = 0
# В доказательство адрес попадает под номером: IP машины в нём не нужен.
for number, host in enumerate(addresses, 1):
label = 'адрес %d' % number
if host.startswith('127.'):
continue
# VPN-туннель может принимать соединения на любой порт: такой адрес ничего не доказывает.
if is_open(host, CONTROL_PORT):
print('%s пропущен: открыт и контрольный порт %d' % (label, CONTROL_PORT))
continue
checked += 1
states = {port: is_open(host, port) for port in (8080, 5432, 6379)}
print(label, states)
result(label + ': LB доступен', states[8080])
result(label + ': PostgreSQL и Valkey закрыты', not states[5432] and not states[6379])
# Без этого пропуск всех адресов выглядел бы как успех.
result('проверен хотя бы один внешний адрес', checked > 0)
# Сколько реплик LB считает рабочими: поле status (индекс 17) в CSV-статистике HAProxy.
def lb_up():
csv = dc('exec', '-T', 'lb', 'wget', '-qO-', 'http://127.0.0.1:8404/stats;csv')
return sum(1 for line in csv.splitlines()
if line.startswith('api,') and line.split(',')[1] != 'BACKEND' and line.split(',')[17] == 'UP')
# Подождать до 60 с, пока LB не покажет заданное число реплик.
def wait_lb(count):
end = time.monotonic() + 60
while time.monotonic() < end:
if lb_up() == count:
return True
time.sleep(0.3)
return False
# Сколько запросов обслужила каждая реплика: по заголовку X-Instance-Id в ответе.
def instances(requests=48):
seen = collections.Counter()
for _ in range(requests):
with urllib.request.urlopen(BASE + '/health/ready', timeout=3) as response:
seen[response.headers['X-Instance-Id']] += 1
return seen
# Изменить число реплик и проверить, что все получают трафик поровну (разница не больше 1).
# --no-recreate не трогает работающие контейнеры, только добавляет или убирает лишние.
def scale(count):
dc('up', '-d', '--no-recreate', '--wait', '--scale', 'api=%d' % count, check=False)
arrived = wait_lb(count)
names = sorted(dc('ps', '--format', '{{.Name}}', 'api').split())
seen = instances()
print('реплик=%d контейнеры=%s запросы_по_репликам=%s' % (count, names, dict(seen)))
result('масштаб %d: LB видит все реплики' % count, arrived)
result('масштаб %d: нагрузка на всех поровну' % count, len(names) == count and len(seen) == count and max(seen.values()) - min(seen.values()) <= 1)
# Проверка 4: api масштабируется до 4 реплик и обратно. finally возвращает 2 реплики даже при ошибке.
def audit_scale():
print('## масштабирование одного Compose-service')
if not wait_lb(2):
raise SystemExit('LB не видит 2 реплики')
try:
scale(4)
finally:
scale(2)
# У реплик нет своего состояния: новых томов появиться не должно.
volumes = run('docker', 'volume', 'ls', '--filter', 'name=mtusi-lab3_', '--format', '{{.Name}}').split()
print('тома проекта:', volumes)
result('реплики не создали своих томов', set(volumes) == {'mtusi-lab3_pgdata', 'mtusi-lab3_valkeydata'})
# Выполнить все проверки и вывести итог. Код выхода 1, если хотя бы одна не прошла.
def main():
audit_config()
audit_runtime()
audit_network()
audit_scale()
print('ИТОГ:', 'PASS' if not failed else 'FAIL: ' + '; '.join(failed))
sys.exit(1 if failed else 0)
main()
+25
View File
@@ -0,0 +1,25 @@
#!/bin/sh
# Лимиты, порты, секреты, хранилища, масштабирование. Результат: evidence/level4/limits.txt
#
# Запуск из любого каталога при поднятом стенде с двумя репликами: sh scripts/limits-evidence.sh
# Сами проверки выполняет scripts/limits-evidence.py, здесь только запуск и сохранение вывода.
# Файл результата перезаписывается. Значения секретов не печатаются.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Общие функции: здесь нужна git_state (текущий коммит).
. scripts/lb-lib.sh
OUT=evidence/level4/limits.txt
mkdir -p evidence/level4
status=0
# Шапка и вывод проверок попадают в один файл. Код запоминаем, чтобы вывести файл на экран
# и при неудаче. Код группы — это код python-скрипта, последней команды в ней.
{
echo "# Лимиты и изоляция $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
python3 scripts/limits-evidence.py
} > "$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+298
View File
@@ -0,0 +1,298 @@
#!/bin/sh
# Уровень 4: совместимость миграций с работающей версией и однократность запуска.
# Проверочные миграции живут только во временном каталоге и откатываются в конце;
# каталог migrations/ не меняется. Результат: evidence/level4/migrations.txt
#
# Запуск из любого каталога: sh scripts/migration-evidence.sh (нужны Python и make, идёт несколько минут)
# Реплики заменяются, образы пересобираются, в сценарии 2 API намеренно ломается на 10 с: данные
# синтетические, но ничего другого со стендом в это время делать нельзя. Код выхода: 0 при ИТОГ: PASS.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Общие функции: compose, ожидание LB, запуск loadgen, отсчёт времени замера.
. scripts/lb-lib.sh
DIR=evidence/level4
OUT=$DIR/migrations.txt
# Текущая версия схемы. При добавлении настоящей миграции 00008 надо менять и её, и имена
# проверочных миграций ниже: они тоже 00008.
VERSION=7
# Отдельная сеть и БД для сценария 6: рабочая БД в нём не участвует.
RACE_NET=lab3-migrate-race
RACE_DB=lab3-migrate-race-db
# Станет 1 при первой неудачной проверке.
FAILED=0
mkdir -p "$DIR"
# Временный каталог внутри проекта: Docker монтирует из него проверочные миграции.
TMP=$(mktemp -d "$PWD/evidence/.migration-test.XXXXXX")
# Выполнить SQL и вернуть результат без оформления.
psql_q() { compose exec -T postgres psql -U messenger -d messenger -Atc "$1"; }
# Текущая версия схемы по таблице goose.
db_version() { psql_q 'SELECT max(version_id) FROM goose_db_version WHERE is_applied'; }
# Напечатать PASS или FAIL по условию true/false и запомнить неудачу. Выполнение не прерывается.
check() { # имя условие
if [ "$2" = true ]; then echo "PASS $1"; else echo "FAIL $1"; FAILED=1; fi
}
# Вернуть true, если два значения равны: результат передаётся в check.
is() { if [ "$1" = "$2" ]; then echo true; else echo false; fi; }
# ID работающих реплик: по изменению списка видно, заменялись ли они.
api_ids() { compose ps -q api | sort | tr '\n' ' '; }
# Версия образа, на который сейчас указывает тег, и версия образа работающей реплики.
tag_label() { docker image inspect -f '{{index .Config.Labels "org.opencontainers.image.version"}}' mtusi-lab3-api; }
running_label() { docker inspect -f '{{index .Config.Labels "org.opencontainers.image.version"}}' "$(compose ps -q api | head -1)"; }
# Добавить к каждой строке время от начала замера.
with_time() { while IFS= read -r line; do echo "t=$(elapsed)s $line"; done; }
verify_ok() { # файл результата: нет потерь, дублей и секунд без успеха
python3 - "$1" <<'PY'
import json, sys
d = json.load(open(sys.argv[1], encoding='utf8'))
v = d['verify']
print('true' if v['lost'] == 0 and v['duplicate_ids'] == 0 and v['duplicate_texts'] == 0 and not d['seconds_without_success'] and not v.get('error') else 'false')
PY
}
# Сумма ошибок за весь замер по посекундной шкале результата loadgen.
errors_of() { python3 -c "import json,sys; print(sum(s['err'] for s in json.load(open(sys.argv[1],encoding='utf8'))['timeline']))" "$1"; }
# Подставляет каталог с миграциями и, при необходимости, настройку api.
# Рабочие миграции и проверочная копируются во временный каталог. Он монтируется в migrate поверх
# /migrations через дополнительный файл Compose, поэтому migrations/ в проекте не меняется.
# COMPOSE_FILE действует на все следующие команды compose, в том числе в rolling-update.sh.
use_override() { # файл-миграции [блок api]
rm -rf "$TMP/migrations"
mkdir -p "$TMP/migrations"
cp migrations/*.sql "$TMP/migrations/"
[ -z "$1" ] || cp "$1" "$TMP/migrations/"
{
echo 'services:'
echo ' migrate:'
echo ' volumes:'
echo " - $TMP/migrations:/migrations:ro"
[ -z "${2:-}" ] || printf ' api:\n %s\n' "$2"
} >"$TMP/override.yaml"
COMPOSE_FILE="compose.yaml:$TMP/override.yaml"
export COMPOSE_FILE
}
# Запустить goose с заданной командой (up, down-to N) в контейнере migrate.
goose_to() {
compose run --rm -T --entrypoint sh migrate -c \
'exec goose -dir /migrations postgres "$(cat "$DATABASE_URL_FILE")" '"$1" 2>&1 | grep -v ' Container '
}
# Выполняется при любом выходе, даже при ошибке: откатить проверочную миграцию, удалить
# отдельную БД, сеть и временный каталог. Код выхода скрипта при этом сохраняется.
cleanup() {
status=$?
if [ -f "$TMP/override.yaml" ] && [ "$(db_version 2>/dev/null)" != "$VERSION" ]; then
goose_to "down-to $VERSION" >/dev/null 2>&1 || echo "не удалось откатить проверочную миграцию" >&2
fi
unset COMPOSE_FILE || true
docker rm -f "$RACE_DB" >/dev/null 2>&1 || true
docker network rm "$RACE_NET" >/dev/null 2>&1 || true
rm -rf "$TMP"
exit "$status"
}
trap cleanup EXIT
# Создать файл проверочной миграции в формате goose.
write_migration() { # имя up down
cat >"$TMP/$1" <<SQL
-- +goose Up
-- +goose StatementBegin
$2
-- +goose StatementEnd
-- +goose Down
-- +goose StatementBegin
$3
-- +goose StatementEnd
SQL
}
# Сценарий 1. Совместимая миграция только добавляет: старый код её не замечает. Обновление идёт
# под нагрузкой; результат должен быть без ошибок, потерь и дублей.
expand_under_load() {
echo "## 1. Совместимая миграция (expand) и замена реплик под нагрузкой"
# Новая колонка и новая таблица: старые запросы их не используют.
write_migration 00008_rollout_probe.sql \
'ALTER TABLE messages ADD COLUMN rollout_probe text; CREATE TABLE rollout_probe_table (id bigint PRIMARY KEY);' \
'DROP TABLE rollout_probe_table; ALTER TABLE messages DROP COLUMN rollout_probe;'
use_override "$TMP/00008_rollout_probe.sql"
# Новая метка сборки: по ней видно, что реплики действительно заменены.
export APP_BUILD="expand-$(date -u +%Y%m%d%H%M%S)"
compose build api migrate >/dev/null 2>&1
before_ids=$(api_ids)
start_loadgen -duration 60s -warmup 5s -concurrency 16 -label expand -out /evidence/level4/rolling-expand.json
sleep_until 10
begin=$(elapsed)
echo "t=${begin}s начало: версия схемы $(db_version), реплики $before_ids"
# Код выхода сохраняем в файл: иначе конвейер с with_time его потерял бы.
{ sh scripts/rolling-update.sh 2>&1; echo $? >"$TMP/rolling.code"; } | with_time
check 'expand: скрипт замены завершился успешно' "$(is "$(cat "$TMP/rolling.code")" 0)"
end=$(elapsed)
echo "t=${end}s конец: версия схемы $(db_version), реплики $(api_ids)"
# Момент применения миграции: до него и какое-то время после работают старые реплики.
applied=$(psql_q "SELECT round(extract(epoch FROM tstamp AT TIME ZONE 'UTC'))::bigint FROM goose_db_version WHERE version_id = 8")
echo "схема изменена на t=$((applied - MEASURE_START))s, старые реплики продолжали работать до строк замены выше"
finish_loadgen >/dev/null
python3 scripts/rolling-summary.py "$DIR/rolling-expand.json" "$begin" "$end"
check 'expand: миграция применена один раз' "$(is "$(psql_q 'SELECT count(*) FROM goose_db_version WHERE version_id = 8')" 1)"
check 'expand: нет потерь, дублей и секунд без успеха' "$(verify_ok "$DIR/rolling-expand.json")"
check 'expand: ошибок клиента 0' "$(is "$(errors_of "$DIR/rolling-expand.json")" 0)"
echo "контрактные тесты на новой схеме:"
# Публичный контрактный тест на расширенной схеме. Код сохраняем, чтобы set -e не прервал скрипт.
make test >"$TMP/test.log" 2>&1 && test_status=0 || test_status=$?
tail -3 "$TMP/test.log"
check 'expand: make test проходит на расширенной схеме' "$(is "$test_status" 0)"
goose_to "down-to $VERSION" | tail -1
check 'expand: проверочная миграция откачена' "$(is "$(db_version)" "$VERSION")"
}
# Сценарий 2. Контроль чувствительности: заведомо несовместимая миграция должна дать ошибки.
# Если бы их не было, 0 ошибок в сценарии 1 ничего бы не доказывал.
breaking_under_load() {
echo "## 2. Контроль: несовместимая миграция ломает работающую версию"
# Переименование колонки, которую использует работающий код.
write_migration 00008_breaking_rename.sql \
'ALTER TABLE messages RENAME COLUMN text TO text_v2;' \
'ALTER TABLE messages RENAME COLUMN text_v2 TO text;'
use_override "$TMP/00008_breaking_rename.sql"
start_loadgen -duration 30s -warmup 5s -concurrency 16 -label breaking -out /evidence/level4/migration-breaking.json
sleep_until 10
goose_to up | tail -1
echo "t=$(elapsed)s переименована колонка messages.text"
sleep_until 15
# Readiness проверяет только связь с БД, поэтому LB не должен вывести реплики: это ограничение.
up_during=$(lb_up_count)
echo "t=$(elapsed)s LB считает рабочими реплик: $up_during"
sleep_until 20
goose_to "down-to $VERSION" | tail -1
echo "t=$(elapsed)s колонка возвращена"
# || true: ошибки здесь ожидаемы, их оценивают проверки ниже.
finish_loadgen >/dev/null || true
python3 scripts/rolling-summary.py "$DIR/migration-breaking.json" 10 20
errors=$(errors_of "$DIR/migration-breaking.json")
[ "$errors" -gt 0 ] && seen=true || seen=false
check 'контроль: нагрузка замечает несовместимую схему' "$seen"
check 'контроль: readiness не проверяет схему, реплики остаются в LB' "$(is "$up_during" 2)"
check 'контроль: схема восстановлена' "$(is "$(db_version)" "$VERSION")"
}
# Сценарий 3. Миграция с ошибкой: обновление останавливается до замены реплик, транзакция откатывается.
failed_migration() {
echo "## 3. Упавшая миграция останавливает обновление до замены реплик"
# Создаёт таблицу и падает на делении на ноль: таблицы после этого быть не должно.
write_migration 00008_fails.sql 'CREATE TABLE migration_must_rollback (id int); SELECT 1 / 0;' 'SELECT 1;'
use_override "$TMP/00008_fails.sql"
before_ids=$(api_ids)
label=$(running_label)
if APP_BUILD=failed-migration sh scripts/rolling-update.sh >"$TMP/log" 2>&1; then code=0; else code=$?; fi
tail -1 "$TMP/log"
[ "$code" -ne 0 ] && stopped=true || stopped=false
check 'упавшая миграция: скрипт вернул ошибку' "$stopped"
check 'упавшая миграция: реплики те же' "$(is "$(api_ids)" "$before_ids")"
check 'упавшая миграция: версия схемы не изменилась' "$(is "$(db_version)" "$VERSION")"
check 'упавшая миграция: транзакция откатилась' "$(is "$(psql_q "SELECT to_regclass('migration_must_rollback') IS NULL")" t)"
check 'упавшая миграция: тег образа возвращён' "$(is "$(tag_label)" "$label")"
}
# Сценарий 4. Новая реплика не стартует: старые продолжают работать, клиенты ошибок не видят.
bad_image() {
echo "## 4. Реплика, которая не стартует, не снижает доступность"
# Подмена команды запуска на /bin/false: контейнер сразу завершается с ошибкой.
use_override '' 'entrypoint: ["/bin/false"]'
before_ids=$(api_ids)
label=$(running_label)
start_loadgen -duration 50s -warmup 5s -concurrency 16 -label bad-image -out /evidence/level4/rolling-bad-image.json
sleep_until 5
begin=$(elapsed)
if APP_BUILD=bad-image sh scripts/rolling-update.sh >"$TMP/log" 2>&1; then code=0; else code=$?; fi
end=$(elapsed)
tail -1 "$TMP/log"
finish_loadgen >/dev/null
python3 scripts/rolling-summary.py "$DIR/rolling-bad-image.json" "$begin" "$end"
[ "$code" -ne 0 ] && stopped=true || stopped=false
check 'плохой образ: скрипт вернул ошибку' "$stopped"
check 'плохой образ: старые реплики на месте' "$(is "$(api_ids)" "$before_ids")"
check 'плохой образ: ошибок клиента 0' "$(is "$(errors_of "$DIR/rolling-bad-image.json")" 0)"
check 'плохой образ: нет потерь и дублей' "$(verify_ok "$DIR/rolling-bad-image.json")"
check 'плохой образ: тег образа возвращён' "$(is "$(tag_label)" "$label")"
}
# Сценарий 5. Миграции применяются один раз: повторный запуск и масштабирование их не выполняют.
once_only() {
echo "## 5. Однократность: повторный запуск и масштабирование"
unset COMPOSE_FILE
rows=$(psql_q 'SELECT count(*) FROM goose_db_version')
compose run --rm -T migrate 2>&1 | grep -v ' Container ' | tail -1 | sed -E 's/^[0-9/]+ [0-9:]+ //'
ids=$(api_ids)
compose up -d --wait --scale api=3 >/dev/null 2>&1
wait_lb_up 3
kept=true
for id in $ids; do compose ps -q api | grep -qxF "$id" || kept=false; done
check 'масштабирование не пересоздаёт работающие реплики' "$kept"
compose up -d --wait --scale api=2 >/dev/null 2>&1
wait_lb_up 2
check 'повторный запуск и масштабирование не добавили записей о миграциях' "$(is "$(psql_q 'SELECT count(*) FROM goose_db_version')" "$rows")"
image=$(docker inspect -f '{{.Config.Image}}' "$(compose ps -q api | head -1)")
# В образе API нет goose и миграций, поэтому реплики физически не могут запускать их при старте.
has_goose=$(docker run --rm --entrypoint sh "$image" -c 'command -v goose || ls /migrations 2>/dev/null || true')
check 'в образе API нет goose и миграций: реплики не могут гонять их при старте' "$(is "$has_goose" '')"
ids=$(api_ids)
compose up -d --wait >/dev/null 2>&1
check 'обычный compose up после rolling не пересоздаёт реплики' "$(is "$(api_ids)" "$ids")"
}
# Сценарий 6. Не проверка, а демонстрация ограничения: у goose up нет блокировки, и 8 одновременных
# запусков на пустой БД конфликтуют. Поэтому результат печатается, но на ИТОГ не влияет.
race() {
echo "## 6. Что будет при параллельном запуске goose (отдельная пустая БД)"
image=$(compose images -q migrate 2>/dev/null | head -1)
[ -n "$image" ] || image=mtusi-lab3-migrate
docker network create "$RACE_NET" >/dev/null
docker run -d --rm --name "$RACE_DB" --network "$RACE_NET" -e POSTGRES_HOST_AUTH_METHOD=trust \
-e POSTGRES_USER=race -e POSTGRES_DB=race postgres:17.6-alpine >/dev/null
until docker exec "$RACE_DB" pg_isready -U race -d race -h 127.0.0.1 >/dev/null 2>&1; do sleep 0.5; done
for round in 1 2 3; do
docker exec "$RACE_DB" psql -U race -d race -qc 'DROP SCHEMA public CASCADE; CREATE SCHEMA public;' 2>/dev/null
for n in 1 2 3 4 5 6 7 8; do
( if docker run --rm --network "$RACE_NET" --entrypoint goose mtusi-lab3-migrate -dir /migrations postgres \
"postgres://race@$RACE_DB:5432/race?sslmode=disable" up >"$TMP/race.$n" 2>&1; then echo ok; else echo fail; fi >"$TMP/race.$n.code" ) &
done
wait
okc=$(cat "$TMP"/race.*.code | grep -c ok || true)
dup=$(docker exec "$RACE_DB" psql -U race -d race -Atc 'SELECT coalesce(string_agg(version_id::text, $$,$$), $$нет$$) FROM (SELECT version_id FROM goose_db_version GROUP BY 1 HAVING count(*) > 1) d')
ver=$(docker exec "$RACE_DB" psql -U race -d race -Atc 'SELECT max(version_id) FROM goose_db_version')
err=$(cat "$TMP"/race.[0-9] | grep -i -E 'error|fail' | sed -E 's/^[0-9/]+ [0-9:]+ //' | cut -c1-110 | sort | uniq -c | sort -rn | head -1)
echo "раунд $round: успешно $okc из 8, итоговая версия $ver, записаны дважды версии: $dup; частая ошибка: ${err:-нет}"
done
docker rm -f "$RACE_DB" >/dev/null
docker network rm "$RACE_NET" >/dev/null
}
# Основная логика: сценарии идут по порядку, перед каждым ждём 2 реплики в LB.
run() {
echo "# Миграции и замена реплик, $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
compose up -d --wait >/dev/null 2>&1
wait_lb_up 2
check 'исходная версия схемы' "$(is "$(db_version)" "$VERSION")"
expand_under_load
wait_lb_up 2
breaking_under_load
wait_lb_up 2
failed_migration
wait_lb_up 2
bad_image
wait_lb_up 2
once_only
race
[ "$FAILED" = 0 ] && echo 'ИТОГ: PASS' || echo 'ИТОГ: FAIL'
}
# tee показывает ход проверки сразу и пишет его в файл.
run 2>&1 | tee "$OUT"
# Код выхода скрипта: конвейер выше его потерял, поэтому он определяется по итоговой строке.
grep -q '^ИТОГ: PASS' "$OUT"
+52
View File
@@ -0,0 +1,52 @@
#!/bin/sh
# Публичный тест сохранности плюс подтверждение, что контейнеры действительно перезапущены,
# а volumes те же. Результат: evidence/persistence.txt
#
# Запуск из любого каталога при поднятом стенде: sh scripts/persistence-evidence.sh
# Весь стенд на время перезапуска недоступен. Файл результата перезаписывается.
# Код выхода отражает только публичный тест: время запуска контейнеров скрипт записывает,
# но не сравнивает, поэтому блоки "до" и "после" нужно сверить глазами.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Файл с результатом.
OUT=evidence/persistence.txt
# Порт берём из .env, если он там задан (при нескольких значениях последнее), иначе 8080.
PORT=$(sed -n 's/^API_PUBLISH_PORT=//p' .env | tail -n 1)
BASE_URL=${BASE_URL:-http://localhost:${PORT:-8080}}
# Для каждого контейнера стенда: имя, статус, время запуска и подключённые именованные тома.
# Новое started= показывает реальный перезапуск, те же тома показывают, что данные прежние.
state() {
for id in $(docker compose --env-file .env ps -q api lb postgres valkey); do
docker inspect -f '{{.Name}} {{.State.Status}} started={{.State.StartedAt}} volumes={{range .Mounts}}{{if eq .Type "volume"}}{{.Name}} {{end}}{{end}}' "$id"
done | sort
}
# Основная логика; весь её вывод попадает в файл результата (см. конец скрипта).
# Вызов через || отключает set -e внутри run, поэтому ошибка теста обрабатывается через return 1.
run() {
# Шапка доказательства: время и версия кода.
echo "# Persistence $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git rev-parse --short HEAD)$(git diff --quiet HEAD -- . || echo +dirty)"
echo "## до"
state
echo "## тест"
# Публичный тест: создаёт данные и сессию, вызывает restart.sh и проверяет те же данные
# с прежним токеном. Вывод самого restart.sh тест скрывает, чтобы не утекли секреты.
python3 tests/resilience.py --mode persistence --action-script scripts/restart.sh --base-url "$BASE_URL" || return 1
echo "## после"
state
echo "## volumes"
# Даты создания томов: том не пересоздавался, если дата раньше этого запуска.
docker volume ls --filter name=mtusi-lab3_ --format '{{.Name}}' | xargs docker volume inspect -f '{{.Name}} created={{.CreatedAt}}'
}
mkdir -p evidence
# Код запоминаем, чтобы вывести файл на экран и при неудаче.
status=0
run > "$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+45
View File
@@ -0,0 +1,45 @@
#!/bin/sh
# CPU и RAM контейнеров под нагрузкой: профиль как в failover-load.sh, но без отказов.
# docker stats опрашивается в течение всего замера (без прогрева), итог: среднее и максимум.
# 100% CPU соответствует одному ядру. Результат: evidence/level4/resources.txt
#
# Запуск из любого каталога: sh scripts/resources-evidence.sh (стенд должен быть поднят)
set -eu
cd "$(dirname "$0")/.."
. scripts/lb-lib.sh
OUT=evidence/level4/resources.txt
SAMPLES=$(mktemp)
{
echo "# CPU и RAM под нагрузкой, $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
echo "реплик: $(compose ps -q api | wc -l | tr -d ' '), профиль: concurrency=16, запись 20%, замер 60 с, прогрев 5 с"
start_loadgen -duration 60s -warmup 5s -concurrency 16 -label resources
while kill -0 "$LOADGEN_PID" 2>/dev/null; do
docker stats --no-stream --format '{{.Name}} {{.CPUPerc}} {{.MemUsage}}' >>"$SAMPLES"
done
echo "## результат loadgen"
finish_loadgen
echo "## docker stats за время замера"
grep '^mtusi-lab3-' "$SAMPLES" | awk '
function mib(v) {
if (v ~ /GiB$/) return v * 1024
if (v ~ /MiB$/) return v + 0
if (v ~ /KiB$/) return v / 1024
return v / 1048576
}
{
sub(/%$/, "", $2); m = mib($3)
n[$1]++; c[$1] += $2; r[$1] += m
if ($2 + 0 > cm[$1]) cm[$1] = $2 + 0
if (m > rm[$1]) rm[$1] = m
limit[$1] = $5
}
END {
for (k in n)
printf "%s замеров=%d CPU среднее=%.0f%% макс=%.0f%% RAM среднее=%.0f МиБ макс=%.0f МиБ лимит=%s\n",
k, n[k], c[k] / n[k], cm[k], r[k] / n[k], rm[k], limit[k]
}' | sort
} >"$OUT" 2>&1
rm -f "$SAMPLES"
cat "$OUT"
+24
View File
@@ -0,0 +1,24 @@
#!/bin/sh
# Перезапускает API, LB и все используемые хранилища с сохранением volumes.
# Без down -v, flush и повторного seed; migrate при up повторно ничего не применяет.
#
# Вызывается тестом сохранности: make test-persistence ACTION_SCRIPT=scripts/restart.sh
# Можно запускать и вручную из любого каталога: sh scripts/restart.sh
# Стенд на время перезапуска недоступен. Удаляет данные только down -v, здесь его нет.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: compose.yaml и .env ищутся в нём.
cd "$(dirname "$0")/.."
# docker compose с настройками стенда.
compose() { docker compose --env-file .env "$@"; }
# Сначала точка входа и API: они перестают принимать запросы и штатно завершают открытые,
# пока БД и сессии ещё доступны. Контейнеры останавливаются, но не удаляются.
compose stop lb api
# Затем хранилища: штатная остановка, тома остаются на месте.
compose stop postgres valkey
# Запустить всё и дождаться готовности. Миграции уже применены, поэтому migrate ничего не меняет.
# Отказ на любом шаге завершит скрипт с ошибкой благодаря set -e.
compose up -d --wait
+67
View File
@@ -0,0 +1,67 @@
#!/bin/sh
# Уровень 4: rolling update под нагрузкой. Результат: evidence/level4/rolling.{txt,json}
#
# Запуск из любого каталога: sh scripts/rolling-evidence.sh (чуть больше минуты)
# Настройка через окружение: CONCURRENCY (число клиентов, по умолчанию 16).
# Файлы результата перезаписываются, реплики остаются на новом образе с новой меткой.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Общие функции: compose, запуск loadgen, отсчёт времени замера, git_state.
. scripts/lb-lib.sh
CONCURRENCY=${CONCURRENCY:-16}
DIR=evidence/level4
OUT=$DIR/rolling.txt
# Для каждой реплики: имя, короткий ID, метка версии образа и время запуска.
# Новые ID и метка до и после обновления показывают, что реплики действительно заменены.
# $(compose ps -q api) без кавычек намеренно: каждый ID должен стать отдельным аргументом.
versions() {
docker inspect -f '{{.Name}} id={{.Id}} version={{index .Config.Labels "org.opencontainers.image.version"}} started={{.State.StartedAt}}' \
$(compose ps -q api) | sed -E 's/id=([0-9a-f]{12})[0-9a-f]*/id=\1/' | sort
}
# Основная логика; весь её вывод попадает в файл результата (см. конец скрипта).
# Вызов через || отключает set -e внутри run, поэтому каждый шаг сам возвращает ошибку.
run() {
# Шапка доказательства: время и версия кода.
echo "# Rolling update под нагрузкой, $(date -u +%Y-%m-%dT%H:%M:%SZ), commit $(git_state)"
# Поднять стенд, если он не запущен.
compose up -d --wait >/dev/null 2>&1 || return 1
echo "## до"
versions
# Новая метка сборки: код тот же, но по метке видно, какой образ работает.
# export: rolling-update.sh, запущенный ниже, должен использовать её же.
export APP_BUILD="rolling-$(date -u +%Y%m%d%H%M%S)"
# Сборка заранее, чтобы компиляция не конкурировала с замером.
compose build api migrate >/dev/null 2>&1 || return 1
# Нагрузка в фоне: скрипт продолжается, когда начался сам замер.
start_loadgen -duration 60s -warmup 5s -concurrency "$CONCURRENCY" -label rolling \
-out /evidence/level4/rolling.json || return 1
# Первые 10 с замера — RPS до обновления, с ним потом сравниваем.
sleep_until 10
begin=$(elapsed)
echo "t=${begin}s начало rolling update"
# Сама поочерёдная замена. Занимает около 20 с.
sh scripts/rolling-update.sh || return 1
end=$(elapsed)
echo "t=${end}s конец rolling update"
echo "## после"
versions
echo "## результат loadgen"
# Дождаться конца нагрузки. Генератор вернёт ошибку, если сверка нашла потери или дубли.
finish_loadgen || return 1
echo "## сводка"
# RPS до, во время и после обновления, ошибки и сверка истории.
python3 scripts/rolling-summary.py "$DIR/rolling.json" "$begin" "$end"
}
mkdir -p "$DIR"
# Код запоминаем, чтобы вывести файл на экран и при неудаче.
status=0
run >"$OUT" 2>&1 || status=$?
cat "$OUT"
exit "$status"
+30
View File
@@ -0,0 +1,30 @@
#!/usr/bin/env python3
"""Сводка loadgen для окна обновления: rolling-summary.py <json> <начало, с> <конец, с>."""
# Вызывается из rolling-evidence.sh и migration-evidence.sh. Только читает JSON и печатает сводку.
# Начало и конец — секунды замера, в которые шла замена реплик.
import json
import statistics
import sys
# Результат loadgen и границы окна обновления.
data = json.load(open(sys.argv[1], encoding='utf8'))
start, end = int(sys.argv[2]), int(sys.argv[3])
# Посекундная шкала замера; ok(a, b) — успешные запросы по секундам от a включительно до b не включая.
timeline = data['timeline']
ok = lambda a, b: [s['ok'] for s in timeline if a <= s['t'] < b]
# Секунды обновления, включая секунду его окончания.
window = ok(start, end + 1)
# RPS до окна, в окне и после него. После окна 2 с пропускаются как переходные; если таких
# секунд нет, значение будет 0.
print('RPS до обновления: %d; в окне %d-%d с: среднее %d, минимум за секунду %d; после: %d' % (
statistics.mean(ok(0, start)), start, end, statistics.mean(window), min(window),
statistics.mean(ok(end + 3, 10 ** 6) or [0])))
# Окно ошибок расширено на 2 с после конца: ошибка от замены может проявиться чуть позже.
# Секунды без успеха и повторы loadgen посчитал сам, за весь замер.
print('ошибок в окне: %d, всего: %d %s; секунд без единого успеха: %d; записей подтверждено после повтора: %d' % (
sum(s['err'] for s in timeline if start <= s['t'] <= end + 2), sum(s['err'] for s in timeline),
json.dumps(data['errors'], ensure_ascii=False), data['seconds_without_success'], data['writes_confirmed_after_retry']))
# Сколько запросов обслужила каждая реплика: должны быть и старые, и новые.
print('запросов по репликам: %s' % json.dumps(data['requests_per_instance']))
# Сверка истории с подтверждёнными записями: потери и дубли.
print('проверка истории: %s' % json.dumps(data['verify'], ensure_ascii=False))
+70
View File
@@ -0,0 +1,70 @@
#!/bin/sh
# Поочерёдная замена реплик API новым образом без потери доступности.
# Compose не умеет rolling update сам, поэтому: поднять новую реплику, дождаться, пока её
# примет LB, вывести старую. Миграции выполняются один раз до замены и поэтому должны быть
# совместимы с работающей версией (только добавление: expand/contract).
#
# Запуск из любого каталога: sh scripts/rolling-update.sh (стенд должен быть поднят)
# Настройка через окружение: APP_BUILD (метка версии, по умолчанию текущее время).
# Код выхода 1: замена остановлена. Если сбой случился на второй и следующих репликах,
# уже заменённые остаются на новой версии: автоматического отката нет.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: все пути ниже указаны относительно него.
cd "$(dirname "$0")/.."
# Общие функции: compose, wait_lb_up, wait_healthy.
. scripts/lb-lib.sh
# Метка версии попадает в образ при сборке, поэтому экспортируется для docker compose.
APP_BUILD=${APP_BUILD:-$(date -u +%Y%m%d%H%M%S)}
export APP_BUILD
# Сборка переносит тег на новый образ. Если замена сорвётся, тег нужно вернуть,
# иначе следующий compose up разом пересоздаст все реплики из несостоявшейся версии.
first=$(compose ps -q api | head -1)
image=$(docker inspect -f '{{.Config.Image}}' "$first")
previous=$(docker inspect -f '{{.Image}}' "$first")
# Шаг 1. Сборка. Вывод показываем только при ошибке; работающие реплики пока не затронуты.
if ! out=$(compose build api migrate 2>&1); then
echo "$out" >&2
echo "сборка не удалась, реплики не тронуты" >&2
exit 1
fi
# Шаг 2. Миграции, ровно один раз и до замены реплик. При ошибке тег возвращается на прежний образ.
if ! out=$(compose run --rm -T migrate 2>&1); then
echo "$out" >&2
docker image tag "$previous" "$image"
echo "миграция не применена, реплики не тронуты" >&2
exit 1
fi
# Шаг 3. Запомнить старые реплики и убедиться, что LB видит все.
old=$(compose ps -q api)
total=$(echo "$old" | wc -l | tr -d ' ')
wait_lb_up "$total"
# Заменять по одной: число работающих реплик не опускается ниже исходного.
for id in $old; do
# Запустить ещё одну реплику. --no-recreate не трогает старые, --no-deps не трогает хранилища.
# Compose сам создаёт её из текущего образа, то есть уже нового.
before=$(compose ps -q api)
compose up -d --no-deps --no-recreate --scale api="$((total + 1))" api >/dev/null 2>&1
# Новая реплика — ID, которого раньше не было.
new=$(compose ps -q api | grep -vxF "$before")
# Старая реплика выводится только после готовности новой: плохой образ не снижает ёмкость.
if ! wait_healthy "$new" || ! wait_lb_up "$((total + 1))"; then
docker rm -f "$new" >/dev/null
docker image tag "$previous" "$image"
echo "новая реплика не стала готовой и удалена, замена остановлена" >&2
exit 1
fi
# SIGTERM: реплика уходит из балансировки и завершает открытые запросы. Затем удаляется,
# иначе compose up вернул бы её обратно.
docker stop "$id" >/dev/null
docker rm "$id" >/dev/null
# Дождаться, пока LB снова покажет исходное число реплик, и только потом заменять следующую.
wait_lb_up "$total"
echo "заменена реплика ${id%"${id#????????????}"} на ${new%"${new#????????????}"}, версия $APP_BUILD"
done
+65
View File
@@ -0,0 +1,65 @@
#!/usr/bin/env python3
"""Short real Docker experiment; restores original replica count and CPU/RAM limits."""
import json, subprocess as sp, time, pathlib, datetime, csv
ROOT = pathlib.Path(__file__).resolve().parents[1]
OUT = ROOT / 'evidence/track1'
DC = ['docker', 'compose', '--env-file', '.env']
def call(args):
return sp.check_output(args, cwd=ROOT, text=True)
def compose(*args):
return call(DC + list(args))
def ids(service):
return compose('ps', '-q', service).split()
def update(service, cpu, memory, swap=None):
for cid in ids(service):
call(['docker','update','--cpus',str(cpu),'--memory',str(memory),'--memory-swap',str(memory if swap is None else swap),cid])
def ready(n):
for _ in range(90):
raw=compose('exec','-T','lb','wget','-qO-','http://127.0.0.1:8404/stats;csv')
rows=list(csv.reader(raw.splitlines()))
if sum(len(r)>17 and r[0]=='api' and r[1]!='BACKEND' and r[17]=='UP' for r in rows)==n:
return
time.sleep(1)
raise RuntimeError('LB not ready')
def main():
OUT.mkdir(parents=True,exist_ok=True)
original={s:json.loads(call(['docker','inspect',ids(s)[0]]))[0]['HostConfig'] for s in ['api','lb','postgres']}
n0=len(ids('api'))
(OUT/'environment.json').write_text(json.dumps({'utc':datetime.datetime.now(datetime.timezone.utc).isoformat(),'docker':json.loads(call(['docker','info','--format','{{json .}}'])),'original_limits':original},indent=2))
# Same 32-client 80/20 read/write workload; fixed infrastructure in both series.
cases=[('fixed-1',1,2,1024,1,2),('fixed-2',2,1,512,1,2),('fixed-4',4,.5,256,1,2),
('grow-1',1,1,512,1,2),('grow-4',4,1,512,1,2),
('lb2-4',4,1,512,2,2),('db4-4',4,1,512,1,4)]
try:
for label,n,cpu,mem,lb,db in cases:
compose('up','-d','--no-recreate','--scale',f'api={n}','api','lb')
update('api',cpu,f'{mem}m'); update('lb',lb,'256m'); update('postgres',db,'1g')
ready(n)
limits=call(['docker','inspect','--format','{{.Name}} {{.HostConfig.NanoCpus}} {{.HostConfig.Memory}}']+ids('api')+ids('lb')+ids('postgres'))
(OUT/f'{label}-limits.txt').write_text(limits)
for repeat in [1,2]:
name=f'{label}-r{repeat}'
print('RUN',name,flush=True)
compose('exec','-T','postgres','psql','-U','messenger','-d','messenger','-q','-c','ANALYZE;')
with (OUT/f'{name}.log').open('w') as log:
proc=sp.Popen(DC+['--profile','bench','run','--rm','-T','loadgen','-duration','20s','-warmup','5s','-concurrency','32','-label',name,'-out',f'/evidence/track1/{name}.json'],cwd=ROOT,stdout=log,stderr=sp.STDOUT)
deadline=time.monotonic()+180
while 'measure_start' not in (OUT/f'{name}.log').read_text():
if proc.poll() is not None or time.monotonic()>deadline:
raise RuntimeError((OUT/f'{name}.log').read_text())
time.sleep(.2)
with (OUT/f'{name}-stats.jsonl').open('w') as stats:
monitor=sp.Popen(['docker','stats','--format','{{json .}}']+ids('api')+ids('lb')+ids('postgres')+ids('valkey'),stdout=stats,stderr=sp.DEVNULL,text=True)
time.sleep(18)
monitor.terminate(); monitor.wait()
rc=proc.wait(timeout=180)
if rc: raise RuntimeError((OUT/f'{name}.log').read_text())
result=json.loads((OUT/f'{name}.json').read_text())
print(name,round(result['successful_rps']),result['error_share'],result['verify'],flush=True)
finally:
compose('up','-d','--no-recreate','--scale',f'api={n0}','api','lb')
for s,h in original.items():
update(s,h['NanoCpus']/1e9,str(h['Memory']),h['MemorySwap'])
ready(n0)
print('Original limits and replicas restored',flush=True)
if __name__=='__main__': main()
+54
View File
@@ -0,0 +1,54 @@
#!/usr/bin/env python3
"""Build CSV and figures from preserved measurements (no invented values)."""
import csv, json, pathlib, statistics, os
os.environ.setdefault('MPLCONFIGDIR','/private/tmp/track1-mpl')
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
ROOT=pathlib.Path(__file__).resolve().parents[1]
OUT=ROOT/'evidence/track1'
rows=[]
for path in sorted(OUT.glob('*-r[12].json')):
r=json.loads(path.read_text()); label=r['label'].rsplit('-r',1)[0]
samples={}
seen=set()
for line in path.with_name(path.stem+'-stats.jsonl').read_text().splitlines():
# Docker's streaming output may prepend terminal control sequences.
line=line[line.find('{'):]
try: s=json.loads(line)
except ValueError: continue
name=s['Name']
if name not in seen:
seen.add(name)
continue # Initial Docker sample predates the measurement interval.
service=name.rsplit('-',1)[0].replace('mtusi-lab3-','')
samples.setdefault(service,[]).append(float(s['CPUPerc'].rstrip('%')))
row=dict(case=label,repeat=path.stem[-1],rps=r['successful_rps'],read_p95_ms=r['read']['p95_ms'],write_p95_ms=r['write']['p95_ms'],error_share=r['error_share'],lost=r['verify']['lost'],duplicates=r['verify']['duplicate_ids']+r['verify']['duplicate_texts'])
for s,values in samples.items(): row[s+'_cpu_mean']=statistics.mean(values)
rows.append(row)
if not rows: raise SystemExit('No results')
fields=list(dict.fromkeys(k for r in rows for k in r))
with (OUT/'summary.csv').open('w') as f:
w=csv.DictWriter(f,fields); w.writeheader(); w.writerows(rows)
def avg(label,key): return statistics.mean(r[key] for r in rows if r['case']==label)
def bounds(label):
v=[r['rps'] for r in rows if r['case']==label]; m=statistics.mean(v)
return [m-min(v),max(v)-m]
plt.rcParams.update({'font.size':10})
fig,axes=plt.subplots(1,2,figsize=(10,3.5))
for labels,title,ax in [(['fixed-1','fixed-2','fixed-4'],'Общий бюджет API: 2 CPU / 1 ГиБ',axes[0]),(['grow-1','fixed-2','grow-4'],'На реплику: 1 CPU / 512 МиБ',axes[1])]:
means=[avg(l,'rps') for l in labels]
ax.errorbar([1,2,4],means,yerr=list(zip(*(bounds(l) for l in labels))),fmt='o-',capsize=5)
ax.set(xticks=[1,2,4],xlabel='Реплики API',ylabel='Успешные запросы/с',title=title,ylim=(0,max(means)*1.2)); ax.grid(alpha=.25)
fig.tight_layout(); fig.savefig(OUT/'scaling.png',dpi=160); plt.close(fig)
labels=['grow-4','lb2-4','db4-4']
if all(any(r['case']==l for r in rows) for l in labels):
fig,axes=plt.subplots(1,2,figsize=(10,3.5))
axes[0].bar(['Исходный','LB: 2 CPU','БД: 4 CPU'],[avg(l,'rps') for l in labels],yerr=list(zip(*(bounds(l) for l in labels))),capsize=5)
axes[0].set(ylabel='Успешные запросы/с',title='Проверка узкого места: 4 API × 1 CPU')
for s,limit in [('api',100),('lb',100),('postgres',200),('valkey',100)]:
axes[1].bar(s,avg('grow-4',s+'_cpu_mean')/limit*100)
axes[1].axhline(100,color='red',linestyle='--'); axes[1].set(ylabel='% от CPU-лимита',title='Средняя загрузка до улучшения')
fig.tight_layout(); fig.savefig(OUT/'bottleneck.png',dpi=160); plt.close(fig)
for l in dict.fromkeys(r['case'] for r in rows):
print(l, 'RPS', round(avg(l,'rps')), 'read p95',round(avg(l,'read_p95_ms'),2),'write p95',round(avg(l,'write_p95_ms'),2), 'CPU', {s:round(avg(l,s+'_cpu_mean')) for s in ['api','lb','postgres','valkey']})
+34
View File
@@ -0,0 +1,34 @@
#!/bin/sh
# Останавливает одну реплику API, которую назвал тест, и оставляет её остановленной.
# TARGET_INSTANCE_ID — значение X-Instance-Id, то есть короткий ID контейнера.
# БД, сессии и LB не трогает. Восстановление: docker compose --env-file .env up -d --wait
#
# Вызывается тестом отказа: make test-failover ACTION_SCRIPT=scripts/stop-one.sh
# Вручную из любого каталога: TARGET_INSTANCE_ID=<короткий ID> sh scripts/stop-one.sh
# Код выхода: 0 — реплика остановлена, 2 — такой реплики нет.
# -e: выйти при ошибке команды; -u: считать ошибкой неизвестную переменную.
set -eu
# Перейти в корень проекта: compose.yaml и .env ищутся в нём.
cd "$(dirname "$0")/.."
# Без ID завершиться с этим сообщением: останавливать случайную реплику нельзя.
: "${TARGET_INSTANCE_ID:?test provides target API instance alias}"
# Перебрать работающие API-контейнеры. Полные ID сравниваются с коротким по началу строки.
for id in $(docker compose --env-file .env ps -q api); do
case "$id" in
# Шаблон с *: совпадает полный ID, начинающийся с короткого.
"$TARGET_INSTANCE_ID"*)
# Штатная остановка: SIGTERM, реплика уходит из балансировки и завершает открытые запросы.
docker stop "$id" >/dev/null
# Первые 12 символов ID: в обычном sh нет записи ${id:0:12}.
echo "stopped api container ${id%"${id#????????????}"}"
exit 0
;;
esac
done
# Сюда дошли, только если ни один контейнер не подошёл: реплика уже остановлена или ID неверный.
echo "stop-one: no running api container matches the given instance id" >&2
exit 2