Selbstgebaut: Automatisches, einfaches Backup per rsync auf ein bestimmtes externes Speichermedium beim Verbinden (z. B. für paperless-ngx)

Vorab: Es gibt mehrere Projekte und Lösungen, um ein automatisches Backup direkt nach dem Verbinden eines externen Speichermediums (SD-Karte, USB-Stick, USB-Festplatte) auszulösen und durchzuführen. Ein paar Beispiele:

Möchte man eine schlanke, selbstgebaute Lösung herstellen, zum Beispiel wenn man paperless-ngx auf einem Raspberry Pi betreibt und regelmäßig durch einfaches Einstecken eines bestimmten Speichermediums ein Backup auslösen möchte, könnte der nachfolgend beschriebene Arbeitsablauf hilfreich sein.

Das wird benötigt:

  • ein externes Speichermedium (in meinem Beispiel ist das ein sehr alter USB-Stick mit nur 1 GB Speicher, für die Anleitung völlig ausreichend, jedoch muss später natürlich mindestens einmal die gesamte zu sichernde Datenmenge auf das Medium passen)
  • die Vendor-ID des Geräts (Herstellernummer, 0204)
  • die Product-ID des Geräts (Produktnummer, 6025)
  • die UUID des Dateisystems auf dem Gerät

Um alle notwendigen Daten erstmal zu sammeln, starten wir in einem Terminal mit

dmesg -T -w

das fortlaufende Kernellog. Nun stecken wir unser Speichermedium an. Es folgt eine Ausgabe, die etwa so lautet:

[Sat Oct 24 13:05:23 2026] usb 1-1.3: new high-speed USB device number 3 using xhci_hcd
[Sat Oct 24 13:05:24 2026] usb 1-1.3: New USB device found, idVendor=0204, idProduct=6025, bcdDevice= 1.00
[Sat Oct 24 13:05:24 2026] usb 1-1.3: New USB device strings: Mfr=1, Product=2, SerialNumber=3
[Sat Oct 24 13:05:24 2026] usb 1-1.3: Product: Flash Disk
[Sat Oct 24 13:05:24 2026] usb 1-1.3: Manufacturer: USB
[Sat Oct 24 13:05:24 2026] usb 1-1.3: SerialNumber: AA04012700201075
[Sat Oct 24 13:05:24 2026] usb-storage 1-1.3:1.0: USB Mass Storage device detected
[Sat Oct 24 13:05:24 2026] scsi host0: usb-storage 1-1.3:1.0
[Sat Oct 24 13:05:25 2026] scsi 0:0:0:0: Direct-Access USB Flash Disk 5.00 PQ: 0 ANSI: 2
[Sat Oct 24 13:05:25 2026] sd 0:0:0:0: [sda] 2058752 512-byte logical blocks: (1.05 GB/1005 MiB)
[Sat Oct 24 13:05:25 2026] sd 0:0:0:0: [sda] Write Protect is off
[Sat Oct 24 13:05:25 2026] sd 0:0:0:0: [sda] Mode Sense: 0b 00 00 08
[Sat Oct 24 13:05:25 2026] sd 0:0:0:0: [sda] No Caching mode page found
[Sat Oct 24 13:05:25 2026] sd 0:0:0:0: [sda] Assuming drive cache: write through
[Sat Oct 24 13:05:25 2026] sd 0:0:0:0: Attached scsi generic sg0 type 0
[Sat Oct 24 13:05:25 2026] sda: sda1
[Sat Oct 24 13:05:25 2026] sd 0:0:0:0: [sda] Attached SCSI removable disk

Benötigt wird hier nur der Teil „idVendor=0204, idProduct=6025“, er teilt uns mit, dass der Hersteller dieses USB-Sticks oder vielmehr des darauf enthaltenen Chips die ID 0204 und das Produkt die ID 6025 hat. Diese Nummern sind später zur Automatisierung der ganzen Lösung für udev, das Softwaresystem zur automatischen Behandlung von angesteckten Geräten, zwingend notwendig.

/dev/sda1: UUID="CF24-9BE3" BLOCK_SIZE="512" TYPE="vfat" PARTUUID="250a2260-01"

Außerdem ist zur Verifizierung die UUID/PARTUUID wichtig. Sie ermöglicht einen weiteren Check: Sollten Gerät und Hersteller mal identisch sein, brauchen wir einen weiteren Weg zu verifizieren, dass es sich um das korrekte Gerät handelt.

sudo apt install rsync openssl util-linux udev

sudo mkdir -p /etc/usb-backup
sudo mkdir -p /usr/local/sbin
sudo mkdir -p /mnt/usb-backup
sudo chmod 700 /etc/usb-backup

HIermit werden die nötigen Abhängigkeiten installiert bzw. Pfade mit den nötigen Berechtigungen angelegt.

sudo mkdir -p /mnt/.backup-identity
sudo chmod 700 /mnt/.backup-identity

sudo openssl genpkey
-algorithm ED25519
-out /mnt/.backup-identity/private.pem

sudo openssl pkey
-in /mnt/.backup-identity/private.pem
-pubout
-out /etc/usb-backup/identity.pub

Um das Gerät zweifelsfrei zu identifizieren, können wir ein bisschen einfach zu konfigurierende Kryptographie mit openssl nutzen. Dazu legen wir ein Schlüsselpaar an und platzieren dieses an den notwendigen Pfaden.

sudo nano /etc/usb-backup/config

Inhalt:

# USB-Geräteidentität
EXPECTED_SERIAL="DEINE_SERIENNUMMER"
EXPECTED_VENDOR="DEINE_VENDOR-ID"
EXPECTED_MODEL="DEINE_PRODUCT-ID"

# Dateisystem
EXPECTED_UUID="DEINE-DATEISYSTEM-UUID"

# Kryptografische Identität
PUBLIC_KEY="/etc/usb-backup/identity.pub"
PRIVATE_KEY_REL=".backup-identity/private.pem"

# Mountpoint
MOUNTPOINT="/mnt/usb-backup"

# Backup-Quelle
SOURCE="/home/"

# Backup-Ziel auf dem USB-Datenträger
DESTINATION="backup"

# Protokoll
LOG_TAG="usb-backup"

Die nötige Konfiguration ist damit angelegt.

sudo nano /usr/local/sbin/usb-backup.sh

Inhalt:

#!/bin/bash

set -Eeuo pipefail

# Konfiguration laden
source /etc/usb-backup/config

DEVICE_NAME="${1:?Kein USB-Gerät angegeben}"
DEVICE="/dev/${DEVICE_NAME}"

MOUNTED=0
WORKDIR=""

log() {
logger -t "$LOG_TAG" "$"
echo "$"
}

cleanup() {
local result=$?
if [[ -n "$WORKDIR" && -d "$WORKDIR" ]]; then
    rm -rf "$WORKDIR"
fi

if [[ "$MOUNTED" -eq 1 ]]; then
    sync
    umount "$MOUNTPOINT" || {
        log "FEHLER: Aushängen fehlgeschlagen!"
        result=1
    }
fi

exit "$result"
}

trap cleanup EXIT

fail() {
log "FEHLER: $*"
exit 1
}

# Nur Root

[[ "$EUID" -eq 0 ]] || fail "Root-Rechte erforderlich"

# Gerät vorhanden?

[[ -b "$DEVICE" ]] || fail "Blockgerät existiert nicht"

# Parallele Backups verhindern

exec 9>/run/lock/usb-backup.lock
flock -n 9 || fail "Ein anderes Backup läuft bereits"

log "USB-Backup gestartet: $DEVICE"

# USB-Eigenschaften prüfen

udevadm settle --timeout=15 || true

PROPERTIES=$(udevadm info --query=property --name="$DEVICE")

get_property() {
printf '%s\n' "$PROPERTIES" |
sed -n "s/^$1=//p" |
head -n 1
}

[[ "$(get_property ID_BUS)" == "usb" ]] ||
fail "Kein USB-Gerät"

[[ "$(get_property ID_SERIAL_SHORT)" == "$EXPECTED_SERIAL" ]] ||
fail "Seriennummer stimmt nicht"

[[ "$(get_property ID_VENDOR_ID)" == "$EXPECTED_VENDOR" ]] ||
fail "Hersteller-ID stimmt nicht"

[[ "$(get_property ID_MODEL_ID)" == "$EXPECTED_MODEL" ]] ||
fail "Produkt-ID stimmt nicht"

log "USB-Geräteidentität bestätigt"

# Auf Partition warten

PARTITION="/dev/disk/by-uuid/$EXPECTED_UUID"

for i in {1..30}; do
[[ -e "$PARTITION" ]] && break
sleep 1
done

[[ -e "$PARTITION" ]] ||
fail "Backup-Partition nicht gefunden"

PARTITION=$(readlink -f "$PARTITION")

# Sicherstellen, dass die Partition zu genau diesem USB-Gerät gehört

PARENT=$(lsblk -no PKNAME "$PARTITION" | xargs)

[[ "$PARENT" == "$DEVICE_NAME" ]] ||
fail "Partition gehört nicht zum erwarteten USB-Gerät"

log "Dateisystem-UUID bestätigt"

# Zusätzliche Absicherung: UUID erneut direkt prüfen

ACTUAL_UUID=$(blkid -s UUID -o value "$PARTITION")

[[ "$ACTUAL_UUID" == "$EXPECTED_UUID" ]] ||
fail "Dateisystem-UUID stimmt nicht"

# Mountpoint darf nicht bereits anderweitig verwendet werden

mountpoint -q "$MOUNTPOINT" &&
fail "Mountpoint ist bereits belegt"

# Datenträger exklusiv durch den Dienst einbinden

mount -o rw,nosuid,nodev,noexec "$PARTITION" "$MOUNTPOINT"
MOUNTED=1

log "USB-Datenträger eingebunden"

# Schlüsseldateien prüfen

PRIVATE_KEY="$MOUNTPOINT/$PRIVATE_KEY_REL"

[[ -f "$PRIVATE_KEY" && ! -L "$PRIVATE_KEY" ]] ||
fail "Privater Identitätsschlüssel fehlt oder ist ein Symlink"

[[ -f "$PUBLIC_KEY" ]] ||
fail "Öffentlicher Schlüssel fehlt"

# Zufällige Challenge erzeugen

WORKDIR=$(mktemp -d /run/usb-backup.XXXXXX)
chmod 700 "$WORKDIR"

openssl rand -out "$WORKDIR/challenge" 32

# Challenge auf dem USB-Datenträger signieren

openssl pkeyutl
-sign
-inkey "$PRIVATE_KEY"
-rawin
-in "$WORKDIR/challenge"
-out "$WORKDIR/signature" ||
fail "Signatur konnte nicht erstellt werden"

# Signatur verifizieren

openssl pkeyutl
-verify
-pubin
-inkey "$PUBLIC_KEY"
-rawin
-in "$WORKDIR/challenge"
-sigfile "$WORKDIR/signature" ||
fail "Kryptografische Authentifizierung fehlgeschlagen"

log "Kryptografische Identität bestätigt"

# Zielverzeichnis

HOSTNAME=$(hostname -s)
TARGET="$MOUNTPOINT/$DESTINATION/$HOSTNAME"

mkdir -p "$TARGET"

[[ -d "$SOURCE" ]] ||
fail "Backup-Quelle existiert nicht"

log "Backup wird gestartet"

# Backup durchführen

rsync
-aHAX
--numeric-ids
--human-readable
--stats
"$SOURCE"
"$TARGET/"

log "Backup erfolgreich abgeschlossen"

sync

log "USB-Backup beendet"

Damit ist das Skript angelegt.

sudo chmod 700 /usr/local/sbin/usb-backup.sh
sudo chown root:root /usr/local/sbin/usb-backup.sh

Damit sind die Rechte für das Skript eingestellt.

nano /etc/systemd/system/usb-backup@.service

Inhalt:

[Unit]
Description=Automatisches USB-Backup (%I)
Documentation=man:rsync(1)
After=systemd-udev-settle.service

[Service]
Type=oneshot

ExecStart=/usr/local/sbin/usb-backup.sh %I

TimeoutStartSec=0

User=root
Group=root

UMask=0077

Nice=10
IOSchedulingClass=best-effort
IOSchedulingPriority=7

StandardOutput=journal
StandardError=journal

Damit ist der Systemd-Unit zum Start des Skripts angelegt.

sudo nano /etc/udev/rules.d/99-usb-backup.rules

Inhalt:

ACTION=="add",
SUBSYSTEM=="block",
ENV{DEVTYPE}=="disk",
ENV{ID_BUS}=="usb",
ENV{ID_SERIAL_SHORT}=="AA04012700201075",
ENV{ID_VENDOR_ID}=="0204",
ENV{ID_MODEL_ID}=="6025",
TAG+="systemd",
ENV{SYSTEMD_WANTS}+="usb-backup@%k.service"

Damit ist die notwendige udev-Regel angelegt.

gsettings set org.gnome.desktop.media-handling automount false
gsettings set org.gnome.desktop.media-handling automount-open false

Damit wird ein Eingreifen der möglicherweise vorhandenen Desktopumgebung in den Mountvorgang unterbunden.

Fertig!

Nun den USB-Stick anschließen, die Funktion prüfen und beobachten, z. B. mit:

sudo udevadm monitor --udev --property
sudo journalctl -u usb-backup@*.service

Viel Erfolg!

Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert