Was ist der Unterschied zwischen rsync und cp fuer Backups?

rsync uebertraegt nur Dateien, die sich geaendert haben (mittels Pruefsummen oder Aenderungszeiten), wodurch nachfolgende Backups drastisch schneller werden. cp kopiert jedes Mal alles, unabhaengig von Aenderungen, und verbraucht mehr Bandbreite, Festplatten-I/O und Zeit.

Kann rsync eine unterbrochene Uebertragung fortsetzen?

Ja, verwende das Flag --partial (oder -P, das --partial und --progress kombiniert). rsync behaelt teilweise uebertragene Dateien bei und setzt beim naechsten Lauf dort fort, wo es aufgehoert hat.

Wie sparen Snapshot-Backups mit --link-dest Speicherplatz?

Mit --link-dest erstellt rsync Hardlinks zu unveraenderten Dateien des vorherigen Backups, anstatt sie erneut zu kopieren. Jeder Snapshot erscheint als vollstaendiges Backup, aber unveraenderte Dateien teilen sich dieselben Festplattenbloecke und verbrauchen nahezu keinen zusaetzlichen Speicherplatz.

Ist rsync sicher fuer Remote-Backups ueber das Internet?

Ja, bei Verwendung von rsync ueber SSH (Standard fuer Remote-Uebertragungen) werden alle Daten waehrend der Uebertragung verschluesselt. Kombiniere dies mit SSH-Schluessel-Authentifizierung und Firewall-Regeln fuer eine vollstaendig sichere Backup-Pipeline.

Rsync-Backup-Strategien fuer Linux-Server

Datenverlust ist keine Frage des Ob, sondern des Wann. Hardware faellt aus, Ransomware verschluesselt und menschliche Fehler loeschen Daten. Der einzige zuverlaessige Schutz ist eine getestete, automatisierte Backup-Strategie. rsync ist eines der leistungsfaehigsten und flexibelsten Werkzeuge unter Linux fuer diesen Zweck — es uebertraegt nur die Unterschiede zwischen Quelle und Ziel, arbeitet nahtlos ueber SSH und unterstuetzt Snapshot-Backups, die wie vollstaendige Kopien aussehen, aber nur einen Bruchteil des Speicherplatzes belegen.

Diese Anleitung behandelt alles, was du brauchst, um eine produktionsreife rsync-Backup-Strategie fuer deine Linux-Server zu entwerfen, zu implementieren und zu automatisieren.

Was ist Rsync?

Rsync (Remote Sync) ist ein schnelles, vielseitiges Dienstprogramm zum Kopieren von Dateien fuer Linux- und Unix-Systeme. Urspruenglich von Andrew Tridgell und Paul Mackerras geschrieben, verwendet es einen Delta-Transfer-Algorithmus, der nur die Unterschiede zwischen den Quelldateien und den vorhandenen Dateien am Zielort sendet. Dadurch ist es deutlich effizienter als Werkzeuge wie cp oder scp fuer wiederkehrende Backups.

Wichtige Eigenschaften:

Delta-Transfers — nur geaenderte Bytes werden uebertragen, nicht ganze Dateien
Erhaltung von Metadaten — Berechtigungen, Eigentuemer, Zeitstempel, symbolische Links
SSH-Integration — verschluesselte Uebertragungen zu Remote-Servern direkt integriert
Hardlink-Unterstuetzung — ermoeglicht speichereffiziente Snapshot-Backups
Flexibles Filtern — Include/Exclude-Muster fuer granulare Kontrolle

# Pruefen, ob rsync installiert ist und welche Version
rsync --version

Falls rsync nicht installiert ist:

# Debian/Ubuntu
sudo apt update && sudo apt install -y rsync

# RHEL/CentOS/Fedora
sudo dnf install -y rsync

Warum Rsync fuer Backups?

Es gibt viele verfuegbare Backup-Werkzeuge — tar, cp, scp, Duplicity, Borg, Restic — warum also rsync waehlen?

