BorgBackup: Deduplizierte Backups sichern und wiederherstellen

Warum Borg?

BorgBackup ist in Debian enthalten, arbeitet ausschließlich auf der Kommandozeile und lässt sich deshalb hervorragend mit systemd oder cron automatisieren. Vier Eigenschaften machen es für den Serverbetrieb interessant:

• Deduplizierung auf Blockebene: Dateien werden in Chunks zerlegt. Gleiche Chunks werden nur einmal gespeichert – im ganzen Repository. Deshalb ist das zehnte Archiv meist nur wenige Megabyte groß.
• Verschlüsselung clientseitig: Die Daten verlassen deinen Server bereits verschlüsselt. Das Ziel (auch ein gemieteter Speicher) sieht nur Datenmüll.
• Komprimierung: zstd, lz4, zlib oder lzma – wählbar pro Backup.
• Keine Archiv-Kette: Anders als bei manchen Backup-Tools hängt kein Archiv vom anderen ab. Du kannst jedes einzelne Archiv vollständig wiederherstellen – auch wenn du die vorherigen gelöscht hast.

Wie Borg arbeitet

• Repository: der Ablageort deiner Backups – ein Verzeichnis auf einer Platte, einem NAS oder einem entfernten Rechner. Enthält Chunks, Index und Metadaten.
• Archiv: ein Zeitpunkt innerhalb des Repositories. Es bekommt einen Namen (üblich: Datum und Uhrzeit) und ist dein „Wiederherstellungspunkt“.
• Chunks: Dateiinhalte werden in Blöcke zerlegt. Identische Blöcke landen nur einmal im Repository – hier entsteht die enorme Platzersparnis.
• Schlüssel: Bei repokey liegt der Schlüssel im Repository, geschützt durch deine Passphrase. Bei keyfile liegt er außerhalb – dann brauchst du zwingend Repo, Keyfile und Passphrase.

Installation & Vorbereitung

sudo apt update
sudo apt install borgbackup fuse3
borg --version

# Ziel und Mountpunkt anlegen
sudo mkdir -p /mnt/backup
sudo mkdir -p /mnt/recovery

• borgbackup bringt nur die Kommandozeile mit – kein Dienst, kein Daemon. Du entscheidest, wann gesichert wird.
• fuse3 brauchst du nur fürs Mounten (borg mount) – also für die bequemste Form der Wiederherstellung. Installiere es mit.
• /mnt/recovery ist kein Backup-Ort, sondern ein leerer Arbeitspunkt zum Durchsuchen der Archive.

Repository anlegen

sudo borg init --encryption=repokey /mnt/backup/borg-repo

Borg fragt nach einer Passphrase. Nimm einen langen Satz aus mehreren Wörtern – du tippst sie nur selten, aber sie entscheidet über alles. Danach gehört das Repository dir:

# Besitzer setzen, damit du nicht jedes Mal sudo brauchst
sudo chown -R root:root /mnt/backup/borg-repo

# Sofort: Schlüssel exportieren und wegschließen (siehe Abschnitt Schlüssel)
sudo borg key export --paper /mnt/backup/borg-repo /root/borg-key-paper.txt

Für Skripte und Timer legst du die Zugangsdaten in eine geschützte Datei – nicht in das Skript selbst:

sudo install -m 600 /dev/null /root/.borg-env
sudo tee /root/.borg-env > /dev/null <<'EOF'
BORG_REPO=/mnt/backup/borg-repo
BORG_PASSPHRASE='deine-lange-passphrase-mit-mehreren-woertern'
EOF

• BORG_REPO ersetzt das lästige Tippen des Pfades in jedem Befehl.
• BORG_PASSPHRASE fragt die Passphrase nicht interaktiv ab – sonst könnte kein Timer laufen.
• Statt der Passphrase im Klartext kannst du auch BORG_PASSCOMMAND nutzen, etwa mit pass oder secret-tool.

Backups erstellen

export BORG_REPO=/mnt/backup/borg-repo
export BORG_PASSPHRASE='deine-lange-passphrase-mit-mehreren-woertern'

borg create --stats --list --compression zstd,3 \
  --exclude-caches \
  --exclude '/home/*/.cache' \
  --exclude '/var/cache' \
  --exclude '/var/tmp' \
  --exclude '/home/*/.local/share/Trash' \
  --exclude '*.tmp' \
  "$BORG_REPO::server-$(date +%Y-%m-%d_%H-%M)" \
  /etc /root /home /opt/stacks /srv

Automatisierung per systemd-Timer

Ein systemd-Timer ist gegenüber cron klar im Vorteil: Er kann ein fehlendes Ziel-Mount erkennen, verpasste Läufe nachholen und landet sauber im Journal.

#!/bin/sh
# /usr/local/bin/borg-backup.sh
set -eu

. /root/.borg-env

ARCHIV="server-$(date +%Y-%m-%d_%H-%M)"

borg create --stats --compression zstd,3 \
  --exclude-caches \
  --exclude '/home/*/.cache' \
  --exclude '/var/cache' \
  --exclude '/var/tmp' \
  "$BORG_REPO::$ARCHIV" \
  /etc /root /home /opt/stacks /srv

# Aufbewahrung: 7 Tage, 4 Wochen, 6 Monate
borg prune --keep-daily 7 --keep-weekly 4 --keep-monthly 6 "$BORG_REPO"

# Platz tatsächlich freigeben (erst ab Borg 1.2)
borg compact "$BORG_REPO"

# Einmal pro Woche die Integrität prüfen (Sonntag)
[ "$(date +%u)" = "7" ] && borg check "$BORG_REPO"

# /etc/systemd/system/borg-backup.service
[Unit]
Description=Borg-Backup auf /mnt/backup
RequiresMountsFor=/mnt/backup

[Service]
Type=oneshot
EnvironmentFile=/root/.borg-env
ExecStart=/usr/local/bin/borg-backup.sh
Nice=10
IOSchedulingClass=idle

# /etc/systemd/system/borg-backup.timer
[Unit]
Description=Taegliches Borg-Backup

[Timer]
OnCalendar=*-*-* 03:15
Persistent=true
RandomizedDelaySec=15m

[Install]
WantedBy=timers.target

sudo chmod +x /usr/local/bin/borg-backup.sh
sudo systemctl daemon-reload
sudo systemctl enable --now borg-backup.timer
systemctl list-timers borg-backup.timer
journalctl -u borg-backup -n 50 --no-pager

• RequiresMountsFor=/mnt/backup startet den Dienst nur, wenn das Ziel wirklich eingehängt ist – die wichtigste Zeile der ganzen Unit.
• Persistent=true holt einen Lauf nach, wenn der Server nachts aus war.
• RandomizedDelaySec verhindert, dass viele Server gleichzeitig auf ein NAS losgehen.
• Nice=10 und IOSchedulingClass=idle halten das Backup aus dem Weg, wenn parallel gearbeitet wird.

Wartung: check, prune, compact

borg info "$BORG_REPO"                  # Größe, Anzahl Archive, Dedup-Rate
borg list "$BORG_REPO"                  # alle Archive

# Aufbewahrung erst als Probelauf, dann scharf
borg prune --list --dry-run --keep-daily 7 --keep-weekly 4 --keep-monthly 6 "$BORG_REPO"
borg prune --list --keep-daily 7 --keep-weekly 4 --keep-monthly 6 "$BORG_REPO"

borg compact "$BORG_REPO"               # gibt gelöschten Platz wirklich frei
borg check "$BORG_REPO"                 # Integrität der Struktur
borg check --verify-data "$BORG_REPO"   # prüft zusätzlich alle Datenchunks (dauert!)
borg delete "$BORG_REPO::server-2026-01-01_03-15"   # einzelnes Archiv entfernen

Wiederherstellen: die vier Wege

Borg kennt vier Wege zur Wiederherstellung – je nach Situation ist ein anderer der beste:

Vor jedem Restore lohnt der Blick in das Archiv – und der Vergleich zweier Zeitpunkte:

borg list --short "$BORG_REPO"                  # nur Archivnamen, kurz
borg list "$BORG_REPO::server-2026-09-18_03-15" # Inhalt eines Archivs
borg info "$BORG_REPO::server-2026-09-18_03-15" # Metadaten, Größe, Dauer
borg diff "$BORG_REPO::server-2026-09-17_03-15" "$BORG_REPO::server-2026-09-18_03-15"

Einzelne Dateien extrahieren

Pfade im Archiv sind relativ: Aus /etc/nginx wird etc/nginx. Der Restore schreibt die Dateien in das aktuelle Verzeichnis – gehe deshalb immer zuerst in einen leeren Ordner.

# 1. In einen leeren Arbeitsordner wechseln
mkdir -p /tmp/restore && cd /tmp/restore

# 2. Erst schauen, was passieren wuerde
borg extract --dry-run --list "$BORG_REPO::server-2026-09-18_03-15" etc/nginx/

# 3. Dann wirklich extrahieren
borg extract "$BORG_REPO::server-2026-09-18_03-15" etc/nginx/

# 4. Vergleichen und zurueckkopieren (Rechte, ACLs, xattrs inklusive)
sudo rsync -aHAX --numeric-ids /tmp/restore/etc/nginx/ /etc/nginx/

Weitere nützliche Varianten:

# Nur eine einzige Datei ausgeben (praktisch fuer Configs)
borg extract --stdout "$BORG_REPO::server-2026-09-18_03-15" home/user/.bashrc > /tmp/bashrc

# Fuehrende Verzeichnisebenen abschneiden
borg extract --strip-components 3 "$BORG_REPO::server-2026-09-18_03-15" home/user/daten/urlaub

# Mit Besitzer-IDs aus dem Original wiederherstellen
sudo borg extract --numeric-owner "$BORG_REPO::server-2026-09-18_03-15" etc var/www

Archiv mounten (FUSE)

Der bequemste Weg: Borg hängt ein Archiv als schreibgeschütztes Verzeichnis ein. Du kannst danach mit jedem Dateimanager oder rsync arbeiten – ohne den Umweg über eine Extraktion.

sudo mkdir -p /mnt/recovery

# Ein einzelnes Archiv mounten
sudo borg mount "$BORG_REPO::server-2026-09-18_03-15" /mnt/recovery

# Oder gleich das ganze Repository (alle Archive als Unterordner)
sudo borg mount "$BORG_REPO" /mnt/recovery

ls -la /mnt/recovery

# Aufraeumen: erst wenn niemand mehr darauf zugreift
borg umount /mnt/recovery

Das Restore-Script

Der Mount-Weg lässt sich gut in ein kleines Helfer-Skript gießen: Archive auflisten, eines auswählen, einhängen – fertig. Hier die Fassung, die bei uns als /usr/local/bin/borg-restore.sh liegt:

#!/bin/sh

REPO="/mnt/backup/borg-repo"
MOUNTPOINT="/mnt/recovery"

# Falls der Mountpoint noch nicht existiert, erstellen
if [ ! -d "$MOUNTPOINT" ]; then
    echo "Erstelle Mountpoint $MOUNTPOINT..."
    mkdir -p "$MOUNTPOINT" || exit 1
fi

# Prüfen, ob bereits etwas dort gemountet ist
if mountpoint -q "$MOUNTPOINT" || borg mount | grep -q "$MOUNTPOINT"; then
    echo "⚠️  Es ist bereits ein Backup unter $MOUNTPOINT eingebunden!"
    echo "Nutze 'borg umount $MOUNTPOINT' zum Trennen."
    exit 1
fi

echo "======================================"
echo " Verfügbare Backups in $REPO:"
echo "======================================"
# Listet alle Archive auf und zeigt nur die Namen an
borg list "$REPO" --format "{archive}{NEWLINE}"
echo "======================================"

# Benutzer nach dem gewünschten Archiv fragen
printf "Bitte kopiere den Namen des gewünschten Archivs und füge ihn hier ein: "
read -r ARCHIVE

if [ -z "$ARCHIVE" ]; then
    echo "Kein Archiv angegeben. Abbruch."
    exit 1
fi

echo "Lade Archiv '$ARCHIVE' nach $MOUNTPOINT..."
# Mount-Befehl ausführen
if borg mount "$REPO::$ARCHIVE" "$MOUNTPOINT"; then
    echo ""
    echo "✅ Erfolgreich bereitgestellt!"
    echo "--------------------------------------------------------"
    echo "Du kannst deine Daten jetzt hier einsehen: $MOUNTPOINT"
    echo "Zum Trennen tippe nach der Arbeit einfach: borg umount $MOUNTPOINT"
    echo "--------------------------------------------------------"
else
    echo "❌ Fehler beim Bereitstellen des Archivs."
    exit 1
fi

Was das Skript tut – und warum es genau so aufgebaut ist:

• Mountpoint prüfen/erstellen: [ ! -d "$MOUNTPOINT" ] verhindert, dass der Mount an einem fehlenden Ordner scheitert.
• Doppel-Mount verhindern: Die Kombination aus mountpoint -q und borg mount deckt beide Fälle ab – ein bereits eingehängter FUSE-Punkt und ein laufender Borg-Mount.
• Archive nummeriert ausgeben: So sieht man sofort, welches Archiv man braucht, und kann den Namen direkt kopieren statt ihn abzutippen.
• Klare Abbruchpfade: exit 1 mit verständlicher Meldung – wichtig, wenn das Skript mal aus einem anderen Skript aufgerufen wird.

Drei kleine Verbesserungen, wenn du magst:

#!/bin/sh
set -eu                                  # bricht bei Fehlern sauber ab

REPO="/mnt/backup/borg-repo"
MOUNTPOINT="/mnt/recovery"

command -v borg >/dev/null || { echo "borg ist nicht installiert."; exit 1; }
command -v fusermount3 >/dev/null || command -v fusermount >/dev/null || \
  echo "Hinweis: fuse3 fehlt – 'borg mount' braucht FUSE."

mkdir -p "$MOUNTPOINT"
mountpoint -q "$MOUNTPOINT" && { echo "Bereits eingebunden unter $MOUNTPOINT."; exit 1; }

echo "Neueste Archive in $REPO:"
borg list --short --last 15 "$REPO"      # kuerzer als --format, neueste zuerst

printf "Archiv-Name (leer = Abbruch): "
read -r ARCHIVE
[ -n "$ARCHIVE" ] || { echo "Abgebrochen."; exit 1; }

borg mount "$REPO::$ARCHIVE" "$MOUNTPOINT"
echo "Bereitgestellt unter $MOUNTPOINT – beenden mit: borg umount $MOUNTPOINT"

• borg list --short --last 15 statt --format "{archive}{NEWLINE}": kürzer und zeigt die neuesten Archive – im Notfall willst du fast immer eines der letzten.
• set -eu plus Vorabprüfung auf borg und FUSE: das Skript scheitert dann mit klarer Ansage, nicht mit kryptischen Folgefehlern.
• command -v … ist portabler als ein direkter Aufruf, weil es nichts ausführt.

Notfall: der ganze Server

Festplatte defekt, Server neu installiert, nichts ist mehr da – jetzt zählt, dass du das Verfahren vorher geübt hast. Der Ablauf ist immer gleich:

# 1. Von einem Live-System booten, Backup-Ziel einhaengen
sudo mkdir -p /mnt/backup && sudo mount /dev/sdb1 /mnt/backup

# 2. Borg + Zugang bereitstellen
sudo apt install borgbackup
export BORG_REPO=/mnt/backup/borg-repo
export BORG_PASSPHRASE='deine-lange-passphrase'

# 3. Gewuenschtes Archiv auflisten
borg list --short "$BORG_REPO"

# 4. Neue Platte mounten und dorthin entpacken
sudo mkdir -p /mnt/newroot && sudo mount /dev/nvme0n1p2 /mnt/newroot
cd /mnt/newroot
sudo borg extract --numeric-owner --list "$BORG_REPO::server-2026-09-18_03-15"

• Pfade: Du entpackst relativ in das neue Wurzelverzeichnis – aus dem Archiv wird wieder /etc, /home und so weiter.
• --numeric-owner: erhält UID/GID aus dem Original. Sonst kann es passieren, dass Dateien plötzlich einem falschen Nutzer gehören.
• Nicht vergessen: /boot (falls separat), die korrekte /etc/fstab und den Bootloader. Backup ist nicht Klonen – das Nacharbeiten gehört dazu.
• Alternative: borg export-tar "$BORG_REPO::archiv" /tmp/backup.tar, wenn du die Daten mit anderen Werkzeugen weiterverarbeiten willst.

Remote-Repository per SSH

Die dritte Kopie gehört außer Haus. Borg spricht direkt SSH und braucht auf der Gegenseite nur borg:

export BORG_REPO="ssh://backup@backup-host:22/./mnt/backup/borg-repo"
borg init --encryption=repokey "$BORG_REPO"

Für den zugreifenden Server legst du einen eingeschränkten SSH-Schlüssel an:

# ~/.ssh/authorized_keys auf dem Backup-Host
command="borg serve --restrict-to-path /mnt/backup",restrict ssh-ed25519 AAAAC3Nza... borg-client

• --restrict-to-path erlaubt nur diesen einen Ordner – selbst wenn der Schlüssel gestohlen wird.
• restrict schaltet Port-Weiterleitung und Co. ab.
• append-only: Damit ein kompromittierter Quellserver die Backups nicht löschen kann, lässt sich der Zugriff auf „nur anhängen“ beschränken – je nach Version per borg serve --append-only oder Repository-Konfiguration.
• Reicht die Leitung nicht, sichere per borg create auf ein lokales Repo und synchronisiere danach mit borg transfer bzw. rsync der Repo-Dateien.

Schlüssel & Passphrase

# Schlüssel exportieren (Klartext-Datei fuer den Notfall)
borg key export "$BORG_REPO" /root/borg-key-export.txt

# Als Papier-Version zum Ausdrucken – ueberlebt jeden Plattencrash
borg key export --paper "$BORG_REPO" /root/borg-key-paper.txt

# In ein neues Repository importieren
borg key import /mnt/backup/neues-repo /root/borg-key-export.txt

# Passphrase aendern (Schluessel bleibt derselbe)
borg key change-passphrase "$BORG_REPO"

Häufige Probleme (FAQ)

Fazit

Borg ist unspektakulär – und genau das ist bei Backups die höchste Auszeichnung. Ein Repository anlegen, ein Skript schreiben, einen Timer aktivieren: nach einer halben Stunde läuft es. Der eigentliche Wert liegt danach im Wiederherstellen: borg mount für den bequemen Blick, borg extract für gezielte Pfade und ein geübtes --dry-run für den Notfall.