429 lines
19 KiB
Bash
Executable File
429 lines
19 KiB
Bash
Executable File
#!/bin/sh
|
||
set -eu
|
||
# make rolling-update: реплики api по одной переводятся на свежий образ,
|
||
# а API всё это время отвечает (рубрика «4» лабы 3, требование осталось и
|
||
# дальше). Подробности — infra/AGENTS.md, «Поочерёдная замена». В compose
|
||
# такого режима нет (update_config бывает только у Swarm), а сторонний
|
||
# плагин ради этого означал бы ещё одну незакреплённую зависимость.
|
||
#
|
||
# Шаги:
|
||
# 0. проверка стенда. Живых реплик ровно API_REPLICAS, остановленных
|
||
# нет, каждая UP в LB; слотов, брошенных в drain/maint, нет; под ещё
|
||
# одну реплику есть свободный слот. Иначе выход с кодом 2 до любых
|
||
# изменений;
|
||
# 1. сборка образа из рабочего дерева. ROLLOUT_BUILD=0 пропускает шаг —
|
||
# так работает bench/, который заранее вешает тег на нужный образ;
|
||
# 2. migrate на новом образе, один раз и до первой новой реплики. Ревизии
|
||
# только добавляют схему (migrations/AGENTS.md), и старые реплики
|
||
# на ней продолжают работать;
|
||
# 3–5. цикл по старым репликам: up --scale N+1 --no-recreate добавляет
|
||
# одну новую; ждём её healthy и UP в LB; слот старой уходит в drain,
|
||
# пока активных запросов не станет 0, затем в maint; docker stop и rm;
|
||
# когда DNS уберёт адрес, слот снова ready.
|
||
# Если что-то сорвалось: не готовую новую реплику удаляем, а если новая
|
||
# уже UP — старую всё равно выводим до конца. При любом исходе живых
|
||
# реплик остаётся API_REPLICAS, ручных состояний в LB нет, и повторный
|
||
# запуск продолжит работу. Отдельного отката нет: вернуть прежний код и
|
||
# запустить ещё раз (схема только расширялась, старый код на ней живёт).
|
||
#
|
||
# Переменные:
|
||
# API_REPLICAS (2) — сколько реплик должно быть в начале и в конце;
|
||
# ROLLOUT_BUILD (1) — собирать ли образ api из рабочего дерева;
|
||
# ROLLOUT_MIGRATE (1) — запускать ли миграции;
|
||
# ROLLOUT_READY_TIMEOUT (60) — секунд на то, чтобы новая стала UP;
|
||
# ROLLOUT_DRAIN_TIMEOUT (90) — секунд на дренаж старой. Запас над самой
|
||
# длинной загрузкой вложения (~81 с, set-timeout в haproxy.cfg), чтобы
|
||
# плановая замена её не рвала; обычно дренаж занимает доли секунды.
|
||
# Проект compose выбирают те же переменные, что и для docker compose
|
||
# (COMPOSE_PROJECT_NAME, COMPOSE_FILE, COMPOSE_ENV_FILES), по умолчанию —
|
||
# compose.yaml и .env из корня; поэтому профиль rollout в bench/ зовёт
|
||
# этот же скрипт. Секреты в вывод не попадают.
|
||
# Выход: 0 — все реплики заменены; 2 — плохие параметры или стенд не в
|
||
# том состоянии (ничего не тронуто); 1 — ошибка по ходу; 130 и 143 —
|
||
# прерывание через Ctrl+C и SIGTERM.
|
||
cd "$(dirname "$0")/.."
|
||
|
||
# порт runtime API из haproxy.cfg; слушает он только 127.0.0.1 контейнера LB
|
||
LB_API_PORT=9999
|
||
|
||
replicas="${API_REPLICAS:-2}"
|
||
ready_timeout="${ROLLOUT_READY_TIMEOUT:-60}"
|
||
drain_timeout="${ROLLOUT_DRAIN_TIMEOUT:-90}"
|
||
build="${ROLLOUT_BUILD:-1}"
|
||
migrate="${ROLLOUT_MIGRATE:-1}"
|
||
|
||
# фаза текущего круга — по ней trap решает, что прибирать. Пусто: ничего
|
||
# не трогали. starting: контейнер новой реплики есть, в LB он пока не 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 через exec в контейнер LB. В образе нет
|
||
# ни curl, ни socat, поэтому используется /dev/tcp из bash
|
||
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_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"
|
||
}
|
||
|
||
# set server ... state: при успехе HAProxy ничего не пишет, при ошибке
|
||
# объясняет причину (например, 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 с адресом: имя, IP, scur, status.
|
||
# status стоит в конце, потому что может содержать пробел (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 }'
|
||
}
|
||
|
||
# слоты, которые прерванная замена бросила в drain или maint. Смотрим биты
|
||
# srv_admin_state 1 (FMAINT) и 8 (FDRAIN); бит 32 ставит сам резолвер, он не
|
||
# в счёт. По show stat их не отличить: пустой слот в обоих случаях показан
|
||
# как MAINT (resolution), но ручной maint так и не пустит запросы к
|
||
# реплике, которая потом займёт этот слот
|
||
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"])
|
||
}'
|
||
}
|
||
|
||
# одно поле из вывода slots для IP $1; $2 — номер (1 имя, 3 scur, 4 status)
|
||
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 контейнеров api, которых не было в снимке $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
|
||
}
|
||
|
||
# ждать до 10 с, пока резолвер LB (hold 1 с) не освободит слот от IP $1
|
||
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–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 успевает за SHUTDOWN_TIMEOUT
|
||
docker stop --timeout 10 "$old_id" >/dev/null || return 1
|
||
stopped=$(($(now) - stopping))
|
||
# 0 — вышла сама по SIGTERM, 137 — docker добил её по таймауту
|
||
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"
|
||
}
|
||
|
||
# снять новую реплику, которая так и не стала готовой. Если DNS уже дал ей
|
||
# слот, сначала maint и обычный stop: только что запущенный процесс сразу
|
||
# выйдет через ранний обработчик SIGTERM (src/early_stop.py), а успевший
|
||
# подняться доработает то, что LB отправил ему до maint. Без слота
|
||
# запросов к ней не было, поэтому годится docker rm -f — он же спасает в
|
||
# первые миллисекунды старта, пока интерпретатору нечем принять SIGTERM.
|
||
# Если прервали между up --scale и find_new, 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
|
||
for value in "$build" "$migrate"; do
|
||
case "$value" in
|
||
0 | 1) ;;
|
||
*) fail 2 "ROLLOUT_BUILD and ROLLOUT_MIGRATE must be 0 or 1" ;;
|
||
esac
|
||
done
|
||
|
||
# 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
|
||
# ручной drain у живой реплики — след прерванной замены, и make replicas
|
||
# тут не поможет; поэтому эта проверка идёт до проверки UP
|
||
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"
|
||
began=$(now)
|
||
trap cleanup EXIT
|
||
trap 'exit 130' INT
|
||
trap 'exit 143' TERM
|
||
|
||
# 1. сборка под прежний тег. Запущенные контейнеры ссылаются на образ по
|
||
# ID, так что перевешенный тег их не затрагивает
|
||
if [ "$build" = 1 ]; then
|
||
started=$(now)
|
||
docker compose build api
|
||
log "build done in $(($(now) - started))s"
|
||
else
|
||
log "build skipped (ROLLOUT_BUILD=0): tag $image already points to the new image"
|
||
fi
|
||
|
||
# 2. миграции — один раз и раньше первой новой реплики. Именно пересоздаём
|
||
# контейнер migrate на новом образе, а не run --rm: иначе в стенде остался
|
||
# бы migrate со старым образом, и restart.sh (start api тянет за собой
|
||
# migrate) запускал бы старые ревизии против новой схемы — «Can't locate
|
||
# revision», реплики не поднимутся
|
||
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, если проверки нет)
|
||
# и её слот UP. Слот стартует в DOWN и поднимается после rise удачных проверок
|
||
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, ждём scur = 0 (или срок), затем remove_old
|
||
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
|
||
|
||
# финальная сверка: реплик столько же, старых ID нет, все 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"
|