Backups mit rsync — Dein Home-Verzeichnis automatisch sichern

rsync ist das Standardwerkzeug fuer Datei-Backups unter Linux. Es kopiert nicht einfach alles von A nach B — es uebertraegt nur das, was sich seit dem letzten Lauf geaendert hat. Das macht es schnell genug fuer taegliche automatische Backups, auch ueber Netzwerkverbindungen. Dieser Artikel zeigt dir, wie du dein Home-Verzeichnis auf eine externe Festplatte oder ein NAS sicherst, sinnvolle Excludes setzt und das Ganze mit einem Script und Cron vollautomatisch laufen laesst.

Warum Backups? Und warum jetzt?

Festplatten fallen aus — ohne Vorwarnung. SSDs sind nicht zuverlaessiger, nur schneller im Sterben: Laut Backblaze-Analyse liegt die jaehrliche Ausfallrate bei HDDs grob zwischen 1–4 %, bei SSDs typischerweise unter 1 % (Orientierungswerte — stark abhaengig von Modell und Betriebsdauer). Beide Werte steigen deutlich ab Jahr drei der Nutzung. Neben Hardware-Fehlern gibt es drei weitere Szenarien, die regelmaessig Daten vernichten: versehentliches rm -rf im falschen Verzeichnis, ein Systemabsturz waehrend des Schreibens, und Ransomware, die mittlerweile auch Linux-Systeme aktiv befaellt.

Ich habe 2011 eine Festplatte verloren. Fotos, Projekte, Config-Dateien — weg. Seitdem bin ich bei Backups penibel. Die 3-2-1-Regel ist der Industriestandard fuer sinnvolle Backup-Strategie:

• 3 Kopien der Daten insgesamt (Original + zwei Backups)
• 2 verschiedene Medientypen (z.B. interne SSD + externe Festplatte)
• 1 Kopie an einem anderen physischen Ort (NAS, Cloud, bei Freunden)

Ein einzelnes Backup auf einer externen Festplatte, die neben dem Laptop liegt, schuetzt vor Software-Fehlern — aber nicht vor Einbruch, Brand oder Wasserrohrbruch. Deshalb liegt bei mir eine Kopie verschluesselt auf dem NAS und eine zweite offline bei Verwandten. rsync hilft dir, mindestens zwei der drei Ebenen abzudecken: lokal auf USB und remote auf NAS oder Server.

rsync Grundlagen: Syntax und die wichtigsten Flags

rsync steht fuer „remote sync“ und ist auf praktisch jedem Linux-System vorinstalliert. Es arbeitet inkrementell: Beim ersten Lauf kopiert es alles, danach nur noch Dateien, die neu sind oder sich geaendert haben. Aenderungen erkennt rsync standardmaessig anhand von Dateigroesse und Zeitstempel — nicht anhand des Inhalts, was den Prozess sehr schnell macht. Fuer groessere Aenderungen kann rsync auch den sogenannten Delta-Transfer nutzen: Es uebertraegt nur die veraenderten Bloecke innerhalb einer Datei, nicht die gesamte Datei neu.

Die Grundsyntax:

rsync [OPTIONEN] QUELLE ZIEL

Quelle und Ziel koennen lokale Pfade oder Remote-Adressen (user@host:/pfad) sein. Ein abschliessender / bei der Quelle ist entscheidend:

# OHNE abschliessenden Slash — kopiert das Verzeichnis selbst:
$ rsync -a /home/gunter /mnt/backup/
# Ergebnis: /mnt/backup/gunter/

# MIT abschliessendem Slash — kopiert den Inhalt:
$ rsync -a /home/gunter/ /mnt/backup/
# Ergebnis: /mnt/backup/Dokumente, /mnt/backup/Downloads ...

Die wichtigsten Flags im Ueberblick:

• -a (archive): Kombiniert -r (rekursiv), -l (Symlinks erhalten), -p (Berechtigungen), -t (Zeitstempel), -g (Gruppe), -o (Eigentuemer), -D (Geraetedateien). Fast immer sinnvoll.
• -v (verbose): Zeigt jede uebertragene Datei an.
• -h (human-readable): Gibt Dateigroessen lesbar aus (KB, MB statt Bytes).
• --progress: Fortschrittsanzeige pro Datei waehrend der Uebertragung.
• --delete: Loescht Dateien im Ziel, die in der Quelle nicht mehr existieren. Macht aus rsync einen echten Spiegel — Vorsicht.
• --dry-run (oder -n): Simuliert den Lauf ohne etwas zu veraendern. Immer erst testen.
• --exclude: Schliesst Dateien oder Verzeichnisse von der Uebertragung aus.
• -z (compress): Komprimiert Daten waehrend der Uebertragung. Sinnvoll bei langsamen Netzwerken, unnotig bei lokalen Backups.

Ein typischer erster Testlauf:

$ rsync -avh --dry-run /home/gunter/ /mnt/usb-backup/
sending incremental file list
./
Dokumente/
Dokumente/steuern-2025.pdf
Downloads/
Downloads/ubuntu-24.04-desktop.iso
.bashrc
.bash_history

sent 12,45K bytes  received 523 bytes  25,95K bytes/sec
total size is 48,23G  speedup is 3.777,42 (DRY RUN)

Die letzte Zeile der rsync-Ausgabe ist aufschlussreich: total size zeigt den gesamten Datenbestand, speedup das Verhaeltnis zwischen gesamt und tatsaechlich uebertragen — bei inkrementellen Laeufen steigt dieser Wert stark, weil kaum Daten uebertragen werden muessen.

Lokales Backup: Home auf externe Festplatte

Das haeufigste Szenario: externe USB-Festplatte, die Linux als /media/ oder /mnt/ einhaengt. Unter Ubuntu und Mint erscheint ein eingestecktes Laufwerk automatisch unter /media/BENUTZERNAME/LABEL/. Den genauen Pfad findest du mit:

$ lsblk -f
NAME   FSTYPE LABEL       UUID                                 MOUNTPOINTS
sda    ext4               ...                                  /
sdb    ext4   usb-backup  a1b2c3d4-...                        /media/gunter/usb-backup

Backup starten:

$ rsync -avh --progress --delete     /home/gunter/     /media/gunter/usb-backup/home-backup/

sending incremental file list
Dokumente/steuern-2025.pdf
        2,34M 100%    8,21MB/s    0:00:00 (xfr#1, to-chk=847/1.203)
Downloads/linux-kernel-6.12.tar.gz
        1,23G 100%   45,67MB/s    0:00:27 (xfr#2, to-chk=845/1.203)
...
sent 3,41G bytes  received 124,32K bytes  42,58MB/s
total size is 48,23G  speedup is 14,12

Fuer den ersten vollstaendigen Lauf rechne mit einigen Minuten bis Stunden, je nach Datenmenge. Folgelaufe dauern typischerweise unter einer Minute, wenn sich wenig geaendert hat.

Willst du mehrere Backup-Versionen aufbewahren (nicht nur den aktuellen Stand), hilft --backup mit --backup-dir:

# Geaenderte Dateien nicht ueberschreiben, sondern in dated-Ordner verschieben:
$ rsync -avh --delete     --backup     --backup-dir="/media/gunter/usb-backup/versionen/$(date +%Y-%m-%d)"     /home/gunter/     /media/gunter/usb-backup/aktuell/

Damit liegt das aktuelle Backup immer in aktuell/, aeltere Versionen geaenderter Dateien wandern nach versionen/2026-04-08/ usw. Speicherplatz wird nur fuer tatsaechlich geaenderte Dateien verbraucht, nicht fuer den vollstaendigen Snapshot.

Backup auf NAS oder Server: rsync ueber SSH

rsync uebertraegt Daten verschluesselt ueber SSH, wenn du -e ssh angibst. Das Ziel ist dann eine SSH-Adresse im Format user@host:/pfad. Das funktioniert genauso wie lokale Backups, nur dass die Daten ueber das Netzwerk laufen.

# Einmalige Sicherung auf NAS (IP: 192.168.1.100):
$ rsync -avzh --progress --delete     -e ssh     /home/gunter/     [email protected]:/volume1/backups/gunter-home/

Das -z (compress) ist bei Netzwerkertraegungen sinnvoll — bei Textdateien spart es 60–80 % Bandbreite, bei bereits komprimierten Formaten (JPEG, MP4, zip) kaum etwas.

Fuer automatisierte Backups musst du SSH-Key-Authentifizierung einrichten — sonst fragt rsync jedes Mal nach dem Passwort, was einen Cron-Job blockiert. Schluesselpaar anlegen und auf den Server kopieren:

# Schluesselpaar generieren (Ed25519 ist moderner als RSA):
$ ssh-keygen -t ed25519 -C "rsync-backup-gunter" -f ~/.ssh/id_backup

# Oeffentlichen Schluessel auf den Server/NAS kopieren:
$ ssh-copy-id -i ~/.ssh/id_backup.pub [email protected]

# Verbindung testen (sollte ohne Passwort-Abfrage klappen):
$ ssh -i ~/.ssh/id_backup [email protected] "echo Verbindung OK"
Verbindung OK

rsync dann mit dem spezifischen Key aufrufen:

$ rsync -avzh --delete     -e "ssh -i /home/gunter/.ssh/id_backup"     /home/gunter/     [email protected]:/volume1/backups/gunter-home/

Excludes sinnvoll setzen

Nicht jede Datei im Home-Verzeichnis verdient Backup-Speicherplatz. Caches, Trash und temporaere Download-Daten lassen sich neu erstellen — sie mitzusichern kostet Zeit und Platz ohne Gegenwert. Ein typisches Home-Verzeichnis unter Ubuntu 24.04 enthaelt allein in .cache/ leicht 2–10 GB an regenerierbaren Daten.

Excludes ueber eine Datei definieren ist uebersichtlicher als viele --exclude-Flags:

# Datei anlegen:
$ mkdir -p ~/.config/rsync
$ nano ~/.config/rsync/backup-excludes.txt

# Inhalt:
.cache/
.local/share/Trash/
.local/share/recently-used.xbel
.thumbnails/
.mozilla/firefox/*/cache2/
.config/google-chrome/*/Cache/
.config/BraveSoftware/Brave-Browser/*/Cache/
snap/*/common/.cache/
.steam/steam/steamapps/downloading/
.steam/steam/steamapps/temp/
Downloads/*.part
*.tmp
*~
.xsession-errors

rsync einschliesslich Exclude-Datei aufrufen:

$ rsync -avh --delete     --exclude-from="$HOME/.config/rsync/backup-excludes.txt"     /home/gunter/     /media/gunter/usb-backup/home-backup/

Drei Faustregeln fuer Excludes:

• Alles unter .cache/ ist regenerierbar — immer ausschliessen.
• Steam-Spiele (unter .steam/steamapps/common/) koennen mehrere hundert Gigabyte ausmachen. Ausschliessen und bei Bedarf ueber Steam neu herunterladen.
• Browser-Profile sichern ja, Browser-Caches nein: .mozilla/firefox/*/ sichern, aber .mozilla/firefox/*/cache2/ ausschliessen.

Mit --dry-run und -v siehst du vorab, welche Dateien beruecksichtigt werden und welche durch die Excludes herausfallen. Das hilft, Tippfehler in Muster-Pfaden schnell zu entdecken.

Backup-Script: automatisiert mit Logging und Fehlerpruefung

Ein einmaliger rsync-Befehl schuetzt genau einmal. Nuetzlich wird ein Backup erst, wenn es regelmaessig und automatisch laeuft. Das folgende Script sichert das Home-Verzeichnis, schreibt ein Log mit Zeitstempel und gibt bei Fehler einen Hinweis aus.

#!/bin/bash
# backup-home.sh — rsync-Backup fuer Home-Verzeichnis
# Ablage: ~/.local/bin/backup-home.sh
# Ausfuehrbar machen: chmod +x ~/.local/bin/backup-home.sh

set -euo pipefail

# ---- Konfiguration ----------------------------------------
QUELLE="$HOME/"
ZIEL="/media/gunter/usb-backup/home-backup"
EXCLUDES="$HOME/.config/rsync/backup-excludes.txt"
LOG_DIR="$HOME/.local/share/backup-logs"
LOG_DATEI="$LOG_DIR/backup-$(date +%Y-%m-%d).log"
# -----------------------------------------------------------

# Log-Verzeichnis anlegen falls nicht vorhanden:
mkdir -p "$LOG_DIR"

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

# Ziel erreichbar?
if [[ ! -d "$ZIEL" ]]; then
    log "FEHLER: Zielverzeichnis nicht erreichbar: $ZIEL"
    log "Ist die externe Festplatte eingesteckt und eingehaengt?"
    exit 1
fi

log "=== Backup gestartet ==="
log "Quelle: $QUELLE"
log "Ziel:   $ZIEL"

# rsync ausfuehren, Ausgabe ins Log schreiben:
rsync -avh --delete     --exclude-from="$EXCLUDES"     --log-file="$LOG_DATEI"     "$QUELLE"     "$ZIEL"

EXIT_CODE=$?

if [[ $EXIT_CODE -eq 0 ]]; then
    log "=== Backup erfolgreich abgeschlossen ==="
else
    log "=== FEHLER: rsync beendet mit Exit-Code $EXIT_CODE ==="
    exit $EXIT_CODE
fi

Script testen:

$ chmod +x ~/.local/bin/backup-home.sh

# Syntax pruefen:
$ bash -n ~/.local/bin/backup-home.sh

# Ersten Lauf starten:
$ ~/.local/bin/backup-home.sh

# Log anschauen:
$ tail -20 ~/.local/share/backup-logs/backup-2026-04-08.log
[2026-04-08 13:30:15] === Backup gestartet ===
[2026-04-08 13:30:15] Quelle: /home/gunter/
[2026-04-08 13:30:15] Ziel:   /media/gunter/usb-backup/home-backup
[2026-04-08 13:30:47] === Backup erfolgreich abgeschlossen ===

rsync gibt definierte Exit-Codes zurueck. Die haeufigsten: 0 (Erfolg), 11 (Fehler beim Schreiben, z.B. Zieldatentraeger voll), 23 (einige Dateien konnten nicht uebertragen werden), 24 (Quelldatei waehrend Uebertragung verschwunden — meist harmlos). Das Script protokolliert den Exit-Code und bricht bei Fehler sauber ab.

Fuer die Zeitsteuerung — taeglich um 2 Uhr nachts, immer wenn das System laeuft — ist Cron zustaendig. Wie du einen Cron-Job einrichtest, zeigt der Artikel Cron-Jobs: Aufgaben automatisch ausfuehren. Dort findest du auch, wie du Cron so konfigurierst, dass es sich bei fehlgeschlagenem Backup per E-Mail meldet.

Fuer Laptops, die nicht rund um die Uhr laufen, sind systemd-Timer mit Persistent=true besser geeignet als Cron — sie holen einen verpassten Lauf beim naechsten Start nach. Fuer Laptops ist das ein Muss — ich bin von Cron auf systemd-Timer umgestiegen und habe seitdem kein verpasstes Backup mehr gehabt. Das Grundprinzip fuer den Script-Aufruf bleibt aber identisch.

Wiederherstellen: Daten aus dem Backup zurueckholen

rsync funktioniert in beide Richtungen — Quelle und Ziel einfach tauschen:

# Komplettes Home aus Backup wiederherstellen:
$ rsync -avh     /media/gunter/usb-backup/home-backup/     /home/gunter/

# Dry-run zuerst — pruefen, was ueberschrieben wuerde:
$ rsync -avh --dry-run     /media/gunter/usb-backup/home-backup/     /home/gunter/

Einzelne Dateien oder Ordner wiederherstellen:

# Nur Dokumente-Ordner wiederherstellen:
$ rsync -avh     /media/gunter/usb-backup/home-backup/Dokumente/     /home/gunter/Dokumente/

# Eine einzelne Datei:
$ rsync -avh     /media/gunter/usb-backup/home-backup/Dokumente/steuern-2025.pdf     /home/gunter/Dokumente/steuern-2025.pdf

Bei der Wiederherstellung auf ein frisches System musst du Root-Rechte haben, damit rsync die originalen Eigentuemer und Berechtigungen wiederherstellen kann:

# Als Root wiederherstellen (erhaelt uid/gid korrekt):
$ sudo rsync -avh     /media/gunter/usb-backup/home-backup/     /home/gunter/

# Eigentuemeschaft danach pruefen:
$ ls -la /home/gunter/ | head -10

Weiterlernen

Du hast jetzt alle Werkzeuge, um ein solides Backup-System mit rsync aufzubauen: lokale Sicherung, NAS-Backup ueber SSH, sinnvolle Excludes, ein robustes Script und den Weg zur Automatisierung.

Drei Seiten, die direkt daran anknuepfen: