Upload answers 202 after staging, a queued job in PostgreSQL and a broker confirm; a separate worker publishes the original and a thumbnail with bounded retries. Adds the job and variant tables, the broker service, the worker S3 user, cleanup and reconcile support for staging and variants, the failure stand with broker and worker, bench and driver updates. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
427 lines
18 KiB
Bash
Executable File
427 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 с,
|
||
# загрузка ≈ 76 с — haproxy.cfg, design change upload-memory, решение
|
||
# 7; async-attachments, решение 3), иначе плановая замена оборвала бы
|
||
# живую загрузку. Обычно дренаж
|
||
# кончается за 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"
|