Geschwindigkeit: Nach der initialen Vollkopie uebertragen nachfolgende Laeufe nur geaenderte Daten. Ein 500-GB-Backup, bei dem sich 2 GB geaendert haben, dauert Sekunden statt Stunden.
Einfachheit: rsync ist ein einzelner Befehl mit gut dokumentierten Optionen. Kein proprietaeres Format, keine Deduplizierungsdatenbank, die korrumpieren kann.
Transparenz: Backups sind einfache Dateien und Verzeichnisse. Du kannst sie durchsuchen, mit grep filtern und mit Standard-Unix-Werkzeugen wiederherstellen — kein spezielles Wiederherstellungstool noetig.
Universalitaet: rsync ist auf jeder Linux-Distribution, macOS und sogar Windows (ueber WSL oder Cygwin) verfuegbar. Es ist auf den meisten Servern bereits vorinstalliert.
Kombinierbarkeit: rsync laesst sich nahtlos mit cron, systemd-Timern, SSH und Shell-Skripten integrieren.

Der Kompromiss ist, dass rsync keine eingebaute Verschluesselung im Ruhezustand, keine Deduplizierung ueber Backups hinweg und keine Katalogdatenbank bietet. Fuer diese Funktionen solltest du Borg oder Restic in Betracht ziehen. Aber fuer unkomplizierte, zuverlaessige und transparente Backups ist rsync kaum zu schlagen.

Voraussetzungen

Bevor du die Strategien in dieser Anleitung umsetzt, stelle sicher, dass du Folgendes hast:

Zwei Linux-Systeme — einen Quellserver (Produktion) und ein Backup-Ziel (lokale Festplatte, NAS oder Remote-Server)
rsync installiert auf Quelle und Ziel (Version 3.1+ empfohlen)
SSH-Schluessel-Authentifizierung zwischen Quelle und Ziel eingerichtet fuer passwortlose, automatisierte Uebertragungen (siehe unsere SSH-Haertungsanleitung)
Ausreichend Speicherplatz am Ziel — mindestens das 1,5-fache der zu sichernden Datenmenge
Root- oder Sudo-Zugang auf beiden Maschinen, falls du Eigentuemer und spezielle Dateiattribute erhalten musst

# rsync-Version auf beiden Maschinen ueberpruefen
rsync --version | head -1

# Ueberpruefen, ob SSH-Schluessel-Authentifizierung ohne Passwortabfrage funktioniert
ssh -o BatchMode=yes user@backup-server echo "SSH key auth works"

Grundlegende Rsync-Syntax und Optionen

Die allgemeine Syntax von rsync lautet:

rsync [OPTIONEN] QUELLE ZIEL

Das Verstaendnis der wichtigsten Flags ist essenziell, bevor du eine Backup-Strategie aufbaust:

# Archivmodus: erhaelt Berechtigungen, Eigentuemer, Zeitstempel, Symlinks, Geraete
rsync -a /quelle/ /ziel/

# Archiv + ausfuehrlich + lesbare Groessen + Fortschritt
rsync -avhP /quelle/ /ziel/

# Trockenlauf -- zeigt, was uebertragen wuerde, ohne Aenderungen vorzunehmen
rsync -avhn /quelle/ /ziel/

Kritisches Detail: Abschliessende Schraegstriche sind wichtig. /quelle/ (mit Schraegstrich) kopiert den Inhalt des Verzeichnisses. /quelle (ohne Schraegstrich) kopiert das Verzeichnis selbst. Dies ist einer der haeufigsten rsync-Fehler.

# Kopiert den Inhalt von /var/www/ nach /backup/www/
rsync -avh /var/www/ /backup/www/

# Kopiert das Verzeichnis /var/www (als Unterverzeichnis) nach /backup/
# Ergebnis: /backup/www/
rsync -avh /var/www /backup/

Lokale Backups

Die einfachste rsync-Strategie ist ein lokales Backup auf eine separate Festplatte oder Partition. Dies schuetzt vor versehentlichem Loeschen und Dateisystem-Korruption (aber nicht vor einem Hardwareausfall der gesamten Maschine).

# /home auf eine externe Festplatte unter /mnt/backup spiegeln
rsync -avh --delete /home/ /mnt/backup/home/

Das Flag --delete ist wichtig: Es entfernt Dateien vom Ziel, die auf der Quelle nicht mehr existieren, und haelt das Backup als exakten Spiegel. Ohne dieses Flag sammeln sich geloeschte Dateien im Backup unbegrenzt an.

# Mehrere Verzeichnisse in einem Befehl sichern
rsync -avh --delete \
  /etc/ \
  /var/www/ \
  /home/ \
  /mnt/backup/

# Backup mit Logdatei fuer Auditierung
rsync -avh --delete --log-file=/var/log/rsync-backup.log \
  /home/ /mnt/backup/home/

