forked from mtusi2026/mtusi2026lab3
work 3
This commit is contained in:
Executable
+95
@@ -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"
|
||||
Executable
+90
@@ -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"
|
||||
Executable
+51
@@ -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))
|
||||
Executable
+40
@@ -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"
|
||||
Executable
+353
@@ -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)
|
||||
Executable
+66
@@ -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"
|
||||
Executable
+146
@@ -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()
|
||||
Executable
+71
@@ -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"
|
||||
Executable
+51
@@ -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)
|
||||
Executable
+17
@@ -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"
|
||||
@@ -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)"; }
|
||||
Executable
+34
@@ -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)
|
||||
Executable
+23
@@ -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"
|
||||
Executable
+209
@@ -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()
|
||||
Executable
+25
@@ -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"
|
||||
Executable
+298
@@ -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"
|
||||
Executable
+52
@@ -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"
|
||||
Executable
+45
@@ -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"
|
||||
Executable
+24
@@ -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
|
||||
Executable
+67
@@ -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"
|
||||
Executable
+30
@@ -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))
|
||||
Executable
+70
@@ -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
|
||||
@@ -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()
|
||||
@@ -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']})
|
||||
Executable
+34
@@ -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
|
||||
Reference in New Issue
Block a user