Error Handling: set -euo pipefail'in Gerçek Davranışı, trap, Cleanup, Retry ve Kilit
set -e, sonucu koşul olarak kullanılan komutlarda ve bu koşullarda çağrılan function'ların içinde çalışmaz; local x=$(...), command substitution ve (( count++ )) da sürpriz yapar. Bookstore'un deploy script'ine set -Eeuo pipefail, call stack yazan bir ERR trap'i, yarım klasör bırakmayan EXIT trap'i, retry, timeout, flock ile tek deploy kilidi ve tekrar çalıştırılınca zarar vermeyen bir akış ekliyoruz.
Sürüm notu: Bu yazıdaki örnekler Ubuntu 24.04 LTS (uzun süreli destek sürümü) üzerinde Bash 5.2.21 ve kaynaktan derlenen Bash 5.3.20 ile, ShellCheck 0.11.0 ve util-linux 2.39 içindeki flock kullanılarak denenmiştir.
Önce Tahmin Et
Script set -euo pipefail ile başlıyor; bunun "herhangi bir komut hata verirse dur" demek olduğunu düşünüyoruz. Artifact yokken ne olur?
#!/usr/bin/env bash
set -euo pipefail
check_artifact() {
ls /var/tmp/bookstore/bookstore-api-9.9.9-linux-x64.tar.gz
echo "artifact found"
}
if check_artifact; then
echo "deploying"
fi
Script ls'in hatasında mı durur, yoksa deploying yazar mı? Exit code kaç olur? Cevap bir sonraki bölümde.
Önceki yazıyı hazırlarken kütüphaneye start_log'u eklemeyi unuttuğum bir denemede deploy script'i start_log: command not found yazıp hiçbir şey olmamış gibi devam etmişti. Bash'in varsayılanı bu: bir komut başarısız olunca bir sonrakine geçer. Bu yazıda bu varsayılanı değiştiriyoruz ve değiştirmenin sınırlarını görüyoruz: set -e'nin yakalamadığı durumlar, set -u, pipefail ve inherit_errexit, hatanın yerini gösteren bir bir komut başarısız olunca çalışan ERR trap'i, script biterken çalışan EXIT trap'iyle cleanup, retry ve timeout, flock ile aynı anda tek deploy ve tekrar çalıştırıldığında zarar vermeyen bir deploy. Örnekler yine sitedeki serilerin ortak örnek uygulaması Bookstore'un (bir online kitapçı) deploy script'inden.
set -e Gerçekte Ne Yapar?
Önce Tahmin Et'in cevabı:
$ ./predict.sh; echo "exit=$?"
ls: cannot access '/var/tmp/bookstore/bookstore-api-9.9.9-linux-x64.tar.gz': No such file or directory
artifact found
deploying
exit=0
set -e (errexit), bir komut sıfırdan farklı döndüğünde shell'i durdurur; ama komutun sonucu bir koşul olarak kullanılıyorsa durdurmaz. if, while ve until'in koşulu, && ve || zincirlerinde son komut dışındaki her komut ve ! ile tersine çevrilen komut bu istisnalara giriyor. Asıl şaşırtan kısım şu: istisna, koşulda çağrılan function'ın içine kadar uzanıyor. check_artifact if'te çağrıldığı için içindeki ls'in hatası da görmezden gelindi; function son komutu echo'nun sonucuyla, yani 0 ile döndü. Diğer durumlar, her biri ayrı bir bash -c ile:
$ bash -c 'set -e; false && echo "not printed"; echo "after the && list"'; echo "exit=$?"
after the && list
exit=0
$ bash -c 'set -e; f() { false; echo "f continues after false"; }; f || echo "f failed"'; echo "exit=$?"
f continues after false
exit=0
$ bash -c 'set -e; f() { local v=$(false); echo "v=[$v], still running"; }; f'; echo "exit=$?"
v=[], still running
exit=0
$ bash -c 'set -e; v=$(false; echo "inside, after false"); echo "v=[$v]"'; echo "exit=$?"
v=[inside, after false]
exit=0
$ bash -c 'set -e; count=0; (( count++ )); echo "count=$count"'; echo "exit=$?"
exit=1
$ bash -c 'set -e; count=0; count=$((count + 1)); echo "count=$count"'; echo "exit=$?"
count=1
exit=0
$ bash -c 'set -e; false | true; echo "pipeline without pipefail"'; echo "exit=$?"
pipeline without pipefail
exit=0
Sırayla: && zincirinin ilk komutu başarısız olunca zincir duruyor ama script devam ediyor. f || ... ile çağrılan function'ın içinde set -e tamamen kapalı gibi davranıyor. local v=$(false) dördüncü yazıda gördüğümüz maskeleme: satırın exit code'u local'ın, yani 0. Command substitution'ın içi varsayılan olarak set -e'yi miras almıyor; false'tan sonra echo da çalıştı. (( count++ )) ise ters yönden şaşırtıyor: post-increment eski değeri döndürüyor, ifadenin değeri 0 olunca (( )) 1 dönüyor ve script ilk artırmada ölüyor. Sayaç için count=$((count + 1)) yaz. Son satır da önceki yazıdan: pipefail olmadan pipeline'ın soldaki hatası görünmüyor.
Bu yüzden set -e bir emniyet ağı, kontrol mekanizması değil. Önemli bir adımın sonucunu açıkça kontrol et (tar ... || die "..."), değer döndüren function'ları koşul içinde çağırırken içlerinin korunmadığını bil. Greg's Wiki'deki BashFAQ'nun 105. maddesi bu istisnaların uzun listesini tutuyor ve set -e'ye hiç güvenmemeyi önerenler de var. Bu seride kullanıyoruz, çünkü fark edilmeyen bir hatayla devam etmek, beklenmedik bir yerde durmaktan daha pahalı; ama yerini bilerek.
set -u, pipefail ve inherit_errexit
set -u (nounset), tanımsız bir variable'ın genişletilmesini hata sayar. Yazım hatalarını ve unutulan argümanları yakalar:
$ bash -c 'set -u; echo "root=$BOOKSTORE_ROOT"'; echo "exit=$?"
bash: line 1: BOOKSTORE_ROOT: unbound variable
exit=127
$ bash -c 'set -u; echo "root=${BOOKSTORE_ROOT:-/opt/bookstore}"'; echo "exit=$?"
root=/opt/bookstore
exit=0
$ ./unset-arg.sh; echo "exit=$?"
./unset-arg.sh: line 4: $1: unbound variable
exit=1
İsteğe bağlı her değer için ${var:-default} ya da ${1:-} yaz; serinin script'leri ikinci yazıdan beri böyle. pipefail'i önceki yazıda gördük. Command substitution'ın set -e'yi miras almaması için bash 4.4'ten beri bir option var:
$ bash -c 'set -e; shopt -s inherit_errexit; v=$(false; echo "inside, after false"); echo "v=[$v]"'; echo "exit=$?"
exit=1
Serinin bütün script'leri artık header yorumunun hemen altında aynı iki satırla başlıyor:
set -Eeuo pipefail
shopt -s inherit_errexit
-E (errtrace) ERR trap'inin function'lara da geçmesini sağlıyor; bir sonraki bölümde. Bu satırları eklemek davranış değiştiren bir değişiklik, test etmeden ekleme. Bizde bir regresyon çıkardı:
$ BOOKSTORE_ROOT=/tmp/empty ./scripts/bookstore-ctl.sh releases; echo "exit=$?"
exit=1
Hiçbir mesaj yok, yalnız 1. Sebep cmd_releases'teki current=$(readlink -f "$ROOT/current"): kök klasör yoksa readlink -f başarısız oluyor ve önceden boş bir değerle devam eden script şimdi sessizce duruyor. Düzeltme, beklenen durumu açıkça ele almak:
[[ -d $ROOT/releases ]] || die "no releases under $ROOT"
current=$(readlink -f "$ROOT/current") || current=""
$ BOOKSTORE_ROOT=/tmp/empty ./scripts/bookstore-ctl.sh releases; echo "exit=$?"
2026-11-15T04:23:22Z ERROR: no releases under /tmp/empty
exit=1
ERR Trap ile Hatanın Yerini Görmek
set -e script'i durdurur ama nerede durduğunu söylemez. ERR trap'i, set -e'nin devreye gireceği her başarısız komutta çalışır. Dikkat edilmesi gereken nokta, varsayılan olarak function'lara geçmemesi:
#!/usr/bin/env bash
set -eu
trap 'echo "ERR trap: line $LINENO: $BASH_COMMAND (exit $?)" >&2' ERR
step() {
false
}
step
echo "not reached"
$ ./errtrace.sh; echo "exit=$?"
exit=1
$ ./errtrace-E.sh; echo "exit=$?"
ERR trap: line 5: false (exit 1)
exit=1
İlk script sessizce 1 ile bitti; ikincisi tek farkla, set -Eeu ile hatanın satırını ve komutunu yazdı. $LINENO ve $BASH_COMMAND trap çalışırken başarısız olan komutu gösterir; trap string'ini tek tırnakla yazmak bu yüzden şart, çift tırnakla yazılırsa trap tanımlandığı andaki değerleri alır. Kütüphaneye bu bilgiyi call stack'le birlikte log'layan bir handler ekledik:
# ERR trap handler'ı: başarısız komutu, exit code'unu ve call stack'i log'lar.
# Kullanım: trap 'on_error "$?" "$LINENO" "$BASH_COMMAND"' ERR (set -E ile)
on_error() {
local status=$1 line=$2 command=$3 i
log "ERROR: '$command' exited with $status"
# FUNCNAME[0] on_error'ın kendisi; son eleman script'in en üst seviyesi.
for (( i = 1; i < ${#FUNCNAME[@]} - 1; i++ )); do
log " at ${FUNCNAME[i]} (${BASH_SOURCE[i]##*/}:$line)"
line=${BASH_LINENO[i]}
done
}
FUNCNAME, BASH_SOURCE ve BASH_LINENO aynı indekslerle okunan üç array: o an çalışan function'ların adları, tanımlandıkları dosyalar ve her birinin çağrıldığı satır. Deploy script'inin main'i trap'leri en başta kuruyor. Artifact'ı yarıda kesilmiş (bozuk) bir sürümü deploy etmeyi deneyelim:
$ PATH="$HOME/lab-stubs:$PATH" ./scripts/bookstore-deploy.sh -e staging -v 1.4.5; echo "exit=$?"
2026-11-15T04:22:52Z deploying 1.4.5 to staging
gzip: stdin: unexpected end of file
tar: Unexpected EOF in archive
tar: Unexpected EOF in archive
tar: Error is not recoverable: exiting now
2026-11-15T04:22:52Z ERROR: '"$@"' exited with 2
2026-11-15T04:22:52Z at run (common.sh:40)
2026-11-15T04:22:52Z at deploy (bookstore-deploy.sh:159)
2026-11-15T04:22:52Z at main (bookstore-deploy.sh:190)
2026-11-15T04:22:52Z removing unfinished release folder /opt/bookstore/releases/.incoming-1.4.5.s9M4M0
exit=2
$BASH_COMMAND komutun kaynak koddaki metnini verir; komut run'ın içindeki "$@" olduğu için mesajda o görünüyor. Hangi run çağrısı olduğunu stack söylüyor: deploy script'inin 159. satırı, tar. Exit code da tar'ınki. Son satırdaki temizlik EXIT trap'inden geliyor. Lab container'ında systemd olmadığı için sudo ve systemctl'i yine iki küçük stub karşılıyor, health endpoint'i de Bookstore.Api ile aynı cevabı veren küçük bir test servisi.
EXIT Trap'i ile Cleanup
EXIT trap'i script hangi yoldan biterse bitsin çalışır: son satıra gelince, exit ile, set -e yüzünden ya da bir signal trap'inin çağırdığı exit ile. Geçici dosya ve klasörleri silmek için doğru yer:
#!/usr/bin/env bash
tmp=$(mktemp -d)
cleanup() {
rm -rf -- "$tmp"
[[ -n ${KEEP_LOG:-} ]] && echo "keeping log"
}
trap cleanup EXIT
echo "working in $tmp"
exit 3
$ ./exit-trap.sh; echo "exit=$?"
working in /tmp/tmp.KQI4EG0qA1
exit=3
Trap'in son komutu ([[ ... ]] && echo) 1 döndüğü hâlde script 3 ile bitti; bash, trap exit'i kendisi çağırmadıkça script'in exit code'unu korur. Trap'in içinde exit code'a ihtiyacın varsa ilk satırda yakala: local status=$?.
Signal'ler için ayrı trap gerekir. INT (Ctrl-C) ve TERM (kill, systemd'nin durdurması) için trap'te exit çağırınca EXIT trap'i de çalışır; 130 ve 143, 128 + signal numarası geleneğine uyuyor:
main() {
trap cleanup EXIT
trap 'exit 130' INT
trap 'exit 143' TERM
trap 'on_error "$?" "$LINENO" "$BASH_COMMAND"' ERR
...
Deploy'un kendisi de yarım iş bırakmayacak şekilde değişti. Önceden artifact doğrudan releases/1.4.6'ya açılıyordu; yarıda kalan bir deploy, içi yarım dolu ama adı doğru bir release klasörü bırakırdı. Şimdi önce gizli bir klasöre açılıyor ve klasör ancak tamamlanınca adını alıyor:
# ShellCheck 0.11, main'den sonra "; exit" varken trap'ten yapılan çağrıyı görmüyor.
# shellcheck disable=SC2329
cleanup() {
if [[ -n $INCOMING && -d $INCOMING ]]; then
log "removing unfinished release folder $INCOMING"
rm -rf -- "$INCOMING"
fi
}
# Önce gizli bir klasöre aç; releases/VERSION ancak tamamlanınca ortaya çıkar.
if (( DRY_RUN )); then
INCOMING="$ROOT/releases/.incoming-$VERSION.XXXXXX"
else
INCOMING=$(mktemp -d "$ROOT/releases/.incoming-$VERSION.XXXXXX")
fi
run tar -xzf "$artifact" -C "$INCOMING"
if (( DRY_RUN )); then
printf '[dry-run] write %s\n' "$INCOMING/RELEASE"
else
release_info > "$INCOMING/RELEASE"
fi
run mv -T "$INCOMING" "$release_dir"
INCOMING=""
Adı noktayla başladığı için releases/*/ glob'u bu klasörü görmüyor; prune ve report script'leri ona dokunmuyor. ShellCheck 0.11.0'ın main "$@"; exit kalıbında yalnız trap'ten çağrılan function'ı kullanılmıyor sanması (SC2329, hiç çağrılmayan function uyarısı) lab'da karşılaştığım bir yanlış alarm; ; exit kaldırılınca uyarı gidiyor, biz kalıbı koruyup tek satırlık bir directive ile susturuyoruz.
Ctrl-C'yi denemek için, deploy'u kendi process group'unda başlatıp yarım saniye sonra bütün gruba TERM gönderen küçük bir script yazdım; terminalde Ctrl-C de INT'i ön plandaki bütün process'lere gönderir:
#!/usr/bin/env bash
# Deploy'u kendi process group'unda başlatır ve yarım saniye sonra bütün gruba TERM
# gönderir; terminalde Ctrl-C'nin (INT) her process'e ulaşması gibi.
setsid ./scripts/bookstore-deploy.sh "$@" &
pid=$!
sleep 0.5
kill -TERM -- -"$pid"
wait "$pid"
echo "deploy exit=$?"
1.4.6'nın artifact'ı 400 MB; açılması yaklaşık iki saniye sürüyor, sinyal tam ortasına denk geliyor. İlk deneme bir hata buldu:
$ PATH="$HOME/lab-stubs:$PATH" ./interrupt-deploy.sh -e staging -v 1.4.6
2026-11-15T04:22:55Z deploying 1.4.6 to staging
deploy exit=141
$ ls -A /opt/bookstore/releases
.incoming-1.4.6.pRF7Eh
1.4.0
1.4.1
1.4.2
1.4.3
1.4.4
Beklenen exit code 143'tü, gelen 141, yani SIGPIPE; gizli klasör de silinmemiş. TERM bütün process group'a gitti ve önceki yazıda start_log'un başlattığı tee de öldü. Ardından cleanup'taki log, okuyanı kalmamış bir pipe'a yazmaya çalıştı ve script, klasörü silemeden SIGPIPE ile öldü. Düzeltme, log'u taşıyan tee'nin INT ve TERM'i yok saymasını sağlamak; yok sayılan bir signal exec'ten sonra da yok sayılmaya devam eder:
# tee INT ve TERM'i yok sayar: bütün process group'a giden bir Ctrl-C, script'in
# trap'leri hâlâ log'a yazarken log'u durdurmamalı.
exec 2> >(trap '' INT TERM; exec tee -a "$file" >&2)
$ PATH="$HOME/lab-stubs:$PATH" ./interrupt-deploy.sh -e staging -v 1.4.6
2026-11-15T04:22:56Z deploying 1.4.6 to staging
2026-11-15T04:22:56Z removing leftover /opt/bookstore/releases/.incoming-1.4.6.pRF7Eh
Terminated
2026-11-15T04:22:57Z removing unfinished release folder /opt/bookstore/releases/.incoming-1.4.6.0ziJko
deploy exit=143
$ ls -A /opt/bookstore/releases
1.4.0
1.4.1
1.4.2
1.4.3
1.4.4
Terminated, TERM ile ölen tar için bash'in yazdığı satır. Bu sefer exit code 143, yarım klasör silindi ve current'a hiç dokunulmadı. İkinci satırdaki "leftover" temizliğine aşağıda geleceğiz. Bir ayrıntı daha: TERM'i yalnız bash'in PID'sine (process kimlik numarası) gönderseydin, bash'in manual'ına göre trap ön plandaki komut (burada tar) bitene kadar bekler; cleanup gecikir ama yine çalışır.
Retry ve timeout
Service restart'tan hemen sonra health endpoint'i birkaç saniye 503 dönebilir. Tek bir başarısız health check'te deploy'u başarısız saymak yerine, bekleme süresini her seferinde ikiye katlayarak birkaç kez denemek daha doğru:
# Komut başarılı olana kadar en fazla ATTEMPTS kez çalıştırır; her hatadan sonra bekleme ikiye katlanır.
# Kullanım: retry ATTEMPTS DELAY_SECONDS COMMAND [ARGS...]; son exit code'u döner.
retry() {
local attempts=$1 delay=$2 attempt=1 status
shift 2
while true; do
"$@" && return 0
status=$?
if (( attempt >= attempts )); then
log "giving up after $attempt attempts (exit $status): $*"
return "$status"
fi
log "attempt $attempt failed (exit $status), retrying in ${delay}s: $*"
sleep "$delay"
attempt=$((attempt + 1))
delay=$((delay * 2))
done
}
"$@" && return 0 satırı bilerek bir && zinciri: komutun hatası set -e'yi tetiklemiyor ve hemen ardından $? ile okunabiliyor. Deploy, health check'i artık run retry 5 1 "$SCRIPT_DIR/bookstore-health.sh" local ile çağırıyor. Test servisinin iki buçuk saniye 503 dönmesini sağlayıp deploy edelim:
$ touch /tmp/bookstore-unhealthy; setsid -f sh -c 'sleep 2.5; rm -f /tmp/bookstore-unhealthy'
$ PATH="$HOME/lab-stubs:$PATH" ./scripts/bookstore-deploy.sh -e staging -v 1.4.4; echo "exit=$?"
2026-11-15T04:22:52Z deploying 1.4.4 to staging
(lab stub) systemctl restart bookstore-api
curl: (22) The requested URL returned error: 503
FAIL http://127.0.0.1:5000/health
2026-11-15T04:22:52Z attempt 1 failed (exit 1), retrying in 1s: /home/user/bookstore-ops/scripts/bookstore-health.sh local
curl: (22) The requested URL returned error: 503
FAIL http://127.0.0.1:5000/health
2026-11-15T04:22:53Z attempt 2 failed (exit 1), retrying in 2s: /home/user/bookstore-ops/scripts/bookstore-health.sh local
OK http://127.0.0.1:5000/health
2026-11-15T04:22:55Z deployed 1.4.4
exit=0
Retry yalnız geçici hatalar için anlamlı: ağ, servis başlangıcı, kısa süreli kilit. Yanlış bir argüman ya da eksik bir dosya beş denemede de aynı sonucu verir ve deploy'u yalnız uzatır. Beş deneme ve bir saniyelik başlangıçla en kötü durumda 1 + 2 + 4 + 8 = 15 saniye beklenir; bu üst sınırı bilerek seç.
Retry'ın tamamlayıcısı timeout: komutu belirli bir sürede bitmezse durdurur ve 124 döner. Her denemeye bir üst sınır koymak için ikisini birleştirebilirsin: retry 5 1 timeout 10 komut.
$ timeout 2 sleep 5; echo "exit=$?"
exit=124
flock ile Aynı Anda Tek Deploy
İki kişi aynı anda deploy başlatırsa ya da bir cron job'u bir öncekini bitmeden tekrar çalışırsa, iki script aynı klasörlere ve aynı symlink'e yazar. flock (util-linux paketinden), bir dosya üzerinde kernel'in tuttuğu advisory bir kilit alır (yalnız kilide bakan process'leri durdurur); kilit, file descriptor kapanınca, yani script hangi yoldan biterse bitsin, kendiliğinden bırakılır:
# Script bitene kadar tutulan exclusive bir kilit alır.
# Kilidi başka bir process tutuyorsa hemen başarısız olur. Kullanım: acquire_lock FILE
acquire_lock() {
exec 9> "$1"
flock -n 9 || die "another run holds the lock $1"
}
exec 9> dosyayı 9 numaralı file descriptor ile açık tutuyor, flock -n 9 kilidi beklemeden almaya çalışıyor. Deploy script'i kilidi log'u açtıktan hemen sonra, dry run dışında alıyor. İlk deploy arka planda sürerken ikincisini başlatalım:
$ PATH="$HOME/lab-stubs:$PATH" setsid -f ./scripts/bookstore-deploy.sh -e staging -v 1.4.6 > /tmp/first-deploy.log 2>&1; sleep 0.5
$ PATH="$HOME/lab-stubs:$PATH" ./scripts/bookstore-deploy.sh -e staging -v 1.4.6; echo "exit=$?"
2026-11-15T04:22:57Z ERROR: another run holds the lock /opt/bookstore/.deploy.lock
exit=1
$ sleep 4; cat /tmp/first-deploy.log
2026-11-15T04:22:57Z deploying 1.4.6 to staging
(lab stub) systemctl restart bookstore-api
OK http://127.0.0.1:5000/health
2026-11-15T04:23:00Z deployed 1.4.6
Kilit dosyasının içeriği önemli değil, silinmesi de gerekmiyor; bir "PID dosyası yaz, varsa çık" kalıbına göre üstünlüğü bu. O kalıpta script kill -9 ile ölürse dosya kalır ve bir sonraki çalışma sonsuza kadar reddedilir. Cron'da çalışan yedekler için aynı kilidi komut satırından da kullanabilirsin: flock -n /run/lock/bookstore-backup.lock ./backup.sh. Beklemesi gereken bir iş için -n yerine -w 60 en fazla 60 saniye bekler.
Idempotent Tasarım: İki Kez Çalıştırmak Zarar Vermemeli
Idempotent bir script, aynı argümanlarla ikinci kez çalıştırıldığında ya aynı sonuca ulaşır ya da yapacak bir şey olmadığını söyler. Deploy için bunun anlamı: aynı sürümü tekrar deploy etmek hata değil.
# Aynı deploy'u iki kez çalıştırmak hata değil: ikinci çalışmanın yapacağı bir şey yok.
if [[ $current == "$VERSION" ]]; then
log "release $VERSION is already current, nothing to do"
return 0
fi
$ PATH="$HOME/lab-stubs:$PATH" ./scripts/bookstore-deploy.sh -e staging -v 1.4.4; echo "exit=$?"
2026-11-15T04:22:55Z release 1.4.4 is already current, nothing to do
exit=0
Bu, CI'da yeniden çalıştırılan bir pipeline'ın deploy adımını güvenli yapıyor. Aynı fikir küçük adımlarda da geçerli: mkdir -p klasör varsa hata vermez, ln -sfn symlink'i her seferinde aynı yere çevirir, rm -f olmayan dosyada sessizdir. Trap'lerin hiç çalışamadığı tek durum SIGKILL: kill -9 ya da bellek tükenince kernel'in process öldürmesi (OOM killer); bu yüzden deploy, her başlangıçta önceki çalışmalardan kalmış .incoming-* klasörlerini de temizliyor. Yukarıdaki TERM denemesindeki "removing leftover" satırı bu döngüden:
# SIGKILL ile öldürülmüş, hiçbir trap'in çalışamadığı bir deploy'dan kalanlar.
local stale
for stale in "$ROOT"/releases/.incoming-*; do
[[ -d $stale ]] || continue
log "removing leftover $stale"
run rm -rf -- "$stale"
done
Kilit burada da önemli: bu döngü, başka bir deploy'un o an kullandığı .incoming klasörünü silebilirdi; flock aynı anda yalnız bir deploy çalıştığını garanti ettiği için güvenli.
Üretimde Dikkat
Health check başarısız olduğunda deploy şu an die ile bitiyor, ama current symlink'i yeni release'i göstermeye devam ediyor. Script hata verdi, sunucu ise sağlıksız bir sürümle kaldı. Bunun çözümü önceki release'e otomatik geri dönmek; yedinci yazının konusu.
Trap'ler bir defa kurulur ve sonradan kurulan aynı signal'in trap'i öncekini ezer. Kütüphanedeki bir function kendi EXIT trap'ini kurarsa script'in cleanup'ı sessizce kaybolur. Trap'leri yalnız script'in main'inde kur, kütüphane function'larında kurma. Aynı şekilde kütüphane set -e ya da shopt ayarlarını değiştirmemeli; bunlar çağıran script'in kararı.
Exit code'lar arayüzün parçası. Deploy şu an 0 (başarılı), 1 (deploy başarısız), 2 (yanlış kullanım), 130/143 (kesildi) ve set -e'nin durdurduğu komutun kodunu (yukarıdaki tar örneğinde 2) dönebiliyor. Son durum, yanlış kullanım ile bozuk artifact'ı aynı kodla raporlayabiliyor; CI'da ikisini ayırman gerekiyorsa ERR trap'inde exit 1 ile kodu sabitle.
Lab'da /opt/bookstore/.deploy.lock'u kullandık. Gerçek sunucuda kilit dosyasını herkesin yazabildiği bir yere (/tmp) koyma; başka bir kullanıcı aynı adla bir dosya açıp kilidi elinde tutabilir. /run/lock altında, yalnız deploy kullanıcısının yazabildiği bir klasör kullan.
Sık Düşülen Tuzaklar
Hatayı || true ile susturmak. Bir satır set -e yüzünden durduğunda en kolay çıkış satırın sonuna || true eklemek; ama bu, o komutun hiçbir zaman başarısız olamayacağını söylemek demek:
#!/usr/bin/env bash
set -euo pipefail
rm /opt/bookstore/releases/1.3.0/cache.db 2>/dev/null || true
cp /var/tmp/bookstore/missing.tar.gz /opt/bookstore/releases/ || true
echo "deploy finished"
$ ./or-true.sh; echo "exit=$?"
cp: cannot stat '/var/tmp/bookstore/missing.tar.gz': No such file or directory
deploy finished
exit=0
İlk satır kabul edilebilir: olmayan bir cache dosyası gerçekten önemli değil (yine de rm -f daha açık). İkincisi deploy'un asıl adımı ve hatası kayboldu. || true yazdığın her yerde "bu komutun başarısız olması neden sorun değil?" sorusunun cevabını bir yorumla bırak.
Trap'te exit code'u geç okumak. $? trap'e girerken script'in exit code'unu tutar, ama ilk komuttan sonra değişir:
#!/usr/bin/env bash
cleanup() {
echo "cleaning up"
exit $?
}
trap cleanup EXIT
false
$ ./trap-late-status.sh; echo "exit=$?"
cleaning up
exit=0
$ ./trap-exit-code.sh; echo "exit=$?"
cleanup sees status 1
exit=1
Başarısız script 0 ile bitti ve CI onu başarılı saydı. İkinci script local status=$?'yı cleanup'ın ilk satırında okuyup sonunda exit "$status" diyor. En güvenlisi, cleanup'ta exit hiç çağırmamak; yukarıda gördüğümüz gibi bash exit code'u kendisi korur.
INT trap'inde exit'i unutmak. Trap signal'in varsayılan davranışının yerini alır; trap'te exit yoksa Ctrl-C script'i durdurmaz:
$ ./trap-int-no-exit.sh; echo "exit=$?"
cleaning up
still running after INT
exit=0
$ ./trap-int-exit.sh; echo "exit=$?"
cleaning up
exit=130
İlk script INT'i yakaladı, "cleaning up" yazdı ve devam etti. Cleanup'ı EXIT trap'ine koy, signal trap'lerinde yalnız exit ile uygun kodu ver.
(( count++ )) ile sayaç. Yukarıda gördüğümüz gibi sayaç 0'dan başlıyorsa ilk artırma set -e ile script'i bitirir. Aynı şey (( errors )) gibi bir koşulu if dışında tek başına yazınca da olur; aritmetiği $(( )) ile ata, (( ))'i yalnız if ve while'da kullan.
Küçük Bir Deneme
★☆☆ bookstore-prune-releases.sh'yi set -Eeuo pipefail ile çalıştırırken KEEP, release sayısına eşitse ya da kök klasör yoksa ne oluyor? Her durumda bir mesaj ve anlamlı bir exit code aldığından emin ol.
★★☆ retry'a bir üst süre ekle: RETRY_MAX_DELAY (varsayılan 8) bekleme süresinin bu değeri geçmesini engellesin. Health check'i 503 dönerken altı denemenin toplam süresini time ile ölç ve hesapla karşılaştır.
★★★ Deploy'un health check'ten sonraki başarısızlığını ele al: health check başarısız olursa current'ı deploy öncesindeki release'e geri çevir, service'i yeniden başlat ve 1 ile çık. Geri dönüş sırasında da bir hata olursa ne yapmalı? Script'in bunu log'a nasıl yazacağını düşün.
Üçüncü alıştırma, bir sonraki yazının başlangıç noktası. Yedinci yazıda serinin parçalarını gerçek bir script'te birleştiriyoruz: artifact'ı indirip checksum'ını doğrulayan, migration bundle'ı çalıştıran, current'ı atomik olarak değiştiren ve health check başarısızsa önceki release'e dönen bir deploy; yanına da SQL Server için zamanlanmış, rotasyonlu bir veritabanı backup script'i.