Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Wettkampf – Desaster-Drills

Ziel: Acht Störungen finden und beheben, wie sie mit Shell-Skripten im Betrieb vorkommen, jede mit Zeitlimit. · Dauer: ca. 120 min · Voraussetzung: Tag 14

Briefing

  • Jede Runde hat eine Spielleitung: einen Block, der den Fehler einbaut. Lies ihn erst nach der Runde, sonst ist es keine Übung. Am besten tippt ihn jemand anderes.
  • Lage beschreibt, was gemeldet wird, Zeitlimit die Zeit bis zur Lösung.
  • Werkzeuge: Exit-Codes, bash -x, type -a, git diff im Werkzeugkasten, cat -A, file, fuser, systemctl --user status, journalctl --user.
 Symptom ──► Was sagt der Exit-Code? Was steht auf stderr?
         ──► Welcher Befehl läuft wirklich? (type -a, bash -x)
         ──► Was hat sich geändert? (git diff, diff gegen ~/sh-lab/code)

Tagesstart – der Werkzeugkasten kommt vollständig ins Git, damit jede Änderung sichtbar wird:

source ~/sh-lab/setup/env.sh
mkdir -p ~/sh-lab/tag15 && cd ~/sh-lab/werkzeug
git add -A && git commit -qm "Stand vor dem Wettkampf" && git status --short | wc -l
notes-check -q && echo "notes ok"

Erwartet:

0
notes ok

Runde 1: Das Backup startet nicht

Spielleitung:

sed -i 's/$/\r/' ~/sh-lab/werkzeug/bin/notes-backup

Lage: „Jemand hat notes-backup auf seinem Laptop bearbeitet. Seitdem startet es nicht mehr.” Zeitlimit: 10 min

notes-backup; echo "Exit: $?"

Erwartet:

env: $'bash\r': No such file or directory
env: use -[v]S to pass options in shebang lines
Exit: 127

Lösung

bash\r – der Shebang endet mit einem Wagenrücklauf. Die Datei hat Windows-Zeilenenden:

file ~/sh-lab/werkzeug/bin/notes-backup | grep -o 'with CRLF.*'
head -1 ~/sh-lab/werkzeug/bin/notes-backup | cat -A
sed -i 's/\r$//' ~/sh-lab/werkzeug/bin/notes-backup
git -C ~/sh-lab/werkzeug status --short | wc -l

Erwartet:

with CRLF line terminators
#!/usr/bin/env bash^M$
0

cat -A zeigt \r als ^M. Nach dem Entfernen ist die Datei wieder identisch mit dem Stand im Git. Vorbeugen: .gitattributes mit *.sh text eol=lf und ein Editor, der LF schreibt.

Fortschritt speichern? Kostenlos registrieren

Runde 2: Alles grün, nichts geht

Spielleitung:

sed -i 's/^((ergebnis\[fehler\] == 0))$/echo "Prüfung beendet"/' \
  ~/sh-lab/werkzeug/bin/notes-check
docker compose -f ~/sh-lab/notes/compose.yaml stop proxy >/dev/null 2>&1

Lage: „Das Monitoring meldet notes als gesund. Die Benutzer sagen, nichts geht.” Zeitlimit: 10 min

notes-check -q; echo "Exit: $?"
notes-ping; echo "Exit: $?"

Erwartet:

Prüfung beendet
Exit: 0
14:02:11 notes-ping: FEHLER nicht erreichbar: http://127.0.0.1:8080
Exit: 1

Lösung

notes-check -q gibt etwas aus, obwohl es schweigen sollte, und meldet Erfolg. Was hat sich geändert?

git -C ~/sh-lab/werkzeug diff --stat
git -C ~/sh-lab/werkzeug diff | grep -E '^[-+][^-+]'
git -C ~/sh-lab/werkzeug checkout -q bin/notes-check
notes-check -q; echo "Exit: $?"
docker compose -f ~/sh-lab/notes/compose.yaml start proxy >/dev/null 2>&1
notes-wait 10 >/dev/null && notes-check -q; echo "Exit: $?"

Erwartet:

 bin/notes-check | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
-((ergebnis[fehler] == 0))
+echo "Prüfung beendet"
Exit: 1
Exit: 0

Die letzte Zeile eines Skripts bestimmt seinen Exit-Code. Ein harmloses echo am Ende macht jedes Ergebnis zu „Erfolg”. Ein Test wie in Tag 11 („notes nicht erreichbar → Exit 1”) hätte das vor dem Deployment gefunden.

Fortschritt speichern? Kostenlos registrieren

Runde 3: Gelöscht, aber noch da

Spielleitung:

sed -i 's/rm -f -- "\$datei"/rm -f -- $datei/' ~/sh-lab/werkzeug/bin/notes-aufraeumen
touch -d "60 days ago" "$HOME/sh-lab/exporte/notes-alt kopie.csv"

Lage: „Das Aufräumen meldet jede Nacht ‚gelöscht’, aber eine alte Datei bleibt liegen.” Zeitlimit: 15 min

notes-aufraeumen 30 ~/sh-lab/exporte 2>&1 | sed -E 's/^[0-9:]{8}/…/'
ls ~/sh-lab/exporte | grep -c 'alt kopie'

Erwartet:

… notes-aufraeumen: INFO gelöscht: /home/ubuntu/sh-lab/exporte/notes-alt kopie.csv
1 Datei(en) älter als 30 Tage
1

Lösung

Ein Leerzeichen im Namen und eine Variable ohne Anführungszeichen: rm -f bekommt zwei Argumente, …/notes-alt und kopie.csv, die es beide nicht gibt – und -f schweigt dazu. ShellCheck hätte es gemeldet:

shellcheck -x ~/sh-lab/werkzeug/bin/notes-aufraeumen | grep -o 'SC2086.*' | head -1
git -C ~/sh-lab/werkzeug checkout -q bin/notes-aufraeumen
notes-aufraeumen 30 ~/sh-lab/exporte >/dev/null 2>&1
ls ~/sh-lab/exporte | grep -c 'alt kopie'

Erwartet:

SC2086 (info): Double quote to prevent globbing and word splitting.
0

Fortschritt speichern? Kostenlos registrieren

Runde 4: Der Timer schweigt

Spielleitung:

sed -i 's|bin/notes-check|bin/notes-chek|' ~/.config/systemd/user/notes-check.service
systemctl --user daemon-reload

Lage: „Seit dem letzten Umbau kommen keine Prüfergebnisse mehr ins Journal.” Zeitlimit: 10 min

systemctl --user start notes-check.service 2>&1 | head -1
systemctl --user show notes-check.service -p Result -p ExecMainStatus

Erwartet:

Job for notes-check.service failed because the control process exited with error code.
Result=exit-code
ExecMainStatus=203

Lösung

Exit-Status 203 ist ein Code von systemd selbst: EXEC, das Programm ließ sich nicht starten. Das Journal nennt den Grund:

journalctl --user -u notes-check -n 20 --no-pager -o cat \
  | grep -m1 -o 'Unable to locate[^:]*'
sed -i 's|bin/notes-chek|bin/notes-check|' ~/.config/systemd/user/notes-check.service
systemctl --user daemon-reload
systemctl --user start notes-check.service
systemctl --user show notes-check.service -p Result

Erwartet:

Unable to locate executable '/home/ubuntu/sh-lab/werkzeug/bin/notes-chek'
Result=success

Nach jeder Änderung an einer Unit gehört daemon-reload dazu – sonst arbeitet systemd mit der alten Fassung weiter.

Fortschritt speichern? Kostenlos registrieren

Runde 5: Das Backup, das nicht kommt

Spielleitung:

(flock ~/sh-lab/backups/.lock sleep 900 >/dev/null 2>&1 &)

Lage: „Seit Stunden kein neues Backup. Fehler gibt es keine.” Zeitlimit: 10 min

vorher=$(ls ~/sh-lab/backups | wc -l)
notes-backup 2>&1 | sed -E 's/^[0-9:]{8}/…/'; echo "Exit: ${PIPESTATUS[0]}"
echo "Backups: $vorher → $(ls ~/sh-lab/backups | wc -l)"

Erwartet:

… notes-backup: FEHLER läuft schon (/home/ubuntu/sh-lab/backups/.lock)
Exit: 0
Backups: 4 → 4

Lösung

Die Sperre ist belegt – von wem?

ps -o comm= -p "$(fuser ~/sh-lab/backups/.lock 2>/dev/null | xargs | tr ' ' ',')"
fuser -k -TERM ~/sh-lab/backups/.lock >/dev/null 2>&1; sleep 1
notes-backup 2>&1 | grep -c gesichert

Erwartet:

flock
sleep
1

Zwei Prozesse halten die Sperre: flock und das sleep, das es gestartet hat – es erbt die offene Datei. fuser nennt die PIDs aller Prozesse, die die Datei geöffnet haben, fuser -k beendet sie. Hier ist es ein sleep, im echten Leben ein pg_dump, das auf eine blockierte Tabelle wartet. Die Sperre selbst ist richtig, ihr Exit-Code 0 aber gefährlich: Ein Backup, das dauerhaft „läuft schon” meldet, fällt keinem auf. Besser wäre flock -w 600 und danach ein Fehler – oder ein Monitoring auf das Alter des neuesten Backups.

Fortschritt speichern? Kostenlos registrieren

Runde 6: Alles hängt

Spielleitung:

sed -i 's|127.0.0.1:8080"|10.255.255.1:8080"|' ~/sh-lab/setup/env.sh
source ~/sh-lab/setup/env.sh

Lage: „Nach dem Update der Umgebung brauchen alle Werkzeuge ewig und scheitern.” Zeitlimit: 10 min

TIMEFORMAT='%1Rs'
time notes-ping; echo "Exit: $?"

Erwartet:

14:20:44 notes-ping: FEHLER nicht erreichbar: http://10.255.255.1:8080
3.0s
Exit: 1

Lösung

Genau drei Sekunden: das Zeitlimit --max-time 3 aus notes-ping. Die Adresse ist nicht die von notes. Woher kommt sie?

diff ~/sh-lab/code/setup/env.sh ~/sh-lab/setup/env.sh
cp ~/sh-lab/code/setup/env.sh ~/sh-lab/setup/env.sh && source ~/sh-lab/setup/env.sh
notes-ping

Erwartet:

3c3
< export NOTES_URL="http://127.0.0.1:8080"           # notes hinter nginx
---
> export NOTES_URL="http://10.255.255.1:8080"           # notes hinter nginx
notes ok

Ohne --max-time hätte curl hier über zwei Minuten gewartet – pro Aufruf. Zeitlimits an jeder Netzwerkoperation sind der Unterschied zwischen „scheitert schnell” und „hängt”.

Fortschritt speichern? Kostenlos registrieren

Runde 7: Der Restore scheitert

Spielleitung:

neu=$(find ~/sh-lab/backups -name 'notes-*.sql.gz' | sort | tail -1)
head -c 300 "$neu" > /tmp/kaputt && cat /tmp/kaputt > "$neu"

Lage: „Der wöchentliche Restore-Test meldet: Archiv beschädigt.” Zeitlimit: 10 min

gzip -t ~/sh-lab/backups/notes-*.sql.gz; echo "Exit: $?"

Erwartet:

gzip: /home/ubuntu/sh-lab/backups/notes-20261102-142201.sql.gz: unexpected end of file
Exit: 1

Lösung

Ein Backup ist kaputt – welches noch heil ist, zeigt eine Schleife:

for b in ~/sh-lab/backups/notes-*.sql.gz; do
  if gzip -t "$b" 2>/dev/null; then z=ok; else z=KAPUTT; fi
  printf '%-6s %s\n' "$z" "${b##*/}"
done | sed -E 's/[0-9]{8}-[0-9]{6}/JJJJMMTT-HHMMSS/'
for b in ~/sh-lab/backups/notes-*.sql.gz; do
  gzip -t "$b" 2>/dev/null || rm -f -- "$b"
done
notes-backup 2>&1 | grep -c gesichert
gzip -t ~/sh-lab/backups/notes-*.sql.gz && echo "alle heil"

Erwartet (die Zahl der heilen Backups hängt von deinen Läufen ab):

ok     notes-JJJJMMTT-HHMMSS.sql.gz
ok     notes-JJJJMMTT-HHMMSS.sql.gz
ok     notes-JJJJMMTT-HHMMSS.sql.gz
KAPUTT notes-JJJJMMTT-HHMMSS.sql.gz
1
alle heil

notes-backup prüft jedes neue Archiv mit gzip -t – aber nicht, ob ein altes später beschädigt wird. Darum gehört die Prüfung aller Backups in den regelmäßigen Restore-Test.

Fortschritt speichern? Kostenlos registrieren

Runde 8: Das Monitoring lügt

Spielleitung:

notes-check() { echo "3 ok, 0 Fehler"; }
docker compose -f ~/sh-lab/notes/compose.yaml stop proxy >/dev/null 2>&1

Lage: „Im Terminal sagt notes-check ‚3 ok’, das Dashboard ist rot.” Zeitlimit: 10 min

notes-check; echo "Exit: $?"
curl -s -o /dev/null -w '%{http_code}\n' --max-time 2 "$NOTES_URL/healthz"

Erwartet:

3 ok, 0 Fehler
Exit: 0
000

Lösung

Was läuft eigentlich, wenn du notes-check tippst?

type -a notes-check | head -3
unset -f notes-check
notes-check -q; echo "Exit: $?"
docker compose -f ~/sh-lab/notes/compose.yaml start proxy >/dev/null 2>&1
notes-wait 10 >/dev/null && notes-check

Erwartet:

notes-check is a function
notes-check () 
{ 
Exit: 1
3 ok, 0 Fehler

Funktionen und Aliase gehen Programmen im PATH vor. Was in deiner Shell definiert ist – oder in einer .bashrc –, verdeckt jedes gleichnamige Skript. type -a zeigt die ganze Reihenfolge.

Fortschritt speichern? Kostenlos registrieren

Auswertung

Punkte je Runde
3 im Zeitlimit, ohne in die Lösung zu schauen
2 im Zeitlimit, mit einem Blick in den Spielleitungs-Block
1 nach dem Zeitlimit

20 Punkte und mehr: Deine Skripte sind in guten Händen.

Kontrollpunkt

git -C ~/sh-lab/werkzeug status --short | wc -l

Erwartet: Der Werkzeugkasten ist wieder genau der Stand vor dem Wettkampf.

0
~/sh-lab/werkzeug/ci.sh | tail -1

Erwartet:

ci: alles grün
notes-check -q && systemctl --user show notes-check.service -p Result

Erwartet:

Result=success

Enterprise-Notiz

  • Jede Runde ist ein Runbook: Symptom, erste Befehle, Ursache, Lösung, Vorbeugung. Wer nachts gerufen wird, braucht genau das.
  • Vorbeugen ist billiger: .gitattributes gegen CRLF, ShellCheck in der CI gegen fehlende Anführungszeichen, Tests gegen falsche Exit-Codes, Zeitlimits gegen hängende Aufrufe, Monitoring auf das Alter des letzten Backups.
  • Änderungen nachvollziehbar machen: Skripte und Units im Git, verteilt aus dem Git – dann zeigt git diff, was sich geändert hat, und git checkout macht es rückgängig.