Linux Administration #6: Datensicherung und Wiederherstellung

Willkommen zum sechsten Teil unserer technischen Wiki-Serie über Linux-Administration!

Nachdem wir in den vorherigen Artikeln die Grundlagen, die Prozessverwaltung und Shell-Scripting 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:
┌─────────── 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
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:
┌─── 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

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:
┌─────────── 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


# 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
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


# 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

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

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 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:
┌─────────── 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!