Fehlerbehandlung: exit codes, trap

Fehlerbehandlung: Exit-Codes, set, trap

Selbst das perfekt geschriebene Bash-Skript hat irgendwann mit Fehlern zu tun: eine Datei fehlt, ein Server ist nicht erreichbar, die Festplatte ist voll. Anders als Python oder Java hat Bash keine Exceptions im klassischen Sinne. Stattdessen arbeitet alles über Exit-Codes: jeder Befehl liefert nach seiner Ausführung eine Zahl zurück. 0 bedeutet „alles gut", alles andere ist ein Fehler.

Was nach Steinzeit klingt, hat sich seit Jahrzehnten bewährt: dieses einfache System lässt sich beliebig kombinieren und ermöglicht robuste Skripte. Dazu kommen set-Optionen die Bash strenger machen, und trap für Cleanup-Aktionen vor dem Beenden. Mit diesen drei Werkzeugen werden deine Skripte produktionsreif.

1) Exit-Codes – die Sprache des Erfolgs

Jeder ausgeführte Befehl in Bash hinterlässt einen Zahlenwert: den Exit-Code. Über die Spezialvariable $? kannst du ihn lesen. Aber Vorsicht: $? gilt nur direkt nach dem Befehl – ein einziger weiterer Befehl überschreibt ihn.

Häufige Exit-Codes in der Praxis

ls /existiert

Erfolg – alles gut

ls /existiert-nicht

Falsche Verwendung / Datei fehlt

grep "x" leere-datei.txt

grep: Pattern nicht gefunden

cat /etc/shadow (als user)

Permission denied

befehl-gibts-nicht

127

command not found

datei.txt (keine Ausführrechte)

126

nicht ausführbar

[Strg+C beim laufenden Befehl]

130

SIGINT (vom Benutzer abgebrochen)

exit 42 (eigene)

Custom-Exit-Code des Skripts

Exit-Codes sind 0-255. Werte über 255 wrappen modulo 256. Konvention: 0 = Erfolg, 1-125 = Fehler des Skripts, 126/127 = Shell-Probleme, 128+N = Killed by Signal N. Wenn du eigene Skripte schreibst, halte dich an Werte 1-125 und dokumentiere ihre Bedeutung (z.B. 1=allgemein, 2=ungültige Args, 3=Datei fehlt).

2) Exit-Codes in Bedingungen

Was die Bedingung if BEFEHL in L4 macht: sie prüft den Exit-Code. 0 = wahr, alles andere = falsch. Genau umgekehrt zu Python wo 0 falsy ist! In Unix bedeutet 0 Erfolg:

# Prüfung ohne $? if grep -q "ERROR" log.txt; then echo "Fehler gefunden!" fi # Mit Exit-Code-Variable curl -s api.example.com if [[ $? -eq 0 ]]; then echo "API erreichbar" else echo "API-Fehler (Code: $?)" # ⚠ FALSCH! $? ist hier vom echo, nicht von curl! fi # RICHTIG: Code in eigene Variable speichern curl -s api.example.com ec=$? if [[ $ec -ne 0 ]]; then echo "Fehler: $ec" fi

3) exit und eigene Codes

Mit exit N beendest du dein Skript und gibst Code N zurück. Sehr wichtig in Skripten die von anderen Tools (z.B. CI/CD) aufgerufen werden – die schauen genau auf den Exit-Code um zu erkennen ob alles geklappt hat:

#!/bin/bash # backup.sh: erstellt ein Backup if [[ $# -lt 2 ]]; then echo "Aufruf: $0 <quelle> <ziel>" >&2 exit 2 # Falsche Argumente fi if [[ ! -d "$1" ]]; then echo "Quelle existiert nicht" >&2 exit 3 # Quelle fehlt fi tar -czf "$2/backup.tar.gz" "$1" || exit 4 echo "Backup erfolgreich" exit 0

Dokumentations-Tipp: schreibe in einen Kommentar oben im Skript was welcher Exit-Code bedeutet. Andere (und dein zukünftiges Ich) werden es dir danken. Beispiel: # EXIT CODES: 0=ok, 2=args, 3=quelle fehlt, 4=tar-fehler.

4) Die set-Optionen: Bash strenger machen

Standardmäßig ist Bash sehr tolerant: ein fehlgeschlagener Befehl wird ignoriert, das Skript läuft einfach weiter. Das ist in der Praxis oft gefährlich – stell dir vor das Backup-Verzeichnis kann nicht erstellt werden, aber die Daten werden trotzdem hineinkopiert (also ins Nichts). Mit set machst du Bash strenger:

Die wichtigsten set-Optionen

set -e--errexit

Skript bricht sofort ab wenn ein Befehl Exit-Code ≠ 0 hat. Das wichtigste set-Flag überhaupt.

set -u--nounset

Verwendung nicht-gesetzter Variablen wirft Fehler statt leer zu sein. Findet Tippfehler.

set -x--xtrace

Zeigt jeden ausgeführten Befehl an. Debug-Modus. Ein- und ausschaltbar mit set +x.

set -o pipefail

Pipe-Exit-Code = letzter fehlgeschlagener Befehl, nicht letzter Befehl. Wichtig in Kombination mit -e.

Die goldene Kombination für jedes ernsthafte Skript ganz oben: set -euo pipefail. Macht Bash so strikt wie eine „echte" Programmiersprache. Mit set +e kannst du temporär entschärfen wenn du einen Fehler erwartest und behandeln willst.

5) set -e in der Praxis

Vergleich was passiert mit und ohne strikten Modus:

#!/bin/bash # OHNE set -e: Gefährlich! cd /backup/wichtig # Verzeichnis existiert nicht → Fehler ignoriert rm -rf * # Aber DAS hier wird trotzdem ausgeführt! # Im Home-Verzeichnis (weil cd fehlschlug) # → BACKUP ALLER DATEIEN WEG

#!/bin/bash set -euo pipefail # Schutz aktiv cd /backup/wichtig # Skript bricht hier ab! rm -rf * # Wird nicht mehr erreicht – safe

Das ist ein dramatisches aber nicht erfundenes Beispiel – „shell script vernichtete halbe Server-Festplatte" ist eine bekannte Folklore-Geschichte. set -euo pipefail ist eine billige Versicherung.

6) Wann set -e nicht ausreicht: explizite Prüfung

set -e ist nicht magisch – es greift nicht in allen Fällen. Probleme:

In Pipes: nur der letzte Befehl der Pipe wird geprüft. Lösung: set -o pipefail dazu.
In Bedingungen: if befehl; – hier wird der Fehler erwartet, nicht abgebrochen.
Mit ||: befehl || alternative – auch hier wird der Fehler „eingefangen".
Subshells: (...) haben eigenes Verhalten.

Für kritische Stellen lieber explizit prüfen:

cp wichtig.txt /backup/ || { echo "Backup fehlgeschlagen!" >&2 exit 1 } # Oder mit Funktion (siehe L5): err_exit() { echo "FEHLER: $1" >&2 exit "${2:-1}" } cp wichtig.txt /backup/ || err_exit "cp fehlgeschlagen" 5

7) trap: Cleanup vor dem Beenden

Was wenn dein Skript eine temporäre Datei anlegt – und mitten in der Ausführung mit Strg+C abgebrochen wird? Die temp-Datei bleibt liegen. Hier kommt trap ins Spiel: damit registrierst du einen „Aufräum-Befehl" der bei bestimmten Ereignissen ausgeführt wird.

trap-Lifecycle: was passiert wann?

▶

Skript startet

→

🪤

trap registriert

→

⚙

Skript läuft

→

⚠

Ereignis tritt ein

→

🧹

Cleanup läuft

← Klick eine Stage.

Syntax: trap 'BEFEHL' SIGNAL. Mehrere Signale: trap 'cleanup' INT TERM EXIT. EXIT ist ein „Pseudo-Signal" das immer beim normalen Beenden ausgelöst wird – darum ist es das meistgenutzte trap-Ziel. INT ist Strg+C. TERM ist kill PID. Trap entfernen mit trap - SIGNAL.

8) Klassisches trap-Pattern: Temp-Datei aufräumen

Das wahrscheinlich häufigste trap-Pattern in echten Skripten:

#!/bin/bash set -euo pipefail # Temp-Verzeichnis mit eindeutigem Namen anlegen TEMPDIR=$(mktemp -d) # Cleanup-Funktion definieren cleanup() { rm -rf "$TEMPDIR" echo "Aufräumen erledigt" } # Bei JEDEM Beenden cleanup aufrufen trap cleanup EXIT # Eigentliche Arbeit – temp-Dateien anlegen, was auch immer echo "Daten" > "$TEMPDIR/work.tmp" # ... viel Arbeit ... # Skript endet → cleanup() läuft AUTOMATISCH # Auch wenn User Strg+C drückt: cleanup läuft trotzdem!

Das ist „defensive Programmierung" in Bash. mktemp -d erstellt ein eindeutig benanntes Temp-Verzeichnis (wichtig: zwei parallel laufende Skripte stören sich nicht). Egal wie das Skript endet – cleanup wird ausgeführt. Vergleichbar mit finally in Python try/finally oder mit defer in Go.

9) Die wichtigsten Unix-Signale

Signale sind kurze „Nachrichten" die ein Prozess vom System bekommen kann. Über trap reagiert dein Skript darauf:

Wichtige Signale für Bash-Skripte

SIGINT2

Strg+C im Terminal. Abfangbar.

SIGTERM15

Normales kill PID. Höflich, abfangbar.

SIGHUP1

Terminal geschlossen. Auch zum Reload genutzt.

SIGUSR1/210/12

Frei für eigene Zwecke (z.B. Reload-Trigger).

EXIT0

Pseudo: bei normalem Skript-Ende.

ERR

Pseudo: bei Fehler (nur mit set -E).

SIGKILL9

NICHT abfangbar! kill -9 stirbt sofort.

SIGSTOP19

Prozess pausieren. NICHT abfangbar.

Liste aller Signale mit kill -l. Wenn ein Server-Admin „kill -9" gegen dein Skript wirft, hast du keine Chance mehr aufzuräumen – darum sind Locks und Markierungs-Dateien auf der Festplatte zusätzlich sinnvoll. Mehr zu Prozessen und Signalen in K29 Linux-Server-Admin.

10) Debug-Modus mit set -x

Wenn dein Skript sich falsch verhält und du nicht weißt warum: set -x aktiviert einen Debug-Modus der jeden Befehl vor der Ausführung zeigt:

#!/bin/bash set -x # Debug AN name="Anna" echo "Hallo $name" ls *.txt | wc -l set +x # Debug AUS

Ausgabe sieht etwa so aus:

+ name=Anna + echo 'Hallo Anna' Hallo Anna + ls foo.txt bar.txt + wc -l 2

Jede Zeile mit + ist ein „Bash zeigt was es gerade tut". Sehr nützlich um zu sehen wie Variablen tatsächlich expandiert werden – oft anders als gedacht! Alternativ ohne ganzes Skript modifizieren: bash -x mein-skript.sh beim Aufruf.

11) ShellCheck – der Bash-Linter

Bevor du ein Bash-Skript live schaltest: jag es durch ShellCheck. Das ist ein statischer Analyzer der typische Fehler erkennt:

Fehlende Quotes um Variablen
Verwechslung von = und == in [ ]
Nicht-gesetzte Variablen verwendet
Veraltete Konstrukte (z.B. Backticks statt $())
Logikfehler in if-Bedingungen

Installation: apt install shellcheck (Linux) oder brew install shellcheck (Mac). Aufruf: shellcheck mein-skript.sh. Oder direkt im Browser unter shellcheck.net. Die meisten Editoren (VS Code) haben Plugins die ShellCheck im Hintergrund laufen lassen und Probleme markieren während du tippst. Jedes ernsthafte Bash-Projekt sollte ShellCheck verwenden – findet Bugs bevor sie in Produktion gehen.

12) Defensives Skript-Template

Eine Vorlage die du für jedes neue Bash-Skript verwenden kannst:

#!/usr/bin/env bash # # mein-skript.sh – Beschreibung was es macht # Author: Anna, Stand: 2026-05-17 # # Exit-Codes: # 0 = Erfolg # 1 = Allgemeiner Fehler # 2 = Ungültige Argumente set -euo pipefail # Globale Variablen SKRIPT_NAME=$(basename "$0") TEMPDIR=$(mktemp -d) # Aufräumen registrieren cleanup() { rm -rf "$TEMPDIR" } trap cleanup EXIT # Fehler-Helfer err() { echo "$SKRIPT_NAME: $1" >&2 exit "${2:-1}" } # Argumente prüfen [[ $# -ge 1 ]] || err "Usage: $SKRIPT_NAME <datei>" 2 datei="$1" [[ -f "$datei" ]] || err "Datei '$datei' nicht gefunden" 3 # Hauptlogik echo "Verarbeite $datei..." # ... eigentliche Arbeit ... echo "Fertig!" exit 0

Zusammenfassung

Exit-Code = Zahl nach jedem Befehl. 0 = Erfolg, alles andere = Fehler. Über $? abrufen (direkt danach!). Eigene Codes mit exit N. set -e bricht bei jedem Fehler ab. set -u wirft Fehler bei nicht-gesetzten Variablen. set -o pipefail macht Pipes streng. Goldene Kombination: set -euo pipefail. set -x für Debug-Modus. trap 'cleanup' EXIT registriert Aufräum-Handler – läuft bei normalem Ende UND Abbruch. Wichtige Signale: SIGINT (Strg+C), SIGTERM (kill), SIGKILL (kill -9, nicht abfangbar). Defensive Skripte: set -euo pipefail + trap cleanup EXIT + frühe Argument-Validierung + shellcheck drüber laufen lassen.