Willkommen zum sechsten Teil unserer technischen Wiki-Serie über Linux-Administration!
Nachdem wir in den vorherigen Artikeln die Grundlagen, Benutzerverwaltung, Prozesse, Netzwerkkonfiguration und Shell-Scripting behandelt haben, widmen wir uns heute einem kritischen Aspekt der Systemadministration: der Datensicherung und Wiederherstellung.
Als Linux-Administrator ist die Sicherung und Wiederherstellung von Daten eine deiner wichtigsten Aufgaben.
Stell dir vor, dein System ist wie ein wertvolles Buch – und Backups sind wie Kopien dieses Buches, die du an verschiedenen sicheren Orten aufbewahrst. Wenn das Original beschädigt wird oder verloren geht, kannst du es jederzeit wiederherstellen.
Backup-Strategien
Als Linux-Administrator ist die Datensicherung eine deiner wichtigsten Aufgaben. Stell dir Backups wie verschiedene Versicherungspolicen vor – jede hat ihre eigenen Vor- und Nachteile.
Backup-Arten:
┌─────────── Vollbackup ───────────┐
│ - Komplette Datensicherung │
│ - Hoher Speicherverbrauch │
│ - Lange Backup-Zeit │
├─────────── Differentiell ────────┤
│ - Änderungen seit letztem Full │
│ - Mittlerer Speicherverbrauch │
│ - Schnellere Wiederherstellung │
├─────────── Inkrementell ─────────┤
│ - Nur neue Änderungen │
│ - Geringer Speicherverbrauch │
│ - Komplexere Wiederherstellung │
└──────────────────────────────────┘
1. Vollbackup (Full Backup)
Ein Vollbackup ist wie ein kompletter Umzugskarton mit allem Inhalt. Es sichert alle ausgewählten Daten, unabhängig davon, ob sie sich geändert haben oder nicht.
Vorteile:
- Einfache Wiederherstellung
- Alle Daten in einer Sicherung
- Unabhängig von anderen Backups
Nachteile:
- Benötigt viel Speicherplatz
- Zeitaufwändig
- Hohe Netzwerklast bei Remote-Backups
2. Differentielles Backup
Ein differentielles Backup sichert alle Änderungen seit dem letzten Vollbackup. Dies ist wie ein Tagebuch, das alle Änderungen seit einem bestimmten Datum aufzeichnet.
Backup-Zeitstrahl (Differentiell):
┌─── Tag 1 ───┬─── Tag 2 ───┬─── Tag 3 ───┐
│ Vollbackup │ Diff (20GB) │ Diff (25GB) │
│ (100GB) │ seit Tag 1 │ seit Tag 1 │
└─────────────┴─────────────┴─────────────┘
Vorteile:
- Schneller als Vollbackup
- Weniger Speicherplatz als Vollbackup
- Einfachere Wiederherstellung als inkrementelles Backup
Nachteile:
- Mehr Speicherplatz als inkrementelles Backup
- Längere Backup-Zeit als inkrementelles Backup
3. Inkrementelles Backup
Ein inkrementelles Backup sichert nur die Änderungen seit dem letzten Backup (egal welcher Art). Dies ist wie ein täglicher Eintrag in einem Tagebuch.
Backup-Zeitstrahl:
┌─── Tag 1 ───┬─── Tag 2 ───┬─── Tag 3 ───┐
│ Vollbackup │ Inkrement 1 │ Inkrement 2 │
│ (100 GB) │ (5 GB) │ (3 GB) │
└─────────────┴─────────────┴─────────────┘
Vorteile:
- Sehr schnelle Backup-Zeit
- Minimaler Speicherverbrauch
- Ideal für tägliche Backups
Nachteile:
- Komplexere Wiederherstellung
- Benötigt alle vorherigen Backups
- Höheres Risiko bei beschädigten Backups
4. Snapshot-Backups
Ein Snapshot ist eine punktuelle Aufnahme des Systemzustands zu einem bestimmten Zeitpunkt. Anders als traditionelle Backups nutzen Snapshots Copy-on-Write-Technologie.
Snapshot-Funktionsweise:
┌─────────── Originaldaten ──────────┐
│ Block A │ Block B │ Block C │
├─────────── Snapshot 1 ─────────────┤
│ Nur geänderte Blöcke werden kopiert│
│ A' │ B │ C │
├─────────── Snapshot 2 ─────────────┤
│ Weitere Änderungen │
│ A' │ B' │ C │
└────────────────────────────────────┘
Vorteile:
- Sehr schnelle Erstellung (Sekunden)
- Platzsparend (nur Änderungen)
- Konsistente Sicherung
- Schnelle Wiederherstellung
Nachteile:
- Abhängig vom Dateisystem (z.B. ZFS, Btrfs)
- Bei Systemausfall alle Snapshots betroffen
- Kein Ersatz für externe Backups
- Benötigt mehr Speicherplatz über Zeit
Einsatzgebiete:
- Vor Systemupdates
- Entwicklungsumgebungen
- Virtuelle Maschinen
- Datenbank-Backups
Backup-Tools und -Technologien
Als Linux-Administrator hast du Zugriff auf verschiedene, leistungsfähige Backup-Tools. Jedes Tool hat seine spezifischen Stärken und Einsatzgebiete.
Backup-Tools:
┌─────────── Traditionell ──────────┐
│ tar - Archivierung │
│ dd - Bit-genaue Kopien │
│ rsync - Synchronisation │
└───────────────────────────────────┘
Traditionell
rsync
Ein leistungsstarkes Tool für inkrementelle Backups und Synchronisation. Hauptmerkmale:
- Überträgt nur geänderte Dateien
- Unterstützt Remote-Backups
- Bandbreiteneffizient
- Erhält Berechtigungen
# Lokales Backup
rsync -av /quelle/ /ziel/
# Remote-Backup
rsync -avz -e ssh /lokale/daten/ user@server:/backup/
# Mit Ausschlüssen
rsync -av --exclude='*.tmp' /quelle/ /ziel/
tar
Das klassische Tool für Archivierung und Komprimierung.
Hauptmerkmale:
- Erstellt einzelne Archivdateien
- Verschiedene Komprimierungsmethoden
- Erhält Metadaten und Berechtigungen
# Backup erstellen mit Komprimierung
tar -czf backup.tar.gz /zu/sichernde/daten/
# Backup mit Datum
tar -czf backup_$(date +%Y%m%d).tar.gz /daten/
# Archiv entpacken
tar -xzf backup.tar.gz
dd
Ein mächtiges Tool für bit-genaue Kopien von Datenträgern.
Hauptmerkmale:
- Erstellt exakte Kopien (Disk Images)
- Kann ganze Festplatten sichern
- Arbeitet auf niedrigster Ebene
# Festplatte auf Image sichern
dd if=/dev/sda of=/backup/disk.img bs=4M status=progress
# Image auf neue Festplatte zurückspielen
dd if=/backup/disk.img of=/dev/sdb bs=4M status=progress
# Partition sichern
dd if=/dev/sda1 of=/backup/partition.img bs=4M
Modern
Backup-Tools:
┌─────────── Modern ────────────────┐
│ borg - Deduplizierung │
│ restic - Verschlüsselung │
└───────────────────────────────────┘
borg
Ein modernes Backup-Tool mit Deduplizierung und Verschlüsselung.
Hauptmerkmale:
- Intelligente Deduplizierung
- Integrierte Verschlüsselung
- Komprimierung
- Schnelle Wiederherstellung
# Repository initialisieren
borg init --encryption=repokey /pfad/zum/backup
# Backup erstellen
borg create --stats --progress \
/pfad/zum/backup::backup-{now} \
/home/user/daten
# Backups auflisten
borg list /pfad/zum/backup
restic
Ein sicheres Backup-Programm mit Cloud-Unterstützung.
Hauptmerkmale:
- Verschlüsselung
- Cloud-Storage-Support
- Schnelle Inkrementelle Backups
- Einfache Bedienung
# Repository initialisieren
restic init --repo /backup/restic-repo
# Backup erstellen
restic -r /backup/restic-repo backup /home/user/daten
# Snapshots anzeigen
restic -r /backup/restic-repo snapshots
Backup-Automatisierung
Nach den Backup-Tools kommen wir nun zur Automatisierung der Backup-Prozesse. Eine gute Backup-Strategie ist nur dann effektiv, wenn sie zuverlässig und regelmäßig ausgeführt wird.
Backup-Skript erstellen
a) Einfaches Backup-Skript mit Logging
#!/bin/bash
# simple_backup.sh - Grundlegendes Backup mit Logging
# Konfiguration
SOURCE_DIR="/home/user/data"
BACKUP_DIR="/backup"
LOG_FILE="/var/log/backup.log"
MAX_BACKUPS=5
# Logging-Funktion
log_message() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
echo "$1"
}
b) Inkrementelles Backup-Skript
#!/bin/bash
# incremental_backup.sh - Inkrementelles Backup-System
# Konfiguration
SOURCE="/home/user/data"
BACKUP_BASE="/backup/incremental"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
LATEST_LINK="$BACKUP_BASE/latest"
# Inkrementelles Backup mit rsync
if [ -d "$LATEST_LINK" ]; then
rsync -av --link-dest="$LATEST_LINK" "$SOURCE/" "$BACKUP_BASE/backup_$TIMESTAMP/"
else
rsync -av "$SOURCE/" "$BACKUP_BASE/backup_$TIMESTAMP/"
fi
# Aktualisiere "latest" Link
ln -snf "$BACKUP_BASE/backup_$TIMESTAMP" "$LATEST_LINK"
c) Full Backup-Skript
#!/bin/bash
# full_backup.sh - Vollständiges System-Backup
# Konfiguration
SOURCE_DIRS=("/home" "/etc" "/var/www")
BACKUP_DIR="/backup"
DATE=$(date +%Y%m%d_%H%M%S)
LOG_FILE="/var/log/backup.log"
RETENTION_DAYS=30
# Logging-Funktion
log_message() {
local message="$1"
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $message" >> "$LOG_FILE"
echo "$message"
}
# Backup-Verzeichnis prüfen/erstellen
check_backup_dir() {
if [ ! -d "$BACKUP_DIR" ]; then
mkdir -p "$BACKUP_DIR"
log_message "Backup-Verzeichnis erstellt: $BACKUP_DIR"
fi
}
# Speicherplatz prüfen
check_disk_space() {
local required_space=$(du -sc "${SOURCE_DIRS[@]}" | tail -n1 | cut -f1)
local available_space=$(df "$BACKUP_DIR" | tail -n1 | awk '{print $4}')
if [ $available_space -lt $required_space ]; then
log_message "FEHLER: Nicht genügend Speicherplatz!"
exit 1
fi
}
# Backup erstellen
create_backup() {
local backup_file="${BACKUP_DIR}/full_backup_${DATE}.tar.gz"
log_message "Starte Vollbackup..."
tar -czf "$backup_file" "${SOURCE_DIRS[@]}" 2>> "$LOG_FILE"
if [ $? -eq 0 ]; then
log_message "Backup erfolgreich: $backup_file"
return 0
else
log_message "FEHLER: Backup fehlgeschlagen!"
return 1
fi
}
# Alte Backups aufräumen
cleanup_old_backups() {
log_message "Lösche Backups älter als $RETENTION_DAYS Tage..."
find "$BACKUP_DIR" -name "full_backup_*.tar.gz" -mtime +$RETENTION_DAYS -delete
}
# Hauptprogramm
main() {
log_message "=== Starte Backup-Prozess ==="
check_backup_dir
check_disk_space
create_backup
cleanup_old_backups
log_message "=== Backup-Prozess beendet ==="
}
# Skript ausführen
main
Cron-Job-Einrichtung
Die regelmäßige Ausführung von Backups ist entscheidend für die Datensicherheit. Cron ist das perfekte Werkzeug dafür:
Cron-Zeitformat:
┌───────────── Minute (0-59)
│ ┌───────────── Stunde (0-23)
│ │ ┌───────────── Tag (1-31)
│ │ │ ┌───────────── Monat (1-12)
│ │ │ │ ┌───────────── Wochentag (0-7)
* * * * * Befehl/Skript
Backup-Cron einrichten:
# Backup-Skript für Cron vorbereiten
chmod +x /usr/local/sbin/backup_system.sh
# Crontab bearbeiten
crontab -e
# Tägliches Backup um 2 Uhr morgens
0 2 * * * /usr/local/sbin/backup_system.sh
# Wöchentliches Vollbackup am Sonntag um 3 Uhr
0 3 * * 0 /usr/local/sbin/full_backup.sh
Monitoring und Benachrichtigungen
Ein effektives Backup-System benötigt nicht nur die Sicherung selbst, sondern auch eine zuverlässige Überwachung. Nur so können wir sicherstellen, dass unsere Backups erfolgreich durchgeführt werden und im Notfall verfügbar sind.
Komponenten eines Backup-Monitorings
Monitoring-Komponenten:
┌─────────── Status-Prüfung ────────┐
│ - Backup-Erfolg │
│ - Backup-Größe │
│ - Speicherplatz │
├─────────── Benachrichtigung ──────┤
│ - E-Mail-Alerts │
│ - Log-Einträge │
│ - System-Meldungen │
└───────────────────────────────────┘
Status-Überwachung
Die Status-Überwachung prüft kontinuierlich verschiedene Aspekte unserer Backups:
- Erfolgreiche Durchführung
- Aktualität der Backups
- Integrität der Backup-Dateien
- Verfügbarer Speicherplatz
Hier ist ein Beispiel für ein Monitoring-Skript:
#!/bin/bash
# backup_monitor.sh
# Konfiguration
BACKUP_DIR="/backup"
LOG_FILE="/var/log/backup_monitor.log"
MAIL_TO="admin@domain.com"
MIN_SIZE=1048576 # 1MB in Bytes
# Monitoring-Funktionen
check_backup_status() {
# Prüfe letztes Backup
local latest_backup=$(find "$BACKUP_DIR" -type f -name "backup_*.tar.gz" -mtime -1)
if [ -z "$latest_backup" ]; then
send_alert "WARNUNG: Kein aktuelles Backup gefunden!"
return 1
fi
# Prüfe Backup-Größe
local size=$(stat -f %z "$latest_backup")
if [ "$size" -lt "$MIN_SIZE" ]; then
send_alert "WARNUNG: Backup-Größe zu klein: $size Bytes"
return 1
fi
log_message "Backup-Status OK: $(basename "$latest_backup")"
return 0
}
# Alert-Funktion
send_alert() {
local message="$1"
echo "$message" | mail -s "Backup Alert" "$MAIL_TO"
log_message "ALERT: $message"
}
Backup-Verifizierung und Tests
Die beste Backup-Strategie ist nutzlos, wenn die Backups nicht funktionieren. Daher ist die regelmäßige Überprüfung und das Testen der Backups essentiell.
Verifizierungs-Prozess:
┌─────────── Integrität ───────────┐
│ - Checksummen prüfen │
│ - Backup-Größe verifizieren │
│ - Archiv-Test durchführen │
├─────────── Tests ────────────────┤
│ - Wiederherstellung testen │
│ - Stichproben durchführen │
│ - Recovery-Plan validieren │
└──────────────────────────────────┘
1. Integrität prüfen
Die Integrität deiner Backups sollte regelmäßig überprüft werden:
a) Checksummen erstellen und prüfen
# MD5-Prüfsumme erstellen
md5sum backup.tar.gz > backup.md5
# SHA256-Prüfsumme erstellen (sicherer)
sha256sum backup.tar.gz > backup.sha256
# Prüfsumme verifizieren
sha256sum -c backup.sha256
b) Archiv-Integrität testen
# tar-Archiv testen
tar -tvf backup.tar.gz
# zip-Archiv testen
unzip -t backup.zip
2. Test-Wiederherstellungen
Die regelmäßige Durchführung von Test-Wiederherstellungen ist entscheidend für die Zuverlässigkeit deines Backup-Systems.
Verifizierungs-Prozess:
┌─────────── Integrität ───────────┐
│ - Checksummen prüfen │
│ - Backup-Größe verifizieren │
│ - Archiv-Test durchführen │
├─────────── Tests ────────────────┤
│ - Wiederherstellung testen │
│ - Stichproben durchführen │
│ - Recovery-Plan validieren │
└──────────────────────────────────┘
a) Testumgebung vorbereiten
# Testverzeichnis erstellen
mkdir /tmp/backup_test
cd /tmp/backup_test
# Backup-Archiv prüfen
tar -tvf /backup/full_backup_20240101.tar.gz
# Testwiederherstellung durchführen
tar -xzf /backup/full_backup_20240101.tar.gz
b) Datenintegrität prüfen
# Verzeichnisstruktur prüfen
find . -type d | sort > struktur.txt
# Dateiberechtigungen prüfen
ls -lR > berechtigungen.txt
# Stichprobenartige Dateiprüfung
file wichtige_datei.txt
md5sum kritische_daten.db
3. Dokumentation
Eine gründliche Dokumentation ist entscheidend für ein erfolgreiches Backup-System. Sie hilft dir und deinem Team, Prozesse nachzuvollziehen und im Notfall schnell zu reagieren.
Dokumentations-Struktur:
┌─────────── Backup-Plan ──────────┐
│ - Backup-Strategien │
│ - Zeitpläne │
│ - Verantwortlichkeiten │
├─────────── Prozesse ─────────────┤
│ - Backup-Verfahren │
│ - Wiederherstellung │
│ - Notfallplan │
└──────────────────────────────────┘
Wichtige Dokumentationselemente:
- Backup-Konfiguration
- Backup-Typen und Zeitpläne
- Speicherorte und Aufbewahrungsfristen
- Verwendete Tools und Skripte
- Wiederherstellungsprozesse
- Schritt-für-Schritt-Anleitungen
- Kontaktpersonen und Zuständigkeiten
- Notfallprozeduren
- Test-Protokolle
- Durchgeführte Tests
- Testergebnisse
- Erkannte Probleme und Lösungen
Disaster Recovery
Bei der Disaster Recovery geht es um die Wiederherstellung deines Systems nach einem schwerwiegenden Ausfall. Ein durchdachter Plan ist hier entscheidend.
Recovery-Prozess:
┌─────────── Vorbereitung ─────────┐
│ 1. Situation analysieren │
│ 2. Recovery-Plan aktivieren │
│ 3. Team informieren │
├─────────── Wiederherstellung ────┤
│ 4. System wiederherstellen │
│ 5. Daten zurückspielen │
│ 6. Services neustarten │
├─────────── Validierung ──────────┤
│ 7. Tests durchführen │
│ 8. Monitoring aktivieren │
│ 9. Dokumentation aktualisieren │
└──────────────────────────────────┘
1. Recovery-Strategie
a) Recovery-Ziele definieren:
- RPO (Recovery Point Objective): Maximaler akzeptabler Datenverlust
- RTO (Recovery Time Objective): Maximale akzeptable Ausfallzeit
- Kritische Systeme und Dienste identifizieren
b) Recovery-Level festlegen:
Recovery-Stufen:
┌─────────── Level 1 ──────────────┐
│ Kritische Geschäftsprozesse │
├─────────── Level 2 ──────────────┤
│ Wichtige Unterstützungssysteme │
├─────────── Level 3 ──────────────┤
│ Nicht-kritische Systeme │
└──────────────────────────────────┘
Dokumentation
Eine vollständige und aktuelle Dokumentation ist entscheidend:
a) System-Dokumentation:
- Hardware-Konfiguration
- Software-Versionen
- Netzwerk-Einstellungen
- Backup-Konfiguration
- Abhängigkeiten zwischen Systemen
b) Recovery-Prozeduren:
- Schritt-für-Schritt Anleitungen
- Wiederherstellungsreihenfolge
- Validierungsprozesse
- Rollback-Pläne
Verantwortlichkeiten
Klare Zuständigkeiten sind essentiell für schnelles Handeln:
a) Recovery-Team:
- Teamleiter (Entscheidungsträger)
- System-Administratoren
- Netzwerk-Spezialisten
- Datenbank-Administratoren
- Support-Mitarbeiter
b) Eskalationsprozesse:
Eskalations-Hierarchie:
┌─────────── Stufe 1 ──────────────┐
│ Erste Reaktion & Bewertung │
├─────────── Stufe 2 ──────────────┤
│ Technische Eskalation │
├─────────── Stufe 3 ──────────────┤
│ Management-Eskalation │
└──────────────────────────────────┘
2. System-Wiederherstellung
Die Wiederherstellung eines Systems nach einem Ausfall erfordert ein systematisches Vorgehen. Als Linux-Administrator musst du verschiedene Wiederherstellungsszenarien beherrschen.
Wiederherstellungs-Prozess:
┌─────────── Vorbereitung ─────────┐
│ - Boot-Medium erstellen │
│ - Backups identifizieren │
│ - Hardware prüfen │
├─────────── System ───────────────┤
│ - Basis-System installieren │
│ - Konfiguration wiederherstellen │
│ - Services einrichten │
├─────────── Daten ────────────────┤
│ - Backup einspielen │
│ - Berechtigungen prüfen │
│ - Integrität testen │
└──────────────────────────────────┘
Vorbereitende Maßnahmen
- Boot-Medium mit Rettungssystem vorbereiten
- Backup-Medien und Wiederherstellungspunkte identifizieren
- Hardware auf Fehler prüfen
- Netzwerkverbindung sicherstellen
System-Wiederherstellung
a) Basis-System installieren:
- Partitionierung wiederherstellen
- Grundsystem installieren
- Bootloader konfigurieren
b) Systemkonfiguration:
/etc
Verzeichnis wiederherstellen- Netzwerk-Einstellungen anpassen
- Benutzer und Gruppen einrichten
c) Dienste und Services:
- Systemdienste konfigurieren
- Abhängigkeiten prüfen
- Services in richtiger Reihenfolge starten
3. Daten-Wiederherstellung
Die Wiederherstellung von Daten erfordert ein systematisches Vorgehen, abhängig von der Art des Backups und der wiederherzustellenden Daten.
Wiederherstellungs-Prozess:
┌─────────── Vorbereitung ─────────┐
│ - Backup identifizieren │
│ - Zielverzeichnis prüfen │
│ - Speicherplatz verifizieren │
├─────────── Durchführung ─────────┤
│ - Daten wiederherstellen │
│ - Berechtigungen prüfen │
│ - Integrität testen │
└──────────────────────────────────┘
Daten aus Vollbackup wiederherstellen
# Backup entpacken
tar -xzf /backup/full_backup_20240101.tar.gz -C /recovery/
# Berechtigungen prüfen und korrigieren
chown -R user:group /recovery/data/
chmod -R 755 /recovery/data/
Inkrementelle Wiederherstellung
# Vollbackup wiederherstellen
tar -xzf /backup/full_20240101.tar.gz -C /recovery/
# Inkrementelle Backups in chronologischer Reihenfolge
tar -xzf /backup/incr_20240102.tar.gz -C /recovery/
tar -xzf /backup/incr_20240103.tar.gz -C /recovery/
4. Notfallpläne
Ein durchdachter Notfallplan ist entscheidend für die schnelle Wiederherstellung im Krisenfall.
Notfallplan-Struktur:
┌─────────── Vorbereitung ─────────┐
│ - Kontaktliste │
│ - Backup-Inventar │
│ - Recovery-Anleitungen │
├─────────── Maßnahmen ────────────┤
│ - Sofortmaßnahmen │
│ - Wiederherstellungsschritte │
│ - Validierung │
└──────────────────────────────────┘
Vorbereitung und Dokumentation
- Aktuelle Kontaktliste aller Verantwortlichen
- Standorte aller Backup-Medien
- Zugangsdaten und Passwörter (sicher verwahrt)
- Hardware-Anforderungen
- Netzwerk-Konfigurationen
Sofortmaßnahmen
- Schadensbegrenzung
- Betroffene Systeme identifizieren
- Team informieren
- Backup-Medien bereitstellen
Wiederherstellungsschritte
- Priorisierte Wiederherstellungsliste
- Abhängigkeiten beachten
- Testprozeduren
- Dokumentation der durchgeführten Schritte
ja fahre mit dem Haupthema: Best Practices fort mit den Unterthemen:
- 3-2-1 Backup-Regel
- Verschlüsselung
- Aufbewahrungsfristen
- Dokumentation
Best Practices
Die Einhaltung bewährter Praktiken ist entscheidend für ein zuverlässiges Backup-System. Hier sind die wichtigsten Best Practices für deine Backup-Strategie.
Best Practices Übersicht:
┌─────────── 3-2-1 Regel ───────────┐
│ - 3 Backup-Kopien │
│ - 2 verschiedene Medien │
│ - 1 Off-Site Backup │
├─────────── Sicherheit ────────────┤
│ - Verschlüsselung │
│ - Zugriffskontrollen │
│ - Verifizierung │
└───────────────────────────────────┘
Die 3-2-1 Backup-Regel
Diese bewährte Regel hilft dir, deine Daten optimal zu schützen:
Backup-Kopien:
- Original-Daten
- Erste Backup-Kopie (z.B.
externe Festplatte
) - Zweite Backup-Kopie (z.B.
Cloud-Storage
)
Verschiedene Medien:
- Unterschiedliche Speichertypen (z.B.
SSD
undHDD
) - Verschiedene Hersteller
- Verschiedene Technologien
1 Off-Site Backup:
- Physisch getrennt vom Hauptstandort
- Cloud-Storage oder externes Rechenzentrum
- Schutz vor lokalen Katastrophen
Verschlüsselung
Die Verschlüsselung deiner Backups ist ein wichtiger Sicherheitsaspekt, besonders wenn sensible Daten gesichert werden.
Verschlüsselungs-Optionen:
┌─────────── Symmetrisch ──────────┐
│ - Ein Schlüssel │
│ - Schnell │
│ - Einfach │
├─────────── Asymmetrisch ─────────┤
│ - Schlüsselpaar │
│ - Sicherer │
│ - Komplexer │
└──────────────────────────────────┘
a) Backup-Verschlüsselung mit GPG:
# Backup erstellen und verschlüsseln
tar -czf - /wichtige/daten | \
gpg -e -r "admin@domain.com" > backup.tar.gz.gpg
# Backup entschlüsseln
gpg -d backup.tar.gz.gpg | tar -xzf -
b) Verschlüsselte Backups mit borg:
# Repository mit Verschlüsselung initialisieren
borg init --encryption=repokey /pfad/zum/backup
# Verschlüsseltes Backup erstellen
borg create /pfad/zum/backup::backup-{now} /daten
Aufbewahrungsfristen
Die richtige Aufbewahrungsdauer von Backups ist entscheidend für ein effektives Backup-System.
Aufbewahrungsstrategien:
┌─────────── Kurzfristig ──────────┐
│ - Tägliche Backups: 7-14 Tage │
│ - Wöchentliche: 4-8 Wochen │
├─────────── Langfristig ──────────┤
│ - Monatliche: 12-24 Monate │
│ - Jährliche: 5-7 Jahre │
└──────────────────────────────────┘
Aufbewahrungsrichtlinien:
- Tägliche Backups
- Für schnelle Wiederherstellung
- 7-14 Tage aufbewahren
- Automatische Rotation
- Wöchentliche Backups
- Für mittelfristige Sicherung
- 4-8 Wochen aufbewahren
- Jeden Sonntag erstellen
- Monatliche Backups
- Für langfristige Archivierung
- 12-24 Monate aufbewahren
- Am Monatsende erstellen
Implementierung:
# Backup-Rotation einrichten
find /backup/daily -type f -mtime +14 -delete
find /backup/weekly -type f -mtime +60 -delete
find /backup/monthly -type f -mtime +730 -delete
Dokumentation
Eine gründliche Dokumentation ist der Schlüssel zu einem wartbaren Backup-System.
Dokumentations-Struktur:
┌─────────── System ──────────────┐
│ - Hardware-Konfiguration │
│ - Software-Versionen │
│ - Netzwerk-Setup │
├─────────── Backup ──────────────┤
│ - Backup-Strategien │
│ - Speicherorte │
│ - Wiederherstellungspläne │
└─────────────────────────────────┘
1. System-Dokumentation
- Vollständige Hardware-Inventur
- Installierte Software und Versionen
- Netzwerkkonfiguration
- Benutzer und Berechtigungen
2. Backup-Dokumentation
- Verwendete Backup-Tools
- Backup-Zeitpläne
- Speicherorte und Zugangsdaten
- Aufbewahrungsrichtlinien
3. Recovery-Dokumentation
- Schritt-für-Schritt Anleitungen
- Kontaktpersonen für Notfälle
- Testprotokolle
- Fehlerbehandlung
Übung
Backup-System aufsetzen
Szenario: Als Linux-Administrator sollst du ein vollständiges Backup-System für ein kleines Unternehmen einrichten. Die Daten verschiedener Abteilungen müssen gesichert und im Notfall schnell wiederhergestellt werden können.
Anforderungen:
┌─────────── Backup ─────────────┐
│ - Tägliches Backup │
│ - Wöchentliches Vollbackup │
│ - Verschlüsselung │
├─────────── Monitoring ─────────┤
│ - Status-Überprüfung │
│ - E-Mail-Benachrichtigung │
│ - Log-Rotation │
└────────────────────────────────┘
Aufgaben
1. Backup-Struktur erstellen:
- Backup-Verzeichnisse anlegen
- Berechtigungen setzen
- Verschlüsselung einrichten
2. Backup-Skripte entwickeln:
- Tägliches inkrementelles Backup
- Wöchentliches Vollbackup
- Automatische Rotation alter Backups
3. Monitoring einrichten:
- Backup-Status überwachen
- E-Mail-Benachrichtigungen konfigurieren
- Logging implementieren
Mögliche Lösung
1. Backup-Struktur erstellen
# Verzeichnisstruktur anlegen
sudo mkdir -p /backup/{daily,weekly,logs}
sudo mkdir -p /backup/keys
# Berechtigungen setzen
sudo chmod 700 /backup/keys
sudo chmod 755 /backup/{daily,weekly,logs}
# GPG-Schlüssel für Verschlüsselung erstellen
gpg --gen-key
gpg --export-secret-keys --armor backup@domain.com > /backup/keys/backup.key
2. Backup-Skript entwickeln
#!/bin/bash
# backup_system.sh
# Konfiguration
SOURCE_DIRS=("/home" "/etc" "/var/www")
BACKUP_DIR="/backup"
LOG_FILE="/backup/logs/backup.log"
DATE=$(date +%Y%m%d_%H%M)
RETENTION_DAILY=7
RETENTION_WEEKLY=4
# Logging-Funktion
log_message() {
echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" >> "$LOG_FILE"
echo "$1"
}
# Backup erstellen
create_backup() {
local type=$1
local backup_file="${BACKUP_DIR}/${type}/backup_${DATE}.tar.gz"
log_message "Starte ${type} Backup..."
tar -czf - "${SOURCE_DIRS[@]}" | \
gpg -e -r backup@domain.com > "$backup_file"
if [ $? -eq 0 ]; then
log_message "Backup erfolgreich: $backup_file"
return 0
else
log_message "FEHLER: Backup fehlgeschlagen"
return 1
fi
}
3. Monitoring einrichten
#!/bin/bash
# backup_monitor.sh
# Konfiguration
BACKUP_DIR="/backup"
LOG_FILE="/backup/logs/backup.log"
MAIL_TO="admin@domain.com"
MIN_SIZE=1048576 # 1MB in Bytes
# Monitoring-Funktionen
check_backup() {
local latest_backup=$(find "$BACKUP_DIR" -type f -name "backup_*.tar.gz" -mtime -1)
# Prüfe ob Backup existiert
if [ -z "$latest_backup" ]; then
send_alert "FEHLER: Kein aktuelles Backup gefunden!"
return 1
fi
# Prüfe Backup-Größe
local size=$(stat -f %z "$latest_backup")
if [ "$size" -lt "$MIN_SIZE" ]; then
send_alert "WARNUNG: Backup-Größe zu klein: $size Bytes"
return 1
fi
# Prüfe Backup-Integrität
if ! tar -tzf "$latest_backup" >/dev/null 2>&1; then
send_alert "FEHLER: Backup-Archiv beschädigt!"
return 1
fi
log_message "Backup-Status OK: $(basename "$latest_backup")"
return 0
}
# Cron-Job für tägliche Überprüfung:
0 7 * * * /backup/scripts/backup_monitor.sh
Fazit
In diesem sechsten Teil unserer Linux-Administrations-Serie hast du gelernt, wie du ein zuverlässiges Backup-System aufbaust und verwaltest. Du verstehst nun die verschiedenen Backup-Strategien, von Vollbackups über inkrementelle bis hin zu Snapshot-Backups, und kennst ihre jeweiligen Vor- und Nachteile.
Die Sicherung und Wiederherstellung von Daten gehört zu den wichtigsten Aufgaben eines Linux-Administrators. Mit dem erworbenen Wissen kannst du nun eigenständig Backup-Strategien entwickeln, automatisierte Backup-Systeme einrichten und im Notfall Daten wiederherstellen. Besonders wichtig ist das Verständnis für die verschiedenen Backup-Tools und deren Einsatzmöglichkeiten, sowie die Fähigkeit, Backups zu überwachen und zu testen.
Die praktischen Übungen haben dir gezeigt, wie du ein vollständiges Backup-System aufbaust und verwaltest. Du hast gelernt, wie wichtig eine gute Dokumentation und regelmäßige Tests sind, um im Ernstfall schnell und sicher reagieren zu können.
Im nächsten Artikel der Serie werden wir uns mit Systemsicherheit und Härtung beschäftigen. Du lernst, wie du dein System vor Angriffen schützt und sicher konfigurierst.
Bis dahin, sichere deine Daten!