Fuer Backups auf Systemebene, die Geraetedateien und spezielle Attribute einschliessen:

# Vollstaendiges System-Backup (erfordert Root)
sudo rsync -aAXvh --delete \
  --exclude={"/dev/*","/proc/*","/sys/*","/tmp/*","/run/*","/mnt/*","/media/*","/lost+found"} \
  / /mnt/backup/system/

Die Flags -aAX erhalten den Archivmodus (-a), ACLs (-A) und erweiterte Attribute (-X), die fuer ein vollstaendiges System-Backup erforderlich sind.

Remote-Backups ueber SSH

Remote-Backups schuetzen vor lokalem Hardwareausfall, Feuer, Diebstahl und anderen physischen Katastrophen. rsync verwendet SSH als Standardtransport fuer Remote-Uebertragungen und bietet Verschluesselung ohne zusaetzliche Konfiguration.

# Push-Backup: lokale Daten an einen Remote-Server senden
rsync -avhz -e ssh /var/www/ backupuser@192.168.1.100:/backup/www/

# Pull-Backup: Daten von einem Remote-Server lokal abrufen
rsync -avhz -e ssh backupuser@192.168.1.100:/var/www/ /backup/www/

Das Flag -z aktiviert Komprimierung waehrend der Uebertragung, was bei langsameren Netzwerkverbindungen vorteilhaft ist. In einem lokalen Gigabit-Netzwerk kann Komprimierung aufgrund des CPU-Overheads die Uebertragung sogar verlangsamen.

Fuer einen nicht standardmaessigen SSH-Port oder einen bestimmten Schluessel:

# Benutzerdefinierten SSH-Port und Identitaetsdatei verwenden
rsync -avhz -e "ssh -p 2222 -i /home/backupuser/.ssh/backup_key" \
  /var/www/ backupuser@remote:/backup/www/

Fuer automatisierte Backups darf der SSH-Schluessel keine Passphrase haben (oder verwende ssh-agent). Beschraenke den Backup-Schluessel auf dem Remote-Server, um seine Faehigkeiten einzugrenzen:

# Auf dem Remote-Server, in ~backupuser/.ssh/authorized_keys:
# Schluessel auf rsync beschraenken
command="rsync --server --sender -vlogDtprze.iLsfxCIvu . /backup/",no-port-forwarding,no-X11-forwarding,no-agent-forwarding ssh-ed25519 AAAAC3Nz... backup@source

Inkrementelle Backups mit —link-dest (Snapshot-Stil)

Dies ist die leistungsfaehigste rsync-Backup-Strategie. Mit --link-dest kannst du taeglich scheinbar vollstaendige Backups erstellen, wobei nur geaenderte Dateien zusaetzlichen Speicherplatz belegen. Unveraenderte Dateien werden per Hardlink mit dem vorherigen Backup verknuepft.

So funktioniert es:

rsync vergleicht jede Quelldatei mit der entsprechenden Datei im --link-dest-Verzeichnis
Ist eine Datei unveraendert, erstellt rsync einen Hardlink (null zusaetzlicher Speicherplatz)
Ist eine Datei geaendert oder neu, kopiert rsync sie normal
Das Ergebnis ist ein Verzeichnis, das wie ein vollstaendiges Backup aussieht und sich so verhaelt

# Snapshot-Backup erstellen
DATE=$(date +%Y-%m-%d_%H-%M-%S)
DEST="/backup/snapshots/$DATE"
LATEST="/backup/snapshots/latest"

rsync -avh --delete \
  --link-dest="$LATEST" \
  /home/ "$DEST/"

# Den Symlink "latest" aktualisieren
rm -f "$LATEST"
ln -s "$DEST" "$LATEST"

Der Speicherverbrauch ist bemerkenswert. Betrachte einen 100-GB-Datensatz, bei dem sich taeglich 1 % aendert:

Tag	Scheinbare Groesse	Tatsaechlicher Speicherverbrauch
Tag 1 (vollstaendig)	100 GB	100 GB
Tag 2	100 GB	~1 GB (nur neue Daten)
Tag 3	100 GB	~1 GB
30 Tage gesamt	3.000 GB scheinbar	~129 GB tatsaechlich

Jedes Snapshot-Verzeichnis ist mit Standard-Werkzeugen vollstaendig durchsuchbar. Du kannst mit cd in das Backup eines beliebigen Tages wechseln und den vollstaendigen Zustand deiner Dateien zu diesem Zeitpunkt einsehen.

# Backup von vor 5 Tagen durchsuchen
ls /backup/snapshots/2026-01-17_02-00-00/home/jc/documents/

# Eine bestimmte Datei von vor 3 Tagen wiederherstellen
cp /backup/snapshots/2026-01-19_02-00-00/home/jc/report.pdf /home/jc/report.pdf

# Tatsaechlichen Speicherverbrauch pro Snapshot pruefen (zeigt nur einzigartige Daten)
du -sh /backup/snapshots/*/

Ausschlussmuster und Filter

Nicht alles muss gesichert werden. Das Ausschliessen von temporaeren Dateien, Caches und Build-Artefakten spart Zeit und Speicherplatz.

# Ausschlussmuster inline
rsync -avh --delete \
  --exclude='*.tmp' \
  --exclude='*.log' \
  --exclude='.cache/' \
  --exclude='node_modules/' \
  --exclude='__pycache__/' \
  /home/ /backup/home/

Fuer komplexe Ausschlussregeln verwende eine Ausschlussdatei:

# Datei /etc/rsync-excludes.txt erstellen
cat > /etc/rsync-excludes.txt << 'EOF'
# Temporaere Dateien und Cache
*.tmp
*.swp
*.swo
*~
.cache/
.thumbnails/

# Build-Artefakte
node_modules/
vendor/
__pycache__/
*.pyc
target/
build/
dist/

# Systemdateien, die nicht gesichert werden sollen
/proc/
/sys/
/dev/
/run/
/tmp/
/mnt/
/media/
/lost+found/

# Grosse Mediendateien (optional)
# *.iso
# *.mp4
EOF

# Die Ausschlussdatei verwenden
rsync -avh --delete --exclude-from=/etc/rsync-excludes.txt \
  /home/ /backup/home/

rsync unterstuetzt auch Include/Exclude-Kombinationen fuer eine feinere Steuerung:

# Nur .conf- und .sh-Dateien aus /etc sichern
rsync -avh \
  --include='*/' \
  --include='*.conf' \
  --include='*.sh' \
  --exclude='*' \
  /etc/ /backup/etc-configs/

Bandbreitenbegrenzung und Komprimierung

Beim Sichern ueber ein WAN oder eine gemeinsam genutzte Netzwerkverbindung musst du kontrollieren, wie viel Bandbreite rsync verbraucht, um den Produktionsbetrieb nicht zu beeintraechtigen.

# Bandbreite auf 5 MB/s begrenzen (Wert in KB/s)
rsync -avhz --bwlimit=5000 -e ssh \
  /var/www/ backupuser@remote:/backup/www/

# Auf 10 Mbps begrenzen (~1250 KB/s)
rsync -avhz --bwlimit=1250 -e ssh \
  /var/www/ backupuser@remote:/backup/www/

Komprimierungsoptionen:

# Transfer-Komprimierung aktivieren (nuetzlich bei langsamen Verbindungen)
rsync -avhz -e ssh /source/ user@remote:/backup/

# Komprimierung fuer bereits komprimierte Dateien ueberspringen
rsync -avh --compress --skip-compress=gz/bz2/zip/7z/jpg/png/mp4/mkv \
  -e ssh /source/ user@remote:/backup/

Fuer SSH-seitige Komprimierung (Alternative zu rsync’s -z):

# SSH-Komprimierung anstelle von rsync-Komprimierung verwenden
rsync -avh -e "ssh -C" /source/ user@remote:/backup/

Tipp: Aktiviere nicht gleichzeitig rsync-Komprimierung (-z) und SSH-Komprimierung (-C). Doppelte Komprimierung verschwendet CPU-Zyklen und kann die Uebertragungsgroesse sogar erhoehen. Verwende eine von beiden — rsync’s -z ist in der Regel effizienter, da es pro Datei komprimiert.

Automatisiertes Backup-Skript mit Cron

Ein vollstaendiges Backup-Skript sollte Logging, Fehlerberichterstattung, Snapshot-Rotation und E-Mail-Benachrichtigungen umfassen. Hier ist ein produktionsreifes Beispiel:

#!/usr/bin/env bash
# /usr/local/bin/rsync-backup.sh
# Snapshot-basiertes rsync-Backup mit Rotation und Logging

set -euo pipefail

# --- Konfiguration --------------------------------------------------------
SOURCE="/home/"
BACKUP_ROOT="/backup/snapshots"
REMOTE_USER="backupuser"
REMOTE_HOST="192.168.1.100"
REMOTE_DEST="${REMOTE_USER}@${REMOTE_HOST}:${BACKUP_ROOT}"
SSH_KEY="/root/.ssh/backup_ed25519"
EXCLUDE_FILE="/etc/rsync-excludes.txt"
LOG_DIR="/var/log/rsync-backup"
RETENTION_DAYS=30
BWLIMIT=0  # 0 = unbegrenzt, oder KB/s festlegen

# --- Abgeleitete Variablen ------------------------------------------------
DATE=$(date +%Y-%m-%d_%H-%M-%S)
DEST="${BACKUP_ROOT}/${DATE}"
LATEST="${BACKUP_ROOT}/latest"
LOG_FILE="${LOG_DIR}/backup-${DATE}.log"
LOCK_FILE="/tmp/rsync-backup.lock"

# --- Funktionen -----------------------------------------------------------
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $1" | tee -a "$LOG_FILE"
}

cleanup() {
    rm -f "$LOCK_FILE"
    log "Lock file removed."
}

# --- Vorabpruefungen ------------------------------------------------------
mkdir -p "$LOG_DIR" "$BACKUP_ROOT"

# Gleichzeitige Ausfuehrungen verhindern
if [ -f "$LOCK_FILE" ]; then
    echo "Backup already running (lock file exists). Exiting."
    exit 1
fi
trap cleanup EXIT
touch "$LOCK_FILE"

log "=== Backup started ==="
log "Source: $SOURCE"
log "Destination: $DEST"

# --- rsync ausfuehren -----------------------------------------------------
RSYNC_OPTS=(
    -avh
    --delete
    --numeric-ids
    --log-file="$LOG_FILE"
)

[ -f "$EXCLUDE_FILE" ] && RSYNC_OPTS+=(--exclude-from="$EXCLUDE_FILE")
[ "$BWLIMIT" -gt 0 ] 2>/dev/null && RSYNC_OPTS+=(--bwlimit="$BWLIMIT")
[ -L "$LATEST" ] && RSYNC_OPTS+=(--link-dest="$LATEST")

if rsync "${RSYNC_OPTS[@]}" "$SOURCE" "$DEST/"; then
    log "rsync completed successfully."
else
    RSYNC_EXIT=$?
    log "ERROR: rsync exited with code $RSYNC_EXIT"
    # Benachrichtigung senden (auskommentieren und konfigurieren)
    # echo "Backup failed with exit code $RSYNC_EXIT" | mail -s "Backup FAILED" admin@example.com
    exit $RSYNC_EXIT
fi

# --- Symlink "latest" aktualisieren ---------------------------------------
rm -f "$LATEST"
ln -s "$DEST" "$LATEST"
log "Updated 'latest' symlink to $DEST"

# --- Alte Backups rotieren -------------------------------------------------
log "Removing backups older than $RETENTION_DAYS days..."
find "$BACKUP_ROOT" -maxdepth 1 -type d -name "20*" -mtime +$RETENTION_DAYS -exec rm -rf {} \;
log "Rotation complete."

# --- Speicherverbrauchsbericht ---------------------------------------------
USAGE=$(du -sh "$BACKUP_ROOT" | cut -f1)
log "Total backup storage used: $USAGE"

log "=== Backup finished ==="

Mache das Skript ausfuehrbar und plane es mit cron:

# Ausfuehrbar machen
sudo chmod +x /usr/local/bin/rsync-backup.sh

# Root-Crontab bearbeiten
sudo crontab -e

Fuege folgenden Cron-Eintrag hinzu:

# Backup taeglich um 2:00 Uhr ausfuehren
0 2 * * * /usr/local/bin/rsync-backup.sh >> /var/log/rsync-backup/cron.log 2>&1

# Backup alle 6 Stunden ausfuehren
0 */6 * * * /usr/local/bin/rsync-backup.sh >> /var/log/rsync-backup/cron.log 2>&1

Alternativ kannst du einen systemd-Timer fuer eine robustere Planung verwenden:

# /etc/systemd/system/rsync-backup.service
[Unit]
Description=Rsync Backup Service
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/rsync-backup.sh
Nice=10
IOSchedulingClass=idle

# /etc/systemd/system/rsync-backup.timer
[Unit]
Description=Run Rsync Backup Daily

[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true
RandomizedDelaySec=300

[Install]
WantedBy=timers.target

# Timer aktivieren und starten
sudo systemctl daemon-reload
sudo systemctl enable --now rsync-backup.timer

# Timer-Status ueberpruefen
systemctl list-timers rsync-backup.timer

Wiederherstellung aus Backups

Ein Backup ist nur nuetzlich, wenn du daraus wiederherstellen kannst. Da rsync-Backups einfache Dateien und Verzeichnisse sind, ist die Wiederherstellung unkompliziert.

Eine einzelne Datei wiederherstellen

# Die Datei in einem bestimmten Snapshot finden
ls -la /backup/snapshots/2026-01-20_02-00-00/home/jc/documents/report.pdf

# Wiederherstellen
cp /backup/snapshots/2026-01-20_02-00-00/home/jc/documents/report.pdf \
   /home/jc/documents/report.pdf

Ein komplettes Verzeichnis wiederherstellen

# Ein vollstaendiges Verzeichnis aus dem letzten Backup wiederherstellen
rsync -avh /backup/snapshots/latest/var/www/ /var/www/

Vollstaendige Systemwiederherstellung

# Das gesamte System wiederherstellen (von einem Live-USB oder einer Rettungsumgebung)
sudo rsync -aAXvh --delete \
  --exclude={"/dev/*","/proc/*","/sys/*","/tmp/*","/run/*","/mnt/*","/media/*","/lost+found"} \
  /mnt/backup/system/ /mnt/target/

Von einem Remote-Backup wiederherstellen

# Dateien vom Remote-Backup-Server abrufen
rsync -avhz -e "ssh -i /root/.ssh/backup_ed25519" \
  backupuser@192.168.1.100:/backup/snapshots/latest/var/www/ \
  /var/www/

Wichtig: Fuehre vor der Wiederherstellung immer einen Trockenlauf mit --dry-run (oder -n) durch, insbesondere bei vollstaendigen Systemwiederherstellungen. Dies zeigt dir genau, was geaendert wird, ohne etwas zu modifizieren.

# Trockenlauf -- Vorschau, was die Wiederherstellung bewirken wuerde
rsync -avhn /backup/snapshots/latest/home/ /home/

Backup-Integritaet ueberpruefen

Backups, die du nicht ueberpruefst, sind Backups, denen du nicht vertrauen kannst. Plane regelmaessige Integritaetspruefungen ein.

# Quelle und Backup mittels Pruefsummen vergleichen (uebertraegt keine Daten)
rsync -avnc /home/ /backup/snapshots/latest/home/

# Das Flag -c erzwingt einen Pruefsummenvergleich statt Groesse+Zeitstempel
# -n stellt sicher, dass nichts uebertragen wird (Trockenlauf)

Wenn die Ausgabe keine Unterschiede zeigt, ist das Backup eine exakte Kopie. Abweichungen werden mit ihren Pfaden aufgelistet.

Fuer automatisierte Verifizierung fuege eine Pruefung zu deinem Backup-Skript hinzu:

# Nachtraegliche Backup-Verifizierung
log "Running integrity verification..."
DIFF_COUNT=$(rsync -anc --delete "$SOURCE" "$DEST/" 2>/dev/null | wc -l)
if [ "$DIFF_COUNT" -le 1 ]; then
    log "Verification PASSED: backup matches source."
else
    log "WARNING: $DIFF_COUNT differences found between source and backup."
fi

Referenztabelle der Rsync-Optionen

Option	Beschreibung
`-a`	Archivmodus: entspricht `-rlptgoD` (rekursiv, Links, Berechtigungen, Zeiten, Gruppe, Eigentuemer, Geraete)
`-v`	Ausfuehrliche Ausgabe
`-h`	Menschenlesbare Dateigroessen
`-z`	Daten waehrend der Uebertragung komprimieren
`-P`	Entspricht `--partial --progress` (teilweise Uebertragungen fortsetzen + Fortschritt anzeigen)
`-n`	Trockenlauf — zeigt, was uebertragen wuerde, ohne Aenderungen vorzunehmen
`-c`	Pruefsummen anstelle von Aenderungszeit + Groesse zur Erkennung von Aenderungen verwenden
`--delete`	Dateien am Ziel loeschen, die auf der Quelle nicht mehr existieren
`--delete-after`	Nach Abschluss der Uebertragung loeschen (sicherer als Standard `--delete-during`)
`--link-dest=DIR`	Unveraenderte Dateien aus DIR per Hardlink verknuepfen (fuer Snapshot-Backups)
`--exclude=MUSTER`	Dateien ausschliessen, die MUSTER entsprechen
`--exclude-from=DATEI`	Ausschlussmuster aus DATEI lesen
`--include=MUSTER`	Dateien einschliessen, die MUSTER entsprechen (ueberschreibt Ausschluss)
`--bwlimit=KBPS`	Bandbreite in Kilobyte pro Sekunde begrenzen
`-e "ssh ..."`	Remote-Shell und deren Optionen angeben
`--numeric-ids`	Numerische UID/GID beibehalten (wichtig fuer maschinenuebergreifende Backups)
`--log-file=DATEI`	Detailliertes Uebertragungsprotokoll in DATEI schreiben
`--partial`	Teilweise uebertragene Dateien fuer Fortsetzung behalten
`--stats`	Uebertragungsstatistiken am Ende ausgeben
`--progress`	Uebertragungsfortschritt pro Datei anzeigen
`--backup`	Backups von ueberschriebenen/geloeschten Dateien erstellen (mit `--backup-dir`)
`--timeout=SEKUNDEN`	I/O-Timeout in Sekunden festlegen

Fehlerbehebung

rsync: connection unexpectedly closed

Dies deutet normalerweise auf ein SSH-Problem hin. Debugge mit:

# Zuerst SSH-Verbindung testen
ssh -v backupuser@remote echo "Connection works"

# rsync mit SSH-Debug-Ausgabe ausfuehren
rsync -avhz -e "ssh -vvv" /source/ user@remote:/backup/

Haeufige Ursachen: Firewall blockiert den SSH-Port, falscher SSH-Schluesselpfad, SSH-Schluessel mit Passphrase, aber kein laufender ssh-agent.

Zugriffsverweigerungsfehler

# rsync als Root fuer vollstaendige System-Backups ausfuehren
sudo rsync -aAXvh /source/ /backup/

# Oder --no-owner --no-group verwenden, wenn Eigentuemer nicht erhalten bleiben muessen
rsync -avh --no-owner --no-group /source/ /backup/

rsync: —link-dest arg does not exist

Stelle sicher, dass der --link-dest-Pfad absolut und zugaenglich ist:

# Falsch: relativer Pfad
rsync --link-dest=../latest ...

# Richtig: absoluter Pfad
rsync --link-dest=/backup/snapshots/latest ...

Das Backup dauert zu lange

# Identifizieren, was uebertragen wird
rsync -avh --progress --stats /source/ /backup/ 2>&1 | tail -20

# Grosse unnoetige Dateien ausschliessen
rsync -avh --exclude='*.iso' --exclude='*.vmdk' /source/ /backup/

Speicherplatz am Ziel wird knapp

# Speicherverbrauch pro Snapshot pruefen
du -sh /backup/snapshots/*/

# Alte Snapshots manuell entfernen
rm -rf /backup/snapshots/2026-01-01_02-00-00

# Hardlink-Zaehler pruefen (hoher Zaehler bedeutet gute Deduplizierung)
stat /backup/snapshots/latest/some-file

rsync haengt oder stockt bei grossen Dateien

# Timeout setzen, um unbegrenztes Haengen zu verhindern
rsync -avh --timeout=300 --partial /source/ /backup/

Zusammenfassung

Eine durchdachte rsync-Backup-Strategie bietet zuverlaessigen, speichereffizienten und transparenten Datenschutz fuer deine Linux-Server. Die wichtigsten Komponenten sind:

Lokale Backups fuer schnelle Wiederherstellung nach versehentlichem Loeschen
Remote-Backups ueber SSH fuer Disaster Recovery
Inkrementelle Snapshot-Backups mit --link-dest fuer speichereffiziente Versionierung
Ausschlussdateien zum Ueberspringen von Caches, temporaeren Dateien und Build-Artefakten
Automatisierte Planung mit cron oder systemd-Timern
Regelmaessige Verifizierung zur Sicherstellung der Backup-Integritaet
Getestete Wiederherstellungsverfahren — ein Backup, das du nicht getestet hast, ist kein Backup

Kombiniere diese rsync-Backup-Strategie mit der SSH-Haertung, um die Transportschicht abzusichern, und folge der Sicherheitscheckliste fuer Linux-Server, um die Server selbst zu schuetzen. Zusammen bilden diese Praktiken eine solide Grundlage fuer Serveradministration und Disaster Recovery.