426 lines
18 KiB
Bash
Executable File
426 lines
18 KiB
Bash
Executable File
#!/bin/sh
|
||
set -eu
|
||
# Поочерёдная замена реплик api на новый образ без простоя (рубрика «4»
|
||
# лабы 3): make rolling_update. Правила — .claude/rules/balancer.md,
|
||
# решения 1–6 — design change rolling-update.
|
||
# 0. предусловия: работает ровно API_REPLICAS реплик, остановленных нет,
|
||
# слотов LB с ручным состоянием (drain, maint) нет, все реплики UP в
|
||
# LB, для ещё одной есть слот; иначе код 2, ничего не менялось;
|
||
# 1. сборка образа: рабочее дерево или ROLLOUT_COMMIT (git archive);
|
||
# 2. миграции один раз: контейнер сервиса migrate пересоздаётся на новом
|
||
# образе и выполняется до новых реплик — в новом образе новые
|
||
# ревизии, они только расширяют схему;
|
||
# 3–5. для каждой старой реплики: рядом одна новая (--scale N+1
|
||
# --no-recreate) → новая healthy и UP в LB → слот старой drain,
|
||
# запросов в полёте 0 → maint → docker stop → docker rm → адрес ушёл
|
||
# из слота → слот ready.
|
||
# Сбой: новая реплика не готова — она удаляется; новая уже UP — вывод
|
||
# старой доводится до конца. В любом исходе работает API_REPLICAS реплик,
|
||
# слоты LB без ручного состояния; повторный запуск доводит замену.
|
||
# Окружение:
|
||
# API_REPLICAS (2) — число реплик до и после;
|
||
# ROLLOUT_COMMIT — собрать образ из файлов commit, а не рабочего дерева
|
||
# (откат без checkout);
|
||
# ROLLOUT_MIGRATE=0 — без миграций: откат на прежний образ, его миграции
|
||
# не знают новой ревизии, а схема только расширялась;
|
||
# ROLLOUT_READY_TIMEOUT (60) — срок готовности новой реплики, с;
|
||
# ROLLOUT_DRAIN_TIMEOUT (90) — срок дренажа старой, с: больше timeout
|
||
# server пути загрузки и наибольшей длительности загрузки (LB 30 с,
|
||
# загрузка ≈ 73 с — haproxy.cfg, design change upload-memory, решение
|
||
# 7), иначе плановая замена оборвала бы живую загрузку. Обычно дренаж
|
||
# кончается за 0–2 с, срок нужен только медленной загрузке.
|
||
# Проект compose — как у самого docker compose: COMPOSE_PROJECT_NAME,
|
||
# COMPOSE_FILE, COMPOSE_ENV_FILES или docker-compose.yml и .env
|
||
# репозитория; стенд bench/ (профиль rollout) вызывает этот же скрипт со
|
||
# своими. Секретов не печатает. Коды: 0 — замена завершена; 2 — неверный
|
||
# ввод или стенд не готов, ничего не менялось; 1 — сбой; 130 / 143 —
|
||
# прерван (Ctrl+C / SIGTERM).
|
||
cd "$(dirname "$0")/.."
|
||
|
||
# runtime API HAProxy: только loopback внутри контейнера LB (haproxy.cfg)
|
||
LB_API_PORT=9999
|
||
|
||
replicas="${API_REPLICAS:-2}"
|
||
ready_timeout="${ROLLOUT_READY_TIMEOUT:-60}"
|
||
drain_timeout="${ROLLOUT_DRAIN_TIMEOUT:-90}"
|
||
commit="${ROLLOUT_COMMIT:-}"
|
||
migrate="${ROLLOUT_MIGRATE:-1}"
|
||
|
||
# состояние текущей замены для trap (решение 5): "" — реплики не тронуты,
|
||
# starting — новая запущена и ещё не UP, replacing — новая UP, старая
|
||
# выводится из LB и удаляется
|
||
state=""
|
||
before=""
|
||
new_id=""
|
||
old_id=""
|
||
old_addr=""
|
||
old_slot=""
|
||
step=""
|
||
|
||
log() {
|
||
printf '%s rolling-update: %s\n' "$(date -u +%H:%M:%S)" "$*"
|
||
}
|
||
|
||
fail() {
|
||
code=$1
|
||
shift
|
||
printf '%s rolling-update: error: %s\n' "$(date -u +%H:%M:%S)" "$*" >&2
|
||
exit "$code"
|
||
}
|
||
|
||
short() {
|
||
printf '%.12s' "$1"
|
||
}
|
||
|
||
count() {
|
||
printf '%s\n' "$1" | grep -c . || true
|
||
}
|
||
|
||
# команда runtime API LB изнутри его контейнера (curl и socat в образе
|
||
# нет, bash есть); ответ — в stdout
|
||
lb() {
|
||
docker compose exec -T haproxy bash -c \
|
||
'exec 3<>"/dev/tcp/127.0.0.1/$2" && printf "%s\n" "$1" >&3 && cat <&3' \
|
||
lb "$1" "$LB_API_PORT"
|
||
}
|
||
|
||
# та же команда LB для оператора — в подсказках ручной уборки
|
||
lb_hint() {
|
||
printf "docker compose exec -T haproxy bash -c 'exec 3<>/dev/tcp/127.0.0.1/%s && echo \"%s\" >&3 && cat <&3'" \
|
||
"$LB_API_PORT" "$1"
|
||
}
|
||
|
||
# смена состояния слота: успешная команда отвечает пустой строкой, ошибка
|
||
# — текстом («No such server.»)
|
||
lb_set() {
|
||
answer=$(lb "set server api/$1 state $2" | tr -d '\r\n')
|
||
if [ -n "$answer" ]; then
|
||
printf '%s rolling-update: error: LB set server api/%s state %s: %s\n' \
|
||
"$(date -u +%H:%M:%S)" "$1" "$2" "$answer" >&2
|
||
return 1
|
||
fi
|
||
}
|
||
|
||
# занятые слоты backend api: «слот адрес запросов_в_полёте состояние»;
|
||
# состояние последним — в нём бывают пробелы («DOWN 1/2»)
|
||
slots() {
|
||
lb "show stat" | awk -F, '
|
||
/^# / { sub(/^# /, ""); for (i = 1; i <= NF; i++) col[$i] = i; next }
|
||
$1 == "api" && $2 != "BACKEND" && $(col["addr"]) != "" {
|
||
addr = $(col["addr"]); sub(/:[0-9]+$/, "", addr)
|
||
print $2, addr, $(col["scur"]), $(col["status"])
|
||
}'
|
||
}
|
||
|
||
slot_total() {
|
||
lb "show stat" | awk -F, '$1 == "api" && $2 != "BACKEND" && $2 != "" { n++ } END { print n + 0 }'
|
||
}
|
||
|
||
# слоты с ручным состоянием, которое оставила прерванная замена: флаги
|
||
# FMAINT (1) и FDRAIN (8) в srv_admin_state; обслуживание по DNS (32) —
|
||
# штатное. show stat их не различает: у слота без адреса и то и другое —
|
||
# «MAINT (resolution)», а следующей реплике в этом слоте LB запросов не даст
|
||
manual_slots() {
|
||
lb "show servers state api" | awk '
|
||
/^# / { for (i = 2; i <= NF; i++) col[$i] = i - 1; next }
|
||
NF > 5 && col["srv_admin_state"] {
|
||
s = $(col["srv_admin_state"])
|
||
if (s % 2 == 1 || int(s / 8) % 2 == 1) print $(col["srv_name"])
|
||
}'
|
||
}
|
||
|
||
# поле слота с адресом $1: 1 — слот, 3 — запросов в полёте, 4 — состояние
|
||
slot_field() {
|
||
slots | awk -v addr="$1" -v field="$2" '
|
||
$2 == addr { if (field == 4) { $1 = $2 = $3 = ""; sub(/^ +/, "") ; print } else print $field; exit }'
|
||
}
|
||
|
||
address() {
|
||
docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' "$1"
|
||
}
|
||
|
||
health() {
|
||
docker inspect -f '{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' "$1" 2>/dev/null || echo gone
|
||
}
|
||
|
||
now() {
|
||
date +%s
|
||
}
|
||
|
||
# новая реплика — ID, которого не было до up --scale (список before)
|
||
find_new() {
|
||
for id in $(docker compose ps -a -q --no-trunc api); do
|
||
case " $before " in
|
||
*" $id "*) ;;
|
||
*) printf '%s\n' "$id" ;;
|
||
esac
|
||
done
|
||
}
|
||
|
||
# дождаться, пока адрес удалённой реплики уйдёт из слота (DNS, hold 1 с),
|
||
# не дольше 10 с
|
||
wait_address_gone() {
|
||
deadline=$(($(now) + 10))
|
||
while [ -n "$(slot_field "$1" 1)" ]; do
|
||
if [ "$(now)" -ge "$deadline" ]; then
|
||
log "$step: address $1 still in slot after 10s"
|
||
return 0
|
||
fi
|
||
sleep 0.25
|
||
done
|
||
}
|
||
|
||
# довести вывод старой реплики до удаления (решение 3, шаги 3–5)
|
||
# Ошибки проверяются явно (|| return 1): в trap функция вызывается под
|
||
# if, где set -e не действует. Повторный вызов после частичного — тоже
|
||
# корректен: удалённый контейнер пропускается
|
||
remove_old() {
|
||
lb_set "$old_slot" maint || return 1
|
||
if docker inspect "$old_id" >/dev/null 2>&1; then
|
||
log "$step: maint slot $old_slot, stopping old $(short "$old_id")"
|
||
stopping=$(now)
|
||
# stop_grace_period сервиса: uvicorn завершается сам не позже 8 с
|
||
docker stop --timeout 10 "$old_id" >/dev/null || return 1
|
||
stopped=$(($(now) - stopping))
|
||
# код выхода: 0 — graceful по SIGTERM, 137 — SIGKILL по сроку
|
||
exited=$(docker inspect -f '{{.State.ExitCode}}' "$old_id" 2>/dev/null || echo '?')
|
||
docker rm "$old_id" >/dev/null || return 1
|
||
log "$step: removed old $(short "$old_id") (stop ${stopped}s, exit $exited)"
|
||
fi
|
||
wait_address_gone "$old_addr"
|
||
lb_set "$old_slot" ready || return 1
|
||
log "$step: slot $old_slot ready"
|
||
}
|
||
|
||
# убрать новую реплику, которая не стала готовой (решение 7 design change
|
||
# fix-known-issues). Есть слот (DNS уже отдал его) — maint, затем штатная
|
||
# остановка: стартующий процесс выходит сразу по раннему обработчику
|
||
# SIGTERM, работающий — дорабатывает запросы, которые LB успел отправить
|
||
# на слот до maint. Слота нет — запросов на ней не было, и kill безопасен:
|
||
# это и страховка на первые десятки миллисекунд старта интерпретатора, где
|
||
# SIGTERM ещё некому принять. Прерывание между up --scale и поиском новой:
|
||
# ID ещё не известен, ищется здесь
|
||
remove_new() {
|
||
if [ -z "$new_id" ]; then
|
||
new_id=$(find_new | tail -n 1)
|
||
fi
|
||
if [ -z "$new_id" ]; then
|
||
log "$step: no new replica was created"
|
||
return 0
|
||
fi
|
||
log "$step: removing new replica $(short "$new_id") that is not ready"
|
||
new_addr=$(address "$new_id" 2>/dev/null || true)
|
||
new_slot=""
|
||
if [ -n "$new_addr" ]; then
|
||
new_slot=$(slot_field "$new_addr" 1)
|
||
fi
|
||
if [ -z "$new_slot" ]; then
|
||
docker rm -f "$new_id" >/dev/null || return 1
|
||
log "$step: removed new $(short "$new_id") (no slot: docker rm -f)"
|
||
return 0
|
||
fi
|
||
lb_set "$new_slot" maint || return 1
|
||
stopping=$(now)
|
||
docker stop --timeout 10 "$new_id" >/dev/null || return 1
|
||
stopped=$(($(now) - stopping))
|
||
exited=$(docker inspect -f '{{.State.ExitCode}}' "$new_id" 2>/dev/null || echo '?')
|
||
docker rm -f "$new_id" >/dev/null || return 1
|
||
log "$step: removed new $(short "$new_id") (slot $new_slot: stop ${stopped}s, exit $exited)"
|
||
wait_address_gone "$new_addr"
|
||
lb_set "$new_slot" ready || return 1
|
||
}
|
||
|
||
cleanup() {
|
||
code=$?
|
||
set +e
|
||
trap '' INT TERM
|
||
case "$state" in
|
||
starting)
|
||
if ! remove_new; then
|
||
log "manual cleanup: docker rm -f ${new_id:-<new api container>}; slots in manual state: $(lb_hint 'show servers state api') (srv_admin_state 1 or 8); set each ready: $(lb_hint 'set server api/<slot> state ready')"
|
||
fi
|
||
;;
|
||
replacing)
|
||
log "$step: new replica is UP, finishing removal of old $(short "$old_id")"
|
||
if ! remove_old; then
|
||
log "manual cleanup: docker rm -f $old_id; then $(lb_hint "set server api/$old_slot state ready")"
|
||
fi
|
||
;;
|
||
esac
|
||
if [ "$code" -ne 0 ] && [ -n "$state" ]; then
|
||
log "stopped: $(count "$(docker compose ps -q api)") api replicas running; rerun make rolling_update to finish"
|
||
fi
|
||
exit "$code"
|
||
}
|
||
|
||
for value in "$replicas" "$ready_timeout" "$drain_timeout"; do
|
||
case "$value" in
|
||
'' | *[!0-9]* | 0) fail 2 "API_REPLICAS and ROLLOUT_*_TIMEOUT must be positive integers" ;;
|
||
esac
|
||
done
|
||
case "$migrate" in
|
||
0 | 1) ;;
|
||
*) fail 2 "ROLLOUT_MIGRATE must be 0 or 1" ;;
|
||
esac
|
||
if [ -n "$commit" ] && ! git rev-parse --verify --quiet "$commit^{commit}" >/dev/null; then
|
||
fail 2 "ROLLOUT_COMMIT $commit is not a commit of this repository"
|
||
fi
|
||
|
||
# 0. предусловия — ничего не меняют
|
||
if ! lb "show info" >/dev/null 2>&1; then
|
||
fail 2 "HAProxy runtime API is unreachable: start the LB with the current infra/haproxy/haproxy.cfg (docker compose up -d --force-recreate --no-deps haproxy)"
|
||
fi
|
||
old=$(docker compose ps -q --no-trunc api)
|
||
all=$(docker compose ps -a -q --no-trunc api)
|
||
if [ "$(count "$all")" -ne "$(count "$old")" ]; then
|
||
fail 2 "stopped api replicas exist: run make replicas first"
|
||
fi
|
||
if [ "$(count "$old")" -ne "$replicas" ]; then
|
||
fail 2 "$(count "$old") api replicas running, API_REPLICAS=$replicas: run make replicas first"
|
||
fi
|
||
slots_total=$(slot_total)
|
||
if [ $((replicas + 1)) -gt "$slots_total" ]; then
|
||
fail 2 "API_REPLICAS + 1 = $((replicas + 1)) replicas do not fit $slots_total LB slots"
|
||
fi
|
||
# раньше проверки UP: слот работающей реплики в ручном drain — не повод
|
||
# для make replicas, а остаток прерванной замены
|
||
stuck=$(manual_slots | tr '\n' ' ')
|
||
if [ -n "$stuck" ]; then
|
||
fail 2 "LB slots left in manual drain/maint by an interrupted rollout: ${stuck% }; set each ready: $(lb_hint 'set server api/<slot> state ready')"
|
||
fi
|
||
for id in $old; do
|
||
status=$(slot_field "$(address "$id")" 4)
|
||
if [ "$status" != UP ]; then
|
||
fail 2 "replica $(short "$id") is not UP in LB (${status:-no slot}): run make replicas and wait"
|
||
fi
|
||
done
|
||
image=$(docker inspect -f '{{.Config.Image}}' "$(printf '%s\n' "$old" | head -n 1)")
|
||
ids=""
|
||
for id in $old; do
|
||
ids="$ids $(short "$id")"
|
||
done
|
||
log "start: $replicas replicas${ids}, image $image from ${commit:-working tree}"
|
||
began=$(now)
|
||
trap cleanup EXIT
|
||
trap 'exit 130' INT
|
||
trap 'exit 143' TERM
|
||
|
||
# 1. сборка: тот же тег сервиса, работающие реплики остаются на прежнем
|
||
started=$(now)
|
||
if [ -n "$commit" ]; then
|
||
# только файлы commit, рабочее дерево и HEAD не меняются (решение 6)
|
||
git archive --format=tar "$commit" | docker build -q -t "$image" - >/dev/null
|
||
else
|
||
docker compose build api
|
||
fi
|
||
log "build done in $(($(now) - started))s"
|
||
|
||
# 2. миграции один раз, до первой новой реплики (спек db-migrations).
|
||
# Контейнер сервиса migrate пересоздаётся на новом образе, а не одноразовый
|
||
# run --rm: иначе в стенде остался бы migrate прежнего образа, и restart.sh
|
||
# (start api запускает зависимость migrate) гонял бы старые миграции на
|
||
# новой схеме — «Can't locate revision», exit 255, реплики не стартуют
|
||
if [ "$migrate" = 1 ]; then
|
||
started=$(now)
|
||
if ! docker compose up --no-deps --no-build --force-recreate \
|
||
--abort-on-container-exit --exit-code-from migrate migrate; then
|
||
fail 1 "migrations failed: no replica was replaced"
|
||
fi
|
||
log "migrate done in $(($(now) - started))s"
|
||
else
|
||
log "migrate skipped (ROLLOUT_MIGRATE=0)"
|
||
fi
|
||
|
||
number=0
|
||
for old_id in $old; do
|
||
number=$((number + 1))
|
||
step="replica $number/$replicas"
|
||
|
||
# 3. одна новая реплика рядом со старыми
|
||
# new_id прежнего шага — уже рабочая реплика: сбросить до state, иначе
|
||
# уборка удалила бы её вместо новой
|
||
new_id=""
|
||
before=$(docker compose ps -a -q --no-trunc api | tr '\n' ' ')
|
||
state=starting
|
||
started=$(now)
|
||
docker compose up -d --no-deps --no-recreate --no-build --scale "api=$((replicas + 1))" api
|
||
new_id=$(find_new | tail -n 1)
|
||
if [ -z "$new_id" ]; then
|
||
state=""
|
||
fail 1 "$step: compose did not start a new replica"
|
||
fi
|
||
log "$step: started new $(short "$new_id")"
|
||
|
||
# 4. новая готова: healthy (или running без healthcheck) и UP в LB по её
|
||
# адресу — слот начинает DOWN и включается после rise проверок (решение 4)
|
||
deadline=$(($(now) + ready_timeout))
|
||
while :; do
|
||
current=$(health "$new_id")
|
||
status=""
|
||
case "$current" in
|
||
healthy | running)
|
||
new_addr=$(address "$new_id")
|
||
if [ -n "$new_addr" ]; then
|
||
status=$(slot_field "$new_addr" 4)
|
||
fi
|
||
if [ "$status" = UP ]; then
|
||
break
|
||
fi
|
||
;;
|
||
exited | dead | gone)
|
||
fail 1 "$step: new replica $(short "$new_id") $current"
|
||
;;
|
||
esac
|
||
if [ "$(now)" -ge "$deadline" ]; then
|
||
fail 1 "$step: new replica $(short "$new_id") not UP in LB within ${ready_timeout}s (container ${current}, LB ${status:-no slot})"
|
||
fi
|
||
sleep 0.25
|
||
done
|
||
log "$step: new $(short "$new_id") addr $new_addr slot $(slot_field "$new_addr" 1) UP in $(($(now) - started))s"
|
||
|
||
# 5. старая: drain → запросов в полёте 0 → maint → stop → rm → ready
|
||
old_addr=$(address "$old_id")
|
||
old_slot=$(slot_field "$old_addr" 1)
|
||
if [ -z "$old_slot" ]; then
|
||
fail 1 "$step: old replica $(short "$old_id") has no LB slot"
|
||
fi
|
||
state=replacing
|
||
lb_set "$old_slot" drain
|
||
log "$step: drain old $(short "$old_id") addr $old_addr slot $old_slot"
|
||
started=$(now)
|
||
deadline=$((started + drain_timeout))
|
||
while :; do
|
||
inflight=$(slot_field "$old_addr" 3)
|
||
if [ "${inflight:-0}" = 0 ]; then
|
||
log "$step: old $(short "$old_id") idle after $(($(now) - started))s"
|
||
break
|
||
fi
|
||
if [ "$(now)" -ge "$deadline" ]; then
|
||
log "$step: drain timeout ${drain_timeout}s, $inflight requests in flight: graceful stop finishes them"
|
||
break
|
||
fi
|
||
sleep 0.25
|
||
done
|
||
remove_old
|
||
state=""
|
||
old_slot=""
|
||
done
|
||
|
||
# итог: API_REPLICAS реплик, ни одной прежней, все UP
|
||
current=$(docker compose ps -q --no-trunc api)
|
||
if [ "$(count "$current")" -ne "$replicas" ]; then
|
||
fail 1 "$(count "$current") api replicas running after rollout, expected $replicas"
|
||
fi
|
||
ids=""
|
||
for id in $current; do
|
||
case " $(printf '%s\n' "$old" | tr '\n' ' ') " in
|
||
*" $id "*) fail 1 "old replica $(short "$id") still running" ;;
|
||
esac
|
||
status=$(slot_field "$(address "$id")" 4)
|
||
if [ "$status" != UP ]; then
|
||
fail 1 "replica $(short "$id") is not UP in LB after rollout (${status:-no slot})"
|
||
fi
|
||
ids="$ids $(short "$id")"
|
||
done
|
||
log "done: $replicas replicas${ids} UP in $(($(now) - began))s"
|