# restic — Schnelle, verschlüsselte Backups

> Praxis-Guide zu restic: schnelle, verschlüsselte Backups mit Deduplizierung, Snapshots und Retention für lokale, SFTP-, S3- und B2-Repositories.

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

<!-- PROSE:intro -->
restic ist ein modernes Backup-Programm, das deine Daten in verschlüsselten Repositories ablegt und dabei automatisch dedupliziert – jeder Datenblock wird nur einmal gespeichert, egal über wie viele Snapshots oder Hosts hinweg er auftaucht. Du sicherst lokal, per SFTP oder in Cloud-Speicher wie S3 und Backblaze B2, ohne dass Klartext den Rechner verlässt. Dieser Guide führt dich vom Anlegen des Repositories über Backups, Snapshots und Wiederherstellung bis zu Retention-Policies und Wartung.
<!-- PROSE:intro:end -->

## Repository anlegen

`restic init --repo <path>` — Legt ein neues lokales Repository am angegebenen Pfad an.

```bash
restic init --repo /mnt/backup/myrepo
```

`restic -r sftp:<user>@<host>:<path> init` — Legt ein Repository auf einem entfernten Server per SFTP an.

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

`restic -r s3:s3.amazonaws.com/<bucket> init` — Legt ein Repository in einem S3-kompatiblen Bucket an. AWS_ACCESS_KEY_ID und AWS_SECRET_ACCESS_KEY setzen.

```bash
restic -r s3:s3.amazonaws.com/my-backup-bucket init
```

`restic -r b2:<bucket>:<path> init` — Legt ein Repository in Backblaze B2 an. B2_ACCOUNT_ID und B2_ACCOUNT_KEY setzen.

```bash
restic -r b2:my-bucket:restic-repo init
```

`restic -r rclone:<remote>:<path> init` — Legt ein Repository über rclone an (nutzt jedes in rclone konfigurierte Backend).

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

## Backups erstellen

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

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

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

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

`restic -r <repo> backup --tag <tag> <path>` — Versieht den Snapshot mit einem oder mehreren Tags zum einfachen Filtern.

```bash
restic -r /mnt/backup/repo backup --tag daily --tag web /var/www
```

`restic -r <repo> backup --exclude <pattern> <path>` — Schließt Dateien oder Verzeichnisse aus, die auf das Muster passen.

```bash
restic -r /mnt/backup/repo backup --exclude 'node_modules' /home/user/projects
```

`restic -r <repo> backup --exclude-file <file> <path>` — Liest Ausschlussmuster aus einer Datei (ein Muster pro Zeile).

```bash
restic -r /mnt/backup/repo backup --exclude-file ~/.resticignore /home/user
```

`restic -r <repo> backup --files-from <listfile>` — Liest die zu sichernden Dateien und Verzeichnisse aus einer Datei.

```bash
restic -r /mnt/backup/repo backup --files-from /etc/restic/includes.txt
```

`restic -r <repo> backup --verbose <path>` — Zeigt detaillierte Ausgabe inklusive jeder gesicherten Datei.

```bash
restic -r /mnt/backup/repo backup --verbose /home/user
```

## Snapshots auflisten

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

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

`restic -r <repo> snapshots --tag <tag>` — Listet Snapshots gefiltert nach Tag auf.

```bash
restic -r /mnt/backup/repo snapshots --tag daily
```

`restic -r <repo> snapshots --host <hostname>` — Listet Snapshots eines bestimmten Hosts auf.

```bash
restic -r /mnt/backup/repo snapshots --host webserver01
```

`restic -r <repo> snapshots --json` — Gibt die Snapshot-Liste als JSON für Skripte aus.

```bash
restic -r /mnt/backup/repo snapshots --json | jq '.[].id'
```

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

```bash
restic -r /mnt/backup/repo ls a1b2c3d4
```

`restic -r <repo> ls latest` — Listet die Dateien des jüngsten Snapshots auf.

```bash
restic -r /mnt/backup/repo ls latest
```

## Daten wiederherstellen

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

```bash
restic -r /mnt/backup/repo restore a1b2c3d4 --target /tmp/restore
```

`restic -r <repo> restore latest --target <path>` — Stellt den jüngsten Snapshot wieder her.

```bash
restic -r /mnt/backup/repo restore latest --target /tmp/restore
```

`restic -r <repo> restore latest --target <path> --include <pattern>` — Stellt nur die Dateien aus dem jüngsten Snapshot wieder her, die auf das Muster passen.

```bash
restic -r /mnt/backup/repo restore latest --target /tmp/restore --include '/home/user/Documents'
```

`restic -r <repo> restore latest --target <path> --exclude <pattern>` — Stellt alle Dateien außer denen wieder her, die auf das Muster passen.

```bash
restic -r /mnt/backup/repo restore latest --target /tmp/restore --exclude '*.log'
```

`restic -r <repo> dump <snapshot-id> <file>` — Gibt den Inhalt einer einzelnen Datei aus einem Snapshot auf stdout aus.

```bash
restic -r /mnt/backup/repo dump latest /etc/nginx/nginx.conf
```

## Snapshots einhängen (FUSE)

`restic -r <repo> mount <mountpoint>` — Hängt alle Snapshots als virtuelles Dateisystem ein (erfordert FUSE). Durchstöbern mit einem Dateimanager.

```bash
restic -r /mnt/backup/repo mount /mnt/restic
```

`restic -r <repo> mount --snapshot-template <tpl> <mountpoint>` — Passt das Format des Verzeichnisnamens für jeden Snapshot an.

```bash
restic -r /mnt/backup/repo mount --snapshot-template '2006-01-02_15-04-05' /mnt/restic
```

## Vergessen & Prune (Retention-Policies)

`restic -r <repo> forget --keep-last <n>` — Behält nur die n jüngsten Snapshots.

```bash
restic -r /mnt/backup/repo forget --keep-last 7
```

`restic -r <repo> forget --keep-daily <n> --keep-weekly <n> --keep-monthly <n>` — Wendet eine Standard-Retention-Policy an: behält n tägliche, wöchentliche und monatliche Snapshots.

```bash
restic -r /mnt/backup/repo forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12
```

`restic -r <repo> forget --keep-daily 7 --keep-weekly 4 --keep-monthly 6 --prune` — Wendet die Retention-Policy an und entfernt sofort die nicht mehr referenzierten Daten. Destruktiv: löscht Daten endgültig – vorher mit `--dry-run` prüfen.

```bash
restic -r /mnt/backup/repo forget --keep-daily 7 --keep-weekly 4 --keep-monthly 6 --prune
```

`restic -r <repo> forget --dry-run --keep-daily 7` — Zeigt eine Vorschau, welche Snapshots entfernt würden, ohne tatsächlich zu löschen.

```bash
restic -r /mnt/backup/repo forget --dry-run --keep-daily 7
```

`restic -r <repo> forget --tag <tag> --keep-last 3` — Wendet die Retention-Policy nur auf Snapshots mit einem bestimmten Tag an.

```bash
restic -r /mnt/backup/repo forget --tag daily --keep-last 3
```

`restic -r <repo> prune` — Entfernt Daten aus dem Repository, die von keinem Snapshot mehr referenziert werden. Destruktiv: gibt belegten Speicher endgültig frei und kann nicht rückgängig gemacht werden.

```bash
restic -r /mnt/backup/repo prune
```

## Repository-Wartung

`restic -r <repo> check` — Prüft das Repository auf Fehler und verifiziert die Datenintegrität.

```bash
restic -r /mnt/backup/repo check
```

`restic -r <repo> check --read-data` — Verifiziert alle Daten, indem jede Pack-Datei gelesen und entschlüsselt wird (langsam, aber gründlich).

```bash
restic -r /mnt/backup/repo check --read-data
```

`restic -r <repo> check --read-data-subset=<n>/<total>` — Liest nur einen Bruchteil der Daten während der Prüfung. Nützlich für gestaffelte Verifizierung.

```bash
restic -r /mnt/backup/repo check --read-data-subset=1/10
```

`restic -r <repo> stats` — Zeigt Statistiken zum Repository (Gesamtgröße, deduplizierte Größe, Snapshot-Anzahl).

```bash
restic -r /mnt/backup/repo stats
```

`restic -r <repo> stats --mode raw-data` — Zeigt die belegte Festplattengröße aller im Repository gespeicherten Daten.

```bash
restic -r /mnt/backup/repo stats --mode raw-data
```

`restic -r <repo> key list` — Listet alle im Repository gespeicherten Verschlüsselungs-Schlüssel auf.

```bash
restic -r /mnt/backup/repo key list
```

`restic -r <repo> key add` — Fügt dem Repository ein weiteres Verschlüsselungs-Passwort hinzu.

```bash
restic -r /mnt/backup/repo key add
```

`restic -r <repo> rebuild-index` — Baut den Repository-Index neu auf. Bei verlorenem oder beschädigtem Index verwenden.

```bash
restic -r /mnt/backup/repo rebuild-index
```

`restic -r <repo> copy --repo2 <repo2>` — Kopiert alle Snapshots aus dem Repository in ein zweites Repository (3-2-1-Backup-Strategie).

```bash
restic -r /mnt/local/repo copy --repo2 sftp:user@offsite.com:/backup
```

## Umgebungsvariablen

`export RESTIC_REPOSITORY=<path>` — Setzt den Standard-Repository-Pfad, sodass -r entfallen kann.

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

`export RESTIC_PASSWORD=<password>` — Setzt das Repository-Passwort. Nützlich für unbeaufsichtigte Cron-Backups, aber das Passwort steht dann im Klartext in der Umgebung – besser RESTIC_PASSWORD_FILE oder RESTIC_PASSWORD_COMMAND nutzen.

```bash
export RESTIC_PASSWORD=mysecretpassword
```

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

```bash
export RESTIC_PASSWORD_FILE=/etc/restic/password.txt
```

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

```bash
export RESTIC_PASSWORD_COMMAND='pass show restic/main'
```

Authentifizierung für S3-kompatible Backends.

```bash
export AWS_ACCESS_KEY_ID=<key>
export AWS_SECRET_ACCESS_KEY=<secret>
```

Authentifizierung für das Backblaze-B2-Backend.

```bash
export B2_ACCOUNT_ID=<id>
export B2_ACCOUNT_KEY=<key>
```

## Praktische Rezepte

`restic -r <repo> backup --exclude-file ~/.resticignore --tag daily /home` — Tägliches Backup von /home mit Ausschlüssen und einem Tag für Retention-Policies.

```bash
restic -r /mnt/backup/repo backup --exclude-file ~/.resticignore --tag daily /home
```

`restic -r <repo> forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune` — Standard-Retention-Policy: 7 tägliche, 4 wöchentliche, 12 monatliche Snapshots.

```bash
restic -r /mnt/backup/repo forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune
```

`restic -r <repo> snapshots --json | jq '.[-1].id' -r` — Holt die ID des jüngsten Snapshots als reine Zeichenkette.

```bash
restic -r /mnt/backup/repo snapshots --json | jq '.[-1].id' -r
```

`restic -r <repo> backup <path> && restic -r <repo> forget --keep-daily 7 --prune` — Backup und Aufräumen alter Snapshots in einem Cron-Job-Befehl.

```bash
restic -r /mnt/backup/repo backup /home && restic -r /mnt/backup/repo forget --keep-daily 7 --prune
```

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

restic nimmt dir die schwierigen Teile eines Backup-Systems ab: Verschlüsselung, Deduplizierung und Snapshot-Verwaltung laufen transparent im Hintergrund, während dieselben Befehle für lokale Platten, SFTP und Cloud-Speicher funktionieren. Behandle das Repository-Passwort wie einen Generalschlüssel – ohne es sind deine Backups unwiderruflich verloren, deshalb gehören `RESTIC_PASSWORD` im Klartext und stattdessen `RESTIC_PASSWORD_FILE` oder `RESTIC_PASSWORD_COMMAND` in jede ernsthafte Einrichtung. Setze `forget --prune` und `prune` nur bewusst ein und prüfe sie zuvor mit `--dry-run`, denn sie löschen Daten endgültig.

## Weiterführende Links

- [restic – offizielle Dokumentation](https://restic.readthedocs.io/) – vollständiges Handbuch zu Repositories, Backends und Wiederherstellung (englisch)
- [restic.net](https://restic.net/) – offizielle Projektseite mit Überblick und Download (englisch)
- [restic – GitHub-Projekt](https://github.com/restic/restic) – Quellcode, Releases und Issue-Tracker (englisch)
<!-- PROSE:outro:end -->

## Verwandte Kommandos

- [borgbackup](https://www.jpkc.com/db/cheatsheets/backup-sync/borgbackup/) – deduplizierendes, komprimierendes Backup mit verschlüsselten Repositories
- [duplicity](https://www.jpkc.com/db/cheatsheets/backup-sync/duplicity/) – inkrementelle, GPG-verschlüsselte Backups auf viele Speicherziele
- [rclone](https://www.jpkc.com/db/cheatsheets/backup-sync/rclone/) – synchronisiert Dateien mit Dutzenden Cloud-Speicheranbietern