---
id: 2024-11-03-linux-linux-administration-datensicherung-und-wiederherstellung
slug: linux-administration-datensicherung-und-wiederherstellung
title: "Linux Administration #6: Datensicherung und Wiederherstellung"
excerpt: "Lerne die Grundlagen der Linux-Datensicherung: Von Backup-Strategien über Automatisierung bis hin zur Wiederherstellung. Mit praktischen Beispielen für Administratoren."
date: "2024-11-03T09:00:00+01:00"
updated: "2024-11-03T12:52:00+01:00"
author:
name: "Sebastian Palencsar"
handle: "AdminDocs"
category: "linux-administration"
tags: ["backup", "restore", "tar", "rsync", "compression", "disaster-recovery", "linux-administration"]
toc: true
reading_time: 45
---
**Willkommen zum sechsten Teil unserer technischen Wiki-Serie über Linux-Administration!**
Nachdem wir in den vorherigen Artikeln die [Grundlagen](/de/linux-administration/linux-administration-grundlagen-der-linux-administration){.badge-link-text}, die [Prozessverwaltung](/de/linux-administration/linux-administration-fortgeschrittene-benutzerverwaltung){.badge-link-text} und [Shell-Scripting](/de/linux-administration/linux-administration-netzwerkkonfiguration-und-verwaltung){.badge-link-text} behandelt haben, widmen wir uns heute einem kritischen Aspekt der Systemadministration: der Datensicherung und Wiederherstellung.
⚠️ **Hinweis:** In diesem Artikel verwenden wir Ubuntu/Debian als Beispiel-Distribution. Die grundlegenden Konzepte sind auf allen Linux-Systemen gleich, aber die Installation von Paketen und einige Konfigurationspfade können sich je nach Distribution unterscheiden. Wenn du eine andere Distribution verwendest, konsultiere bitte die entsprechende Dokumentation für die spezifischen Installationsbefehle und Pfade.
**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:**
```markdown
┌─────────── 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):**
```markdown
┌─── 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
* Komplexere Wiederherstellung 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:**
```markdown
┌─── 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:**
```markdown
┌─────────── 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
**Nachteile:**
* Abhängig vom Dateisystem (z.B. ZFS, Btrfs)
* Bei Systemausfall alle Snapshots betroffen
* Kein Ersatz für externe Backups
**Einsatzgebiete:**
* Vor Systemupdates
* Entwicklungsumgebungen
* Virtuelle Maschinen
## 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:**
```markdown
┌─────────── 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
```bash
# 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
```bash
# 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
```bash
# 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:**
```markdown
┌─────────── Modern ──────────────────────────────────────────┐
│ borg - Deduplizierung │
│ restic - Verschlüsselung │
└─────────────────────────────────────────────────────────────┘
```
borg
Ein modernes Backup-Tool mit Deduplizierung und Verschlüsselung.
**Hauptmerkmale:**
* Intelligente Deduplizierung
* Integrierte Verschlüsselung
* Schnelle Wiederherstellung
```bash
# 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
```bash
# 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
```
## Vertiefung: Die 3-2-1-Backup-Regel in der Praxis
In der professionellen Datensicherung ist die **3-2-1-Regel** der anerkannte Industriestandard zur Vermeidung von Totalverlusten:
```markdown
┌─────────────────────────────────────────────────────────────┐
│ DIE 3-2-1 BACKUP-ARCHITEKTUR │
├─────────────────────────────────────────────────────────────┤
│ │
│ [ 3 ] KOPIEN DER DATEN VORHALTEN │
│ ├── 1x Primärdaten auf dem Produktivserver │
│ ├── 1x Lokales Backup (schneller Zugriff) │
│ └── 1x Sekundäres Offsite-Backup │
│ │
│ [ 2 ] VERSCHIEDENE SPEICHERMEDIEN NUTZEN │
│ ├── NVMe/SSD-Storage lokal │
│ └── NAS / SAN / Objektspeicher (S3) / Tape │
│ │
│ [ 1 ] KOPIE AN EINEM EXTERNEN STANDORT (OFFSITE) │
│ └── Schutz vor Brand, Diebstahl, Ransomware │
│ │
└─────────────────────────────────────────────────────────────┘
```
## Vertiefung: Datenbank-Backups im laufenden Betrieb (Hot-Backups)
Dateibasierte Backups von aktiven Datenbankverzeichnissen (wie `/var/lib/mysql` oder `/var/lib/postgresql`) führen unweigerlich zu inkonsistenten oder korrupten Datenständen, da Schreibzugriffe während des Kopierens stattfinden. Daher nutzen Administratoren native Dump-Werkzeuge:
### 1. MySQL und MariaDB konsistent sichern (`mysqldump`)
```bash
# Transaktionssicherer Dump aller Datenbanken im laufenden Betrieb:
sudo mysqldump --all-databases --single-transaction --quick \
--lock-tables=false | gzip > /backup/db/all_databases_$(date +%Y%m%d).sql.gz
# Einzelne Datenbank wiederherstellen:
gunzip < /backup/db/appdb_20260220.sql.gz | sudo mysql appdb
```
### 2. PostgreSQL konsistent sichern (`pg_dump` und `pg_dumpall`)
```bash
# Alle PostgreSQL-Cluster-Datenbanken sichern:
sudo -u postgres pg_dumpall | gzip > /backup/db/postgres_all_$(date +%Y%m%d).sql.gz
# Einzelne Datenbank im Custom-Format (schnell, parallelisierbar) sichern:
sudo -u postgres pg_dump -Fc mydb -f /backup/db/mydb_$(date +%Y%m%d).dump
# Mit pg_restore wiederherstellen:
sudo -u postgres pg_restore -d mydb /backup/db/mydb_20260220.dump
```
## Vertiefung: Hardlink-Snapshots mit `rsync --link-dest`
Mit dem Schalter `--link-dest` erstellt `rsync` inkrementelle Snapshots, die sich wie vollwertige Vollbackups verhalten, aber nur für geänderte Dateien neuen Festplattenplatz belegen:
```bash
#!/usr/bin/env bash
set -euo pipefail
BACKUP_PATH="/backup/snapshots"
TODAY=$(date +%Y-%m-%d)
YESTERDAY=$(ls -1d $BACKUP_PATH/20* 2>/dev/null | tail -n 1 || true)
mkdir -p "$BACKUP_PATH/$TODAY"
if [ -n "$YESTERDAY" ] && [ -d "$YESTERDAY" ]; then
echo "Verwende $YESTERDAY als Hardlink-Basis..."
rsync -a --delete --link-dest="$YESTERDAY" /var/www/ "$BACKUP_PATH/$TODAY/"
else
echo "Initiales Vollbackup..."
rsync -a /var/www/ "$BACKUP_PATH/$TODAY/"
fi
```
## 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**
```bash
#!/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**
```bash
#!/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**
```bash
#!/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:**
```markdown
┌─────────────────────────────────────────────────────────────┐
│ CRON-SYNTAX ZEITFORMAT │
├─────────────────────────────────────────────────────────────┤
│ │
│ ┌───────────── Minute (0 - 59) │
│ │ ┌───────────── Stunde (0 - 23) │
│ │ │ ┌───────────── Tag des Monats (1 - 31) │
│ │ │ │ ┌───────────── Monat (1 - 12) │
│ │ │ │ │ ┌───────────── Wochentag (0 - 7, 0/7 = Sonntag) │
│ │ │ │ │ │ │
│ * * * * * /pfad/zum/skript.sh │
│ │
└─────────────────────────────────────────────────────────────┘
```
Backup-Cron einrichten:
```bash
# 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:**
```markdown
┌─────────── 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
**Hier ist ein Beispiel für ein Monitoring-Skript:**
```bash
#!/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:**
```markdown
┌─────────── 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**
```bash
# 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**
```bash
# 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:**
```markdown
┌─────────── 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**
```bash
# 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**
```bash
# 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:**
```markdown
┌─────────── Backup-Plan ─────────────────────────────────────┐
│ • Backup-Strategien │
│ • Zeitpläne │
│ • Verantwortlichkeiten │
├─────────── Prozesse ────────────────────────────────────────┤
│ • Backup-Verfahren │
│ • Wiederherstellung │
│ • Notfallplan │
└─────────────────────────────────────────────────────────────┘
```
**Wichtige Dokumentationselemente:**
1. **Backup-Konfiguration**
* Backup-Typen und Zeitpläne
* Speicherorte und Aufbewahrungsfristen
* Verwendete Tools und Skripte
2. **Wiederherstellungsprozesse**
* Schritt-für-Schritt-Anleitungen
* Kontaktpersonen und Zuständigkeiten
* Notfallprozeduren
3. **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:**
```markdown
┌─────────── 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:**
```markdown
┌─────────── 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:**
```markdown
┌─────────── 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:**
```markdown
┌─────────── 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:**
```markdown
┌─────────── Vorbereitung ────────────────────────────────────┐
│ • Backup identifizieren │
│ • Zielverzeichnis prüfen │
│ • Speicherplatz verifizieren │
├─────────── Durchführung ────────────────────────────────────┤
│ • Daten wiederherstellen │
│ • Berechtigungen prüfen │
│ • Integrität testen │
└─────────────────────────────────────────────────────────────┘
```
Daten aus Vollbackup wiederherstellen
```bash
# 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
```bash
# 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:**
```markdown
┌─────────── 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
### 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:**
```markdown
┌─────────── 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` und `HDD`)
* 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:**
```markdown
┌─────────── Symmetrisch ─────────────────────────────────────┐
│ • Ein Schlüssel │
│ • Schnell │
│ • Einfach │
├─────────── Asymmetrisch ────────────────────────────────────┤
│ • Schlüsselpaar │
│ • Sicherer │
│ • Komplexer │
└─────────────────────────────────────────────────────────────┘
```
**a) Backup-Verschlüsselung mit GPG:**
```bash
# 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:**
```bash
# 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:**
```markdown
┌─────────── Kurzfristig ─────────────────────────────────────┐
│ • Tägliche Backups: 7-14 Tage │
│ • Wöchentliche: 4-8 Wochen │
├─────────── Langfristig ─────────────────────────────────────┤
│ • Monatliche: 12-24 Monate │
│ • Jährliche: 5-7 Jahre │
└─────────────────────────────────────────────────────────────┘
```
**Aufbewahrungsrichtlinien:**
1. **Tägliche Backups**
* Für schnelle Wiederherstellung
* 7-14 Tage aufbewahren
* Automatische Rotation
2. **Wöchentliche Backups**
* Für mittelfristige Sicherung
* 4-8 Wochen aufbewahren
* Jeden Sonntag erstellen
3. **Monatliche Backups**
* Für langfristige Archivierung
* 12-24 Monate aufbewahren
* Am Monatsende erstellen
**Implementierung:**
```bash
# 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:**
```markdown
┌─────────── 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:**
```markdown
┌─────────── 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
```bash
# 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
```bash
#!/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
```bash
#!/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
```
## Befehlsreferenz (Cheatsheet)
Für den schnellen Zugriff bei der Planung und Umsetzung von Backup- und Recovery-Prozessen fasst die folgende Referenztabelle die wichtigsten Linux-Kommandos und Werkzeuge zusammen:
| Befehl / Syntax | Werkzeug / Bereich | Funktion & Beschreibung |
|---|---|---|
| `tar -czf archiv.tar.gz /pfad` | tar | Erstellt ein mit gzip komprimiertes Archiv. |
| `tar -xzf archiv.tar.gz -C /ziel` | tar | Entpackt ein gzip-Archiv in ein definiertes Zielverzeichnis. |
| `tar -tvf archiv.tar.gz` | tar | Listet den Inhalt eines Archivs ohne Entpacken auf. |
| `rsync -avz /quelle/ user@host:/ziel/` | rsync | Synchronisiert Verzeichnisse über SSH mit Archiv-Modus und Kompression. |
| `rsync -a --delete /quelle/ /ziel/` | rsync | Synchronisiert Daten und löscht im Ziel nicht mehr vorhandene Dateien. |
| `rsync -a --link-dest=REF /quelle/ /ziel/` | rsync | Erstellt platzsparende Hardlink-Snapshots basierend auf Referenzstand. |
| `dd if=/dev/sda of=/backup/disk.img bs=4M status=progress` | dd | Erstellt ein bit-genaues 1:1 Image eines Datenträgers. |
| `borg init --encryption=repokey /repo` | BorgBackup | Initialisiert ein verschlüsseltes, dedupliziertes Backup-Repository. |
| `borg create /repo::backup-{now} /daten` | BorgBackup | Erstellt ein neues dedupliziertes und verschlüsseltes Backup-Archiv. |
| `restic backup /pfad/zu/daten` | Restic | Sichert Dateien verschlüsselt und inkrementell in ein Restic-Repo. |
| `sha256sum datei.tar.gz > datei.sha256` | Prüfsumme | Berechnet kryptografische SHA-256-Prüfsumme zur Integritätsprüfung. |
| `sha256sum -c datei.sha256` | Prüfsumme | Validiert Prüfsummen gegen gespeicherte Referenzdaten. |
| `mysqldump --all-databases --single-transaction` | Datenbank | Konsistenter Hot-Dump von MySQL/MariaDB ohne Sperrung von Lesetabellen. |
| `pg_dumpall \| gzip > all_db.sql.gz` | Datenbank | Vollständiger PostgreSQL-Dump aller Datenbanken und Rollen. |
| `pg_restore -d dbname dump.dump` | Datenbank | Stellt PostgreSQL-Datenbank aus binärem Custom-Dump wieder her. |
## Weiterführende Ressourcen
Die folgenden Leitfäden, Handbücher und internen Kursmodule vertiefen die behandelten Strategien zur Datensicherung und Systemverwaltung:
| Ressource | Beschreibung |
|---|---|
| [BorgBackup Documentation](https://borgbackup.readthedocs.io/){.badge-link-text} | Offizielle Dokumentation zur deduplizierenden Archivierung mit Borg. |
| [Restic Documentation](https://restic.readthedocs.io/){.badge-link-text} | Offizieller Leitfaden für sichere Cloud- und On-Premises-Backups mit Restic. |
| [GNU Tar Manual](https://www.gnu.org/software/tar/manual/){.badge-link-text} | Vollständiges Referenzhandbuch des GNU-Tar-Archivierungswerkzeugs. |
| [Linux Administration #5: Shell-Scripting](/de/linux-administration/linux-administration-shell-scripting-und-automatisierung){.badge-link-text} | Das vorherige Modul: Shell-Scripting, Traps, Cron und systemd-Timer. |
| [Linux Administration #7: Systemsicherheit](/de/linux-administration/linux-administration-systemsicherheit-und-hartung){.badge-link-text} | Das nachfolgende Modul: SSH-Härtung, Firewalls, Fail2ban und LUKS-Verschlüsselung. |
| [Befehlszeilenprozessor in Linux](/de/linux-neulinge/befehlszeilenprozessor-in-linux){.badge-link-text} | Fundamentales Wissen zu Shells, I/O-Streams, Pipes und Prozessumleitungen. |
## 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 und differentielle Sicherungen bis hin zu Hardlink-Snapshots und Deduplizierung, und kennst ihre jeweiligen Stärken und Herausforderungen.
Die Sicherung und Wiederherstellung von Daten gehört zu den verantwortungsvollsten Aufgaben im Alltag eines Linux-Administrators. Mit dem erworbenen Wissen kannst du eigenständig Backup-Konzepte entwickeln, automatisierte Backup-Pipelines einrichten und im Notfall Daten zielsicher wiederherstellen. Besonders wichtig ist das Verständnis für die verschiedenen Werkzeuge und deren Einsatzmöglichkeiten sowie die Fähigkeit, Backups kontinuierlich zu überwachen und Integritätsprüfungen durchzuführen.
Die praktischen Übungen haben dir gezeigt, wie du ein vollständiges Backup-System aufbaust, verschlüsselte Archive erstellst und mit Monitoring-Skripten absicherst. Eine sorgfältige Dokumentation und regelmäßige Tests stellen sicher, dass du im Ernstfall schnell und gelassen reagieren kannst.
💡 **Praxis-Tipp:** Ein ungetestetes Backup ist kein Backup! Richte einen quartalsweisen Notfall-Test (*Disaster Recovery Drill*) ein, bei dem du ein Backup auf eine frische, isolierte Test-VM zurückspielst und verifizierst, dass alle Dienste und Datenbanken fehlerfrei anlaufen.
Im nächsten Modul unseres Kurses widmen wir uns der Systemhärtung und Abwehr von Cyber-Angriffen:
👉 **Weiter geht es mit:** [Linux Administration #7: Systemsicherheit und Härtung](/de/linux-administration/linux-administration-systemsicherheit-und-hartung){.badge-link-text}
👉 **Zur Kursübersicht:** [Alle Linux-Administrations-Artikel & Module](/de/category/linux-administration){.badge-link-text}