Praxisprojekt: Systemstatus- und Backup-Script

Du hast in den vorigen neun Lektionen alle Bausteine kennengelernt: Befehle, Variablen, Kontrollstrukturen, Funktionen, Fehlerbehandlung, Textverarbeitung, find/cron und curl/ssh/rsync. Jetzt fügen wir alles zu einem echten Projekt zusammen: ein Systemstatus- und Backup-Skript, das du auf jedem Linux-Server einsetzen kannst.

Wir bauen es in mehreren Iterationen auf – das ist auch die professionelle Arbeitsweise. Erst eine simple Version die funktioniert, dann nach und nach Härtung, bessere Fehlerbehandlung, Konfiguration. Jede Iteration ist lauffähig. Am Ende hast du ein Skript das produktionstauglich ist und gleichzeitig zeigt wie ein FISI Bash-Projekte angeht.

1) Anforderungen festlegen

Bevor wir Code schreiben: was soll das Skript eigentlich können? Anforderungen klar zu formulieren ist der wichtigste Schritt in jedem Software-Projekt:

Anforderungen unseres Projekts

Systeminfos sammeln

Hostname, Uptime, Festplattenbelegung, freier RAM

Verzeichnis sichern

Komprimiertes tar.gz mit Datum im Namen

Aufbewahrung

Backups älter als N Tage automatisch löschen

Logging

Alle Aktionen in eine Logdatei mit Zeitstempel

Konfigurierbar

Quelle, Ziel, Aufbewahrung über Variablen oder Conf-Datei

Robust

Strikter Modus, Cleanup bei Abbruch, Exit-Codes

Cron-tauglich

Läuft ohne Interaktion, schreibt Output strukturiert

Statusmail (optional)

Bei Erfolg/Fehler eine kurze Mail an Admin

In echten Projekten kommen die Anforderungen vom Auftraggeber oder Team. Bei Eigenprojekten musst du dir selbst klare Ziele setzen – sonst „programmierst du planlos rein" und das Ergebnis ist nie fertig. Diese acht Punkte sind realistisch für ein FISI-Tagesgeschäft und werden in den nächsten Iterationen Stück für Stück umgesetzt.

2) Iterative Entwicklung – fünf Stufen

Wir bauen das Skript in fünf Stufen auf. Jede Stufe ist lauffähig und löst einen Teil der Anforderungen. Klick durch die Iterationen:

Stufen des Projekts

v1: Hello Backup

v2: Strikt + Args

v3: Funktionen

v4: Konfig + Cleanup

v5: Produktion

3) Iteration v1: der Prototyp

Wir fangen ganz simpel an. Das hier ist das absolute Minimum was funktioniert:

#!/bin/bash # backup-v1.sh – minimaler Prototyp QUELLE="/home/anna/projekte" ZIEL="/backup" DATUM=$(date +%Y-%m-%d) mkdir -p "$ZIEL" tar -czf "$ZIEL/backup-$DATUM.tar.gz" "$QUELLE" echo "Backup erstellt: $ZIEL/backup-$DATUM.tar.gz"

Was ist hier dabei? Drei Variablen für Quelle, Ziel, Datum. mkdir -p erstellt den Backup-Ordner falls nötig. tar -czf komprimiert die Quelle in ein Archiv. echo bestätigt den Erfolg. Lauffähig, aber: was wenn die Quelle nicht existiert? Was wenn die Platte voll ist? Antwort: das Skript würde kryptisch abstürzen. Genau das fixen wir als nächstes.

4) Iteration v2: strikter Modus und Argumente

Statt Variablen hardzucoden nehmen wir sie als Argumente. Plus die goldene Trinity aus L6:

#!/bin/bash # backup-v2.sh – mit strikter Fehlerbehandlung set -euo pipefail # Argument-Prüfung if [[ $# -lt 1 ]]; then echo "Usage: $0 <quelle> [ziel]" >&2 exit 2 fi QUELLE="$1" ZIEL="${2:-/backup}" # Default mit Parameter-Expansion DATUM=$(date +%Y-%m-%d_%H%M) # Quelle prüfen if [[ ! -d "$QUELLE" ]]; then echo "FEHLER: Quelle '$QUELLE' existiert nicht" >&2 exit 3 fi mkdir -p "$ZIEL" NAME=$(basename "$QUELLE")_$DATUM.tar.gz" echo "Sichere $QUELLE nach $ZIEL/$NAME ..." tar -czf "$ZIEL/$NAME" "$QUELLE" # Größe melden (du -h = human readable) GROESSE=$(du -h "$ZIEL/$NAME" | cut -f1) echo "Fertig. Größe: $GROESSE"

Schon viel besser. Wenn jetzt etwas schiefgeht, kriegt der User eine klare Meldung statt einem kryptischen tar-Fehler. set -euo pipefail sorgt dafür dass bei JEDEM Befehl der fehlschlägt sofort abgebrochen wird. Exit-Codes sind dokumentiert: 2 = falsche Args, 3 = Quelle fehlt.

5) Iteration v3: Funktionen und Logging

Jetzt wird's strukturiert. Wir zerlegen den Code in benannte Funktionen, fügen Logging hinzu und kümmern uns um die Aufbewahrung alter Backups:

#!/bin/bash # backup-v3.sh – mit Funktionen, Logging, Cleanup set -euo pipefail # ===== Konfiguration ===== QUELLE="${1:-/home/anna/projekte}" ZIEL="${2:-/backup}" AUFBEWAHRUNG=7 # Tage LOGFILE="/var/log/backup.log" DATUM=$(date +%Y-%m-%d_%H%M) # ===== Funktionen ===== log() { local level="$1" local msg="$2" local ts=$(date +"%Y-%m-%d %H:%M:%S") echo "[$ts] $level: $msg" | tee -a "$LOGFILE" } system_info() { log INFO "Host: $(hostname)" log INFO "Uptime: $(uptime -p)" log INFO "Disk: $(df -h "$ZIEL" | tail -1 | awk '{print $4 " frei von " $2}')" log INFO "RAM: $(free -h | awk '/^Mem:/ {print $7 " verfügbar"}')" } erstelle_backup() { local name=$(basename "$QUELLE")_$DATUM.tar.gz" local pfad="$ZIEL/$name" log INFO "Backup: $QUELLE → $pfad" tar -czf "$pfad" "$QUELLE" 2>> "$LOGFILE" local groesse=$(du -h "$pfad" | cut -f1) log INFO "Backup fertig: $groesse" } cleanup_alte_backups() { local anzahl=$(find "$ZIEL" -name "*.tar.gz" -mtime +"$AUFBEWAHRUNG" | wc -l) if [[ $anzahl -gt 0 ]]; then log INFO "Lösche $anzahl alte Backups (älter $AUFBEWAHRUNG Tage)" find "$ZIEL" -name "*.tar.gz" -mtime +"$AUFBEWAHRUNG" -delete fi } # ===== Hauptlogik ===== if [[ ! -d "$QUELLE" ]]; then log ERROR "Quelle '$QUELLE' nicht gefunden" exit 3 fi mkdir -p "$ZIEL" log INFO "=== Backup-Lauf gestartet ===" system_info erstelle_backup cleanup_alte_backups log INFO "=== Backup-Lauf erfolgreich beendet ==="

Vier Funktionen mit klaren Aufgaben. Die log()-Funktion schreibt mit tee gleichzeitig auf Terminal UND in die Logdatei. system_info nutzt die Klassiker hostname, uptime, df, free kombiniert mit awk aus L7. cleanup nutzt find -mtime +N -delete aus L8.

Wenn du das ausführst, sieht es etwa so aus:

backup-v3.sh /home/anna/projekte

$ ./backup-v3.sh /home/anna/projekte
[2026-05-17 14:32:01] INFO: === Backup-Lauf gestartet ===
[2026-05-17 14:32:01] INFO: Host: server01
[2026-05-17 14:32:01] INFO: Uptime: up 12 days, 4 hours
[2026-05-17 14:32:01] INFO: Disk: 142G frei von 250G
[2026-05-17 14:32:01] INFO: RAM: 5.2G verfügbar
[2026-05-17 14:32:01] INFO: Backup: /home/anna/projekte → /backup/projekte_2026-05-17_1432.tar.gz
[2026-05-17 14:32:08] INFO: Backup fertig: 145M
[2026-05-17 14:32:08] INFO: Lösche 2 alte Backups (älter 7 Tage)
[2026-05-17 14:32:08] INFO: === Backup-Lauf erfolgreich beendet ===

6) Iteration v4: Konfiguration und Robustheit

Was wenn das Skript auf 10 Servern laufen soll, jeder mit anderer Konfiguration? Wir lagern Settings in eine Datei aus und schützen vor parallelen Läufen:

#!/bin/bash # backup-v4.sh – mit Config-Datei, Lock, trap set -euo pipefail # ===== Konfiguration laden ===== CONFIG="${BACKUP_CONFIG:-/etc/backup.conf}" if [[ -f "$CONFIG" ]]; then # source = Datei lesen wie eingetippt source "$CONFIG" else echo "Config nicht gefunden: $CONFIG" >&2 exit 4 fi # Pflicht-Variablen prüfen : "${QUELLE:?Variable QUELLE muss in Config gesetzt sein}" : "${ZIEL:?Variable ZIEL muss in Config gesetzt sein}" : "${AUFBEWAHRUNG:=7}" : "${LOGFILE:=/var/log/backup.log}" DATUM=$(date +%Y-%m-%d_%H%M) LOCKFILE="/var/run/backup.lock" # ===== Lock + Cleanup-Trap ===== cleanup() { rm -f "$LOCKFILE" } trap cleanup EXIT if [[ -f "$LOCKFILE" ]]; then echo "Backup läuft bereits (PID: $(cat $LOCKFILE))" exit 0 # Nicht als Fehler werten fi echo $$ > "$LOCKFILE" # ===== Funktionen wie in v3 ===== log() { echo "[$(date '+%F %T')] $1: $2" | tee -a "$LOGFILE" } erstelle_backup() { local name=$(basename "$QUELLE")_$DATUM.tar.gz" local pfad="$ZIEL/$name" log INFO "Erstelle: $pfad" tar -czf "$pfad" "$QUELLE" 2>> "$LOGFILE" log INFO "Größe: $(du -h "$pfad" | cut -f1)" } cleanup_alte() { find "$ZIEL" -name "*.tar.gz" -mtime +"$AUFBEWAHRUNG" -delete } # ===== Hauptlogik ===== [[ -d "$QUELLE" ]] || { log ERROR "Quelle '$QUELLE' fehlt"; exit 3; } mkdir -p "$ZIEL" log INFO "=== Start ===" erstelle_backup cleanup_alte log INFO "=== Fertig ==="

Eine zugehörige Konfig /etc/backup.conf:

# /etc/backup.conf # Wird per "source" in das Skript geladen QUELLE="/var/www/firma" ZIEL="/backup/firma" AUFBEWAHRUNG=14 LOGFILE="/var/log/backup-firma.log" ADMIN_MAIL="admin@firma.de"

Das Schöne: dasselbe Skript für mehrere Backup-Jobs! Einfach mehrere Configs anlegen und mit BACKUP_CONFIG=/etc/backup-www.conf ./backup-v4.sh die richtige auswählen. trap cleanup EXIT sorgt für Lock-Entfernung selbst bei Strg+C oder Crash. Pflicht-Variablen werden mit ${VAR:?Fehlermeldung} aus L3 Parameter-Expansion geprüft.

7) Iteration v5: Production-Ready

Die finale Version mit allem drum und dran. Schöner Header mit Doku, Statusmail, klar dokumentierte Exit-Codes:

#!/usr/bin/env bash # ===================================================== # backup.sh – Systemstatus- und Backup-Script # # Usage: # ./backup.sh [config-datei] # BACKUP_CONFIG=/etc/foo.conf ./backup.sh # # Exit-Codes: # 0 = Erfolg # 2 = ungültige Argumente / Hilfe # 3 = Quelle existiert nicht # 4 = Config nicht gefunden / ungültig # 5 = tar-Fehler # # Cron-Eintrag-Beispiel: # 0 3 * * * /usr/local/bin/backup.sh /etc/backup.conf # ===================================================== set -euo pipefail #-- Defaults -- SCRIPT_NAME=$(basename "$0") CONFIG="${1:-${BACKUP_CONFIG:-/etc/backup.conf}}" LOCKFILE="/var/run/backup.lock" DATUM=$(date +%Y-%m-%d_%H%M) #-- Funktionen -- log() { printf '[%s] %s: %s\n' "$(date '+%F %T')" "$1" "$2" | tee -a "$LOGFILE" } err() { log ERROR "$1" [[ -n "${ADMIN_MAIL:-}" ]] && echo "$1" | mail -s "Backup-Fehler" "$ADMIN_MAIL" || true exit "${2:-1}" } cleanup() { rm -f "$LOCKFILE" local ec=$? [[ $ec -eq 0 ]] || log ERROR "Skript abgebrochen mit Code $ec" } system_status() { log INFO "Host: $(hostname -f)" log INFO "Uptime: $(uptime -p)" log INFO "Disk Ziel: $(df -h "$ZIEL" | tail -1 | awk '{print $4 " frei"}')" log INFO "Last: $(uptime | awk -F'load average:' '{print $2}')" } erstelle_backup() { local name=$(basename "$QUELLE")_$DATUM.tar.gz" local pfad="$ZIEL/$name" log INFO "Erstelle Backup: $pfad" if ! tar -czf "$pfad" "$QUELLE" 2>> "$LOGFILE"; then err "tar fehlgeschlagen" 5 fi log INFO "Größe: $(du -h "$pfad" | cut -f1)" } cleanup_alte() { local n=$(find "$ZIEL" -name "*.tar.gz" -mtime +"$AUFBEWAHRUNG" -print | wc -l) if [[ $n -gt 0 ]]; then log INFO "Lösche $n alte Backups" find "$ZIEL" -name "*.tar.gz" -mtime +"$AUFBEWAHRUNG" -delete fi } notify_success() { [[ -n "${ADMIN_MAIL:-}" ]] || return 0 tail -n 20 "$LOGFILE" | mail -s "Backup $SCRIPT_NAME OK" "$ADMIN_MAIL" || true } #-- Main -- trap cleanup EXIT [[ -f "$CONFIG" ]] || { echo "Config '$CONFIG' fehlt"; exit 4; } # shellcheck source=/dev/null source "$CONFIG" : "${QUELLE:?QUELLE muss in Config gesetzt sein}" : "${ZIEL:?ZIEL muss in Config gesetzt sein}" : "${AUFBEWAHRUNG:=7}" : "${LOGFILE:=/var/log/backup.log}" [[ -d "$QUELLE" ]] || err "Quelle '$QUELLE' nicht gefunden" 3 mkdir -p "$ZIEL" if [[ -f "$LOCKFILE" ]]; then log WARN "Lock existiert (PID $(cat $LOCKFILE)). Abbruch." exit 0 fi echo $$ > "$LOCKFILE" log INFO "=== Backup-Lauf gestartet ===" system_status erstelle_backup cleanup_alte log INFO "=== Backup-Lauf erfolgreich beendet ===" notify_success exit 0

Das ist Production-Code. Lesbar, getestet, fehlertolerant. Die err()-Funktion schickt bei Fehlern eine Mail an den Admin (falls in Config gesetzt). Die cleanup()-Funktion loggt sogar Skript-Abbrüche. Alle Exit-Codes sind im Header dokumentiert.

8) ShellCheck-Test

Bevor wir das Skript live schalten: shellcheck drüber laufen lassen (siehe L6):

shellcheck backup.sh

$ shellcheck backup.sh
(keine Ausgabe = keine Warnungen)

$ echo $?
0

$ bash -n backup.sh # Syntax-Check
(keine Ausgabe = Syntax OK)

shellcheck ohne Output ist das Ziel. Sollten Warnungen kommen: ernst nehmen, sind fast immer echte Probleme. bash -n macht einen reinen Syntax-Check ohne Ausführung – schnelle Sanity-Prüfung.

9) Cron-Einrichtung

Das Skript ist fertig – jetzt soll es automatisch laufen. crontab -e öffnen und eintragen:

# Täglich 3 Uhr morgens komplettes Backup 0 3 * * * /usr/local/bin/backup.sh /etc/backup.conf # Stündlich Statusprüfung (nur log, kein Backup) 0 * * * * /usr/local/bin/check.sh >> /var/log/check.log 2>&1 # Wöchentlich Sonntags 2 Uhr: Vollbackup auf externe Platte 0 2 * * 0 /usr/local/bin/backup.sh /etc/backup-external.conf

Sicherheits-Checkliste vor dem Live-Gehen:

Skript an einem Test-Verzeichnis ausprobieren (NICHT mit Produktiv-Daten zuerst!)
Mit --dry-run-Modus (selbst eingebauen) erst „simulieren" lassen
Restore-Test: kann ich aus dem Backup auch wirklich wiederherstellen?
Logfile prüfen: füllt es sich? Werden Fehler korrekt erfasst?
Disk-Space-Monitoring: Backup-Platte hat Reserve?
Aufbewahrung-Logik testen: alte Backups werden wirklich gelöscht?

10) Erweiterungs-Ideen

Was könnte man noch einbauen?

Inkrementelle Backups mit rsync --link-dest – nur Änderungen kopieren, alte bleiben per Hardlink referenziert.
Off-Site-Backup mit rsync oder scp auf einen entfernten Server (siehe L9).
Verschlüsselung via gpg oder openssl – wichtig wenn Backups auf fremden Servern liegen.
Slack/Teams-Benachrichtigung via Webhook statt Mail.
Backup-Prüfung: nach dem tar einen Test-Auspacken machen, prüfen ob Dateigrößen stimmen.
Metrik-Export: Prometheus-Pushgateway für Monitoring-Integration.
Datenbank-Dumps: vor dem tar erst mysqldump oder pg_dump laufen lassen.
Multi-Quellen: nicht nur ein Verzeichnis, sondern Liste in Config.

Spätestens wenn das Skript > 200 Zeilen wird, lohnt sich der Wechsel zu Python. Für richtig große Setups gibt es spezialisierte Tools: BorgBackup, Restic, Bacula. Aber für 80% der FISI-Aufgaben reicht so ein Bash-Skript völlig – und du verstehst genau was passiert. Mehr zu professionellen Backup-Konzepten in K58 Backup-Strategien.

11) Die Bash-Säulen – Rückblick auf den Kurs

Du hast in diesem Kurs alle wichtigen Bash-Konzepte kennengelernt. Hier nochmal als Übersicht – jedes Konzept war in diesem Projekt sichtbar:

Bash-Kursinhalte im Backup-Skript wiederfinden

L1 Shell-Verständnis

Shebang, Skript ausführbar machen

L2 Grundbefehle

tar, du, df, mkdir, basename, find

L3 Variablen + I/O

Quoting, Parameter-Expansion, Streams umleiten

L4 Kontrollstrukturen

if, [[ ]], && ||, Datei-Tests

L5 Funktionen

log(), err(), Argumente, local, return

L6 Fehlerbehandlung

set -euo pipefail, trap cleanup EXIT, Exit-Codes

L7 Textverarbeitung

awk in system_status, cut, tail

L8 Automation

find -mtime -delete, cron-Eintrag

L9 Netzwerk

mail-Versand, optional rsync für Remote-Backup

Genau diese Vermischung ist der Punkt: in echten Bash-Skripten kombinierst du alle Konzepte. Niemand schreibt „nur ein if" oder „nur eine Funktion" – du baust kleine Bausteine zu lösungsorientierten Programmen zusammen. Genau das hast du jetzt gemacht.

12) Wie es weitergeht

Bash ist nur ein Werkzeug von vielen. Die nächsten Schritte für FISI:

K29 Linux-Serveradministration – Bash anwenden auf realen Servern: Users, Services, Logging, Netzwerk-Stack.
K54 CI/CD – Bash-Skripte landen oft in GitLab CI oder GitHub Actions Pipelines.
K32 Docker – Dockerfiles enthalten Bash-Code, Entrypoint-Skripte sind Bash.
K44 PowerShell – Das Windows-Pendant zu Bash. Andere Philosophie (objektbasiert), aber ähnliche Konzepte.
K41 Python – Für alles was über Bash hinausgeht. Komplexere Datenstrukturen, REST-APIs, Tests.
Konfigurationsmanagement – Ansible, Puppet, Chef. Skalieren Bash-Patterns auf 100+ Server.

Übe Bash am besten direkt am eigenen System: schreibe kleine Skripte für Dinge die du regelmäßig manuell machst. Foto-Sortierer? Log-Aufräumer? Status-Dashboard? Jedes davon ist eine perfekte Übung. Innerhalb weniger Wochen wirst du merken: was vorher 10 Minuten Klicken war, ist jetzt ein Tipper. Das ist die echte Macht der Shell.

Zusammenfassung

In diesem Projekt haben wir ein produktionstaugliches Backup-Skript in 5 Iterationen aufgebaut: v1 minimal, v2 mit Argumenten + strikter Modus, v3 mit Funktionen + Logging, v4 mit Config + trap + Lock, v5 production-ready mit Mail-Benachrichtigung und Doku. Iterative Entwicklung ist Standard – nicht alles auf einmal! Wichtige Prinzipien: set -euo pipefail immer, alle Funktionen mit local-Variablen, Konfiguration über separate Datei mit source, trap cleanup EXIT für Lock-Files, Logging mit Zeitstempeln, klare Exit-Codes im Header dokumentieren, mit ShellCheck prüfen, vor Live-Gang im Test-Setup ausprobieren, Cron-Einbindung über crontab -e. Alles aus diesem Kurs floss zusammen: Befehle (L2), Variablen (L3), Kontrollstrukturen (L4), Funktionen (L5), Fehlerbehandlung (L6), Textverarbeitung (L7), find/cron (L8), Mail (L9). Bash ist dein Werkzeug für tägliche Automatisierung – produktiv mit kleinen Schritten am eigenen System trainieren!