# rustic — Schnelle, restic-kompatible Backups in Rust

> Praxis-Guide zu rustic — schnelle, verschlüsselte und deduplizierte Backups in Rust, kompatibel zu restic-Repositories mit Konfigurationsprofilen.

Source: https://www.jpkc.com/db/cheatsheets/backup-sync/rustic/

<!-- PROSE:intro -->
rustic ist eine in Rust geschriebene Backup-Lösung, die schnelle, verschlüsselte und deduplizierte Snapshots erzeugt – und dabei vollständig zu bestehenden restic-Repositories kompatibel bleibt. Du kannst also nahtlos zwischen beiden Werkzeugen wechseln. Gegenüber restic bringt rustic TOML-Konfigurationsprofile, native Cold-Storage-Unterstützung und feinere Aufbewahrungsregeln mit. Dieser Guide führt dich durch die wichtigsten Befehle: Repository anlegen, Backups erstellen, Snapshots durchsuchen, wiederherstellen und alte Stände aufräumen.
<!-- PROSE:intro:end -->

## Repository initialisieren

`rustic init -r <repo>` — Initialisiert ein neues lokales Repository am angegebenen Pfad.

```bash
rustic init -r /mnt/backup/myrepo
```

`rustic -r sftp:<user>@<host>:<path> init` — Initialisiert ein Repository auf einem entfernten Server via SFTP.

```bash
rustic -r sftp:user@server.com:/backup/repo init
```

`rustic -r opendal:s3 -o s3.bucket=<bucket> -o s3.region=<region> init` — Initialisiert ein S3-kompatibles Repository über das OpenDAL-Backend.

```bash
rustic -r opendal:s3 -o s3.bucket=my-backups -o s3.region=eu-central-1 init
```

`rustic -r rclone:<remote>:<path> init` — Initialisiert ein Repository über rclone (nutzt jedes von rclone konfigurierte Backend).

```bash
rustic -r rclone:gdrive:backups/rustic init
```

`rustic init --set-compression <level>` — Initialisiert mit einer bestimmten Kompressionsstufe (-1 bis 22, Standard nutzt zstd-Automatik).

```bash
rustic init -r /mnt/backup/repo --set-compression 3
```

## Konfigurationsprofile

`rustic -P <profile> <command>` — Führt einen Befehl mit einem benannten Profil aus ~/.config/rustic/<profile>.toml oder /etc/rustic/<profile>.toml aus.

```bash
rustic -P daily backup
```

`[repository] in <profile>.toml` — Profil-Abschnitt, der Repository, Passwortdatei, no-cache und weitere repository-weite Optionen definiert (TOML).

```bash
[repository]
repository = "/mnt/backup/repo"
password-file = "/etc/rustic/pw"
```

`[backup] / [[backup.snapshots]] in <profile>.toml` — Vorkonfigurierte Backup-Quellen mit Quellen, Tags und Ausschlüssen — aufgerufen über „rustic backup" ohne Argumente.

```bash
[[backup.snapshots]]
sources = ["/home", "/etc"]
tag = ["daily"]
```

`[forget] in <profile>.toml` — Standard-Aufbewahrungsregeln — angewendet von „rustic forget" ohne Flags.

```bash
[forget]
keep-daily = 7
keep-weekly = 4
```

## Backups erstellen

`rustic -r <repo> backup <path>` — Sichert eine Datei oder ein Verzeichnis ins Repository.

```bash
rustic -r /mnt/backup/repo backup /home/user
```

`rustic -r <repo> backup <path1> <path2>` — Sichert mehrere Pfade in einem einzigen Snapshot.

```bash
rustic -r /mnt/backup/repo backup /home/user /etc
```

`rustic backup --tag <tag> <path>` — Fügt dem Snapshot ein oder mehrere Tags zum Filtern und für die Aufbewahrung hinzu.

```bash
rustic backup --tag daily --tag web /var/www
```

`rustic backup --label <label> <path>` — Setzt ein Label auf den Snapshot (praktisch, um Snapshots verschiedener Quellen zu gruppieren).

```bash
rustic backup --label production /var/www
```

`rustic backup --glob <pattern> <path>` — Schließt Dateien oder Verzeichnisse aus, die auf das angegebene Glob-Muster passen.

```bash
rustic backup --glob '!**/node_modules' /home/user/projects
```

`rustic backup --glob-file <file> <path>` — Liest Include-/Exclude-Glob-Muster aus einer Datei (eines pro Zeile, Präfix „!" schließt aus).

```bash
rustic backup --glob-file ~/.rusticignore /home/user
```

`rustic backup --files-from <listfile> <path>` — Liest zusätzliche zu sichernde Dateien und Verzeichnisse aus einer Datei.

```bash
rustic backup --files-from /etc/rustic/includes.txt
```

`rustic backup --as-path <virtual-path> <path>` — Speichert das Backup unter einem anderen (virtuellen) Pfad im Snapshot. Nützlich für umbenannte Quellen.

```bash
rustic backup --as-path /home/user /mnt/restore/home/user
```

`rustic backup --json <path>` — Gibt maschinenlesbare JSON-Fortschrittsausgabe für Skripte und Monitoring aus.

```bash
rustic backup --json /home/user | jq .
```

`rustic backup --dry-run <path>` — Zeigt, was gesichert würde, ohne ins Repository zu schreiben.

```bash
rustic backup --dry-run /home/user
```

## Snapshots auflisten und inspizieren

`rustic -r <repo> snapshots` — Listet alle Snapshots im Repository auf.

```bash
rustic -r /mnt/backup/repo snapshots
```

`rustic snapshots --filter-tag <tag>` — Listet Snapshots gefiltert nach Tag auf.

```bash
rustic snapshots --filter-tag daily
```

`rustic snapshots --filter-host <hostname>` — Listet Snapshots eines bestimmten Hosts auf.

```bash
rustic snapshots --filter-host webserver01
```

`rustic snapshots --json` — Gibt die Snapshot-Liste als JSON für Skripte aus.

```bash
rustic snapshots --json | jq '.[].id'
```

`rustic ls <snapshot-id>` — Listet die Dateien innerhalb eines bestimmten Snapshots auf.

```bash
rustic ls a1b2c3d4
```

`rustic ls latest` — Listet die Dateien im jüngsten Snapshot auf.

```bash
rustic ls latest
```

`rustic diff <snapshot1> <snapshot2>` — Zeigt die Datei-Unterschiede zwischen zwei Snapshots.

```bash
rustic diff a1b2c3d4 latest
```

`rustic cat <type> <id>` — Gibt den rohen, dekodierten Inhalt eines Repository-Objekts aus (Snapshot, Tree, Blob, Config).

```bash
rustic cat snapshot a1b2c3d4
```

## Daten wiederherstellen

`rustic restore <snapshot-id> <target>` — Stellt einen vollständigen Snapshot in das angegebene Zielverzeichnis wieder her.

```bash
rustic restore a1b2c3d4 /tmp/restore
```

`rustic restore latest <target>` — Stellt den jüngsten Snapshot wieder her.

```bash
rustic restore latest /tmp/restore
```

`rustic restore latest:/<path> <target>` — Stellt nur einen Unterpfad aus dem jüngsten Snapshot wieder her.

```bash
rustic restore latest:/home/user/Documents /tmp/restore
```

`rustic restore --glob <pattern> <snapshot> <target>` — Stellt nur Dateien wieder her, die auf ein Glob-Muster passen (Präfix „!" schließt aus).

```bash
rustic restore --glob '!**/*.log' latest /tmp/restore
```

`rustic restore --dry-run <snapshot> <target>` — Zeigt, was wiederhergestellt würde, ohne Dateien zu schreiben.

```bash
rustic restore --dry-run latest /tmp/restore
```

`rustic restore --delete <snapshot> <target>` — Löscht Dateien im Ziel, die im Snapshot nicht existieren (Spiegel-Wiederherstellung).

```bash
rustic restore --delete latest /var/www
```

`rustic dump <snapshot>:<file>` — Gibt den Inhalt einer einzelnen Datei aus einem Snapshot auf stdout aus.

```bash
rustic dump latest:/etc/nginx/nginx.conf
```

## Snapshots einhängen (FUSE)

`rustic mount <mountpoint>` — Hängt alle Snapshots als schreibgeschütztes virtuelles Dateisystem ein (benötigt FUSE).

```bash
rustic mount /mnt/rustic
```

`rustic mount <snapshot-id> <mountpoint>` — Hängt einen einzelnen Snapshot als schreibgeschütztes Dateisystem ein.

```bash
rustic mount latest /mnt/rustic
```

## Forget & Prune (Aufbewahrung)

*`rustic forget` und `rustic prune` entfernen Snapshots und nicht referenzierte Daten endgültig – prüfe die Wirkung vorher immer mit `--dry-run`.*

`rustic forget --keep-last <n>` — Behält nur die n jüngsten Snapshots und markiert den Rest zur Entfernung.

```bash
rustic forget --keep-last 7
```

`rustic forget --keep-daily <n> --keep-weekly <n> --keep-monthly <n>` — Wendet eine Standard-Aufbewahrungsrichtlinie an: behält n tägliche/wöchentliche/monatliche Snapshots.

```bash
rustic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12
```

`rustic forget --keep-within <duration>` — Behält alle Snapshots, die innerhalb der angegebenen Dauer erstellt wurden (z. B. 7d, 4w, 6m, 1y).

```bash
rustic forget --keep-within 30d
```

`rustic forget --keep-tag <tag>` — Behält stets Snapshots, die das angegebene Tag tragen.

```bash
rustic forget --keep-tag important
```

`rustic forget --filter-tag <tag> --keep-last <n>` — Wendet die Aufbewahrung nur auf Snapshots mit einem bestimmten Tag an.

```bash
rustic forget --filter-tag daily --keep-last 7
```

`rustic forget --dry-run --keep-daily <n>` — Zeigt eine Vorschau, welche Snapshots entfernt würden, ohne sie zu löschen.

```bash
rustic forget --dry-run --keep-daily 7
```

`rustic forget --keep-daily 7 --prune` — Wendet die Aufbewahrung an und entfernt unmittelbar nicht referenzierte Daten aus dem Repository.

```bash
rustic forget --keep-daily 7 --prune
```

`rustic prune` — Entfernt Daten, die von keinem Snapshot mehr referenziert werden. Mit --instant-delete die Sicherheitsverzögerung überspringen.

```bash
rustic prune
```

## Repository-Wartung

`rustic check` — Prüft das Repository auf Fehler und verifiziert die Integrität der Metadaten.

```bash
rustic check
```

`rustic check --read-data` — Verifiziert alle Pack-Dateien, indem ihr Inhalt gelesen und entschlüsselt wird (langsam, gründlich).

```bash
rustic check --read-data
```

`rustic check --read-data-subset <n>%` — Verifiziert einen Prozentsatz der Daten. Nützlich für gestaffelte/geplante Verifikation.

```bash
rustic check --read-data-subset 10%
```

`rustic repair index` — Baut den Repository-Index neu auf. Nutzen, falls der Index verloren oder beschädigt ist.

```bash
rustic repair index
```

`rustic repair snapshots` — Repariert Snapshots, deren Daten teilweise fehlen (erstellt korrigierte Kopien, Originale bleiben).

```bash
rustic repair snapshots
```

`rustic repoinfo` — Zeigt Repository-Informationen: Pack-/Blob-Anzahl, Summen, Kompressionsrate.

```bash
rustic repoinfo
```

`rustic key list` — Listet alle im Repository gespeicherten Verschlüsselungsschlüssel auf.

```bash
rustic key list
```

`rustic key add` — Fügt dem Repository ein neues Verschlüsselungspasswort hinzu.

```bash
rustic key add
```

`rustic copy --target <repo2>` — Kopiert Snapshots in ein zweites Repository (3-2-1-Backup-Strategie).

```bash
rustic copy --target sftp:user@offsite.com:/backup
```

## Tags & Snapshot-Verwaltung

`rustic tag <snapshot-id> --add <tag>` — Fügt bestehenden Snapshots Tags hinzu, ohne das Backup erneut auszuführen.

```bash
rustic tag a1b2c3d4 --add archive
```

`rustic tag <snapshot-id> --remove <tag>` — Entfernt Tags von bestehenden Snapshots.

```bash
rustic tag a1b2c3d4 --remove daily
```

`rustic tag --set <tag> <snapshot-id>` — Ersetzt alle Tags eines Snapshots durch das/die angegebene(n) Tag(s).

```bash
rustic tag --set archive a1b2c3d4
```

`rustic merge <snapshot1> <snapshot2>` — Führt zwei Snapshots zu einem einzigen neuen Snapshot zusammen.

```bash
rustic merge a1b2c3d4 e5f6g7h8
```

## Umgebungsvariablen

`export RUSTIC_REPOSITORY=<path>` — Setzt das Standard-Repository, sodass -r entfallen kann.

```bash
export RUSTIC_REPOSITORY=/mnt/backup/repo
```

`export RUSTIC_PASSWORD=<password>` — Setzt das Repository-Passwort direkt. Praktisch für unbeaufsichtigte/Cron-Backups, aber sicherer sind RUSTIC_PASSWORD_FILE oder RUSTIC_PASSWORD_COMMAND.

```bash
export RUSTIC_PASSWORD=mysecretpassword
```

`export RUSTIC_PASSWORD_FILE=<path>` — Liest das Repository-Passwort aus einer Datei.

```bash
export RUSTIC_PASSWORD_FILE=/etc/rustic/password.txt
```

`export RUSTIC_PASSWORD_COMMAND=<cmd>` — Führt einen Befehl aus und nutzt dessen stdout als Passwort.

```bash
export RUSTIC_PASSWORD_COMMAND='pass show rustic/main'
```

`export RUSTIC_USE_PROFILE=<profile>` — Standardprofil, das geladen wird, wenn -P nicht angegeben ist.

```bash
export RUSTIC_USE_PROFILE=daily
```

`export RUSTIC_NO_PROGRESS=1` — Deaktiviert Fortschrittsbalken (nützlich in Cron-/Nicht-TTY-Kontexten).

```bash
export RUSTIC_NO_PROGRESS=1
```

## Häufige Rezepte

`rustic -P daily backup && rustic -P daily forget --prune` — Führt in einer Cron-Zeile ein tägliches Backup aus und wendet die Aufbewahrung aus einem Profil an.

```bash
0 3 * * * rustic -P daily backup && rustic -P daily forget --prune
```

`rustic snapshots --json | jq -r '.[-1][1][-1].id'` — Holt die ID des jüngsten Snapshots als reinen String.

```bash
rustic snapshots --json | jq -r '.[-1][1][-1].id'
```

`rustic backup --glob-file ~/.rusticignore --tag daily /home` — Tägliches Backup von /home mit Ausschlüssen und einem Tag für Aufbewahrungsrichtlinien.

```bash
rustic backup --glob-file ~/.rusticignore --tag daily /home
```

`rustic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune` — Standard-Aufbewahrungsrichtlinie: 7 tägliche, 4 wöchentliche, 12 monatliche Snapshots.

```bash
rustic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune
```

`rustic copy --target <repo2> && rustic -r <repo2> check` — Synchronisiert in ein Offsite-Repository und verifiziert es (3-2-1-Strategie mit Integritätsprüfung).

```bash
rustic copy --target sftp:user@offsite:/backup && rustic -r sftp:user@offsite:/backup check
```

<!-- PROSE:outro -->
## Fazit

rustic verbindet die Geschwindigkeit und Speichersicherheit von Rust mit dem bewährten, deduplizierten Repository-Format von restic – eine attraktive Wahl, wenn du auf restic aufbaust, aber Konfigurationsprofile und mehr Komfort möchtest. Behandle dein Repository-Passwort wie jedes andere Geheimnis und prüfe `forget`/`prune` immer zuerst mit `--dry-run`. Und ein Backup, das du nie wiederhergestellt hast, ist nur eine Vermutung: teste `rustic restore` regelmäßig.

## Weiterführende Links

- [rustic – offizielle Website](https://rustic.cli.rs) – Dokumentation, Installationsanleitung und Konfigurationsreferenz (englisch)
- [rustic – GitHub-Projekt](https://github.com/rustic-rs/rustic) – Quellcode, Releases und Issue-Tracker (englisch)
- [restic-Dokumentation](https://restic.readthedocs.io/) – Hintergründe zum kompatiblen Repository-Format (englisch)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [restic](https://www.jpkc.com/db/cheatsheets/backup-sync/restic/) – das Original; rustic ist zu seinen Repositories kompatibel
- [borgbackup](https://www.jpkc.com/db/cheatsheets/backup-sync/borgbackup/) – deduplizierendes Backup mit Kompression und Verschlüsselung
- [duplicity](https://www.jpkc.com/db/cheatsheets/backup-sync/duplicity/) – verschlüsselte, inkrementelle Backups auf viele Storage-Backends
- [rclone](https://www.jpkc.com/db/cheatsheets/backup-sync/rclone/) – synchronisiert Dateien mit zahlreichen Cloud-Speichern