Initial vault setup

2026-06-09 18:40:21 +02:00
commit bda02d587f
3692 changed files with 402457 additions and 0 deletions
@@ -0,0 +1,208 @@
+---
+title: restic
+created: 2026-06-07
+updated: 2026-06-07
+type: app
+tags: [catalogue, backups, deduplication, encryption, cloud, s3, b2, sftp, s3, restic, snapshot, incremental, versionning, cli, docker, go]
+confidence: high
+contested: false
+sources: [https://selfh.st/apps/?tag=Backups, https://github.com/restic/restic]
+---
+
+# 💾 restic
+
+> **Le standard de facto des backups chiffrés et dédupliqués en ligne de commande** : rapide, sécurisé, multi-backend, et son format de repo ouvert a inspiré toute une génération d'outils.
+
+## 📋 Informations Générales
+
+| Champ | Valeur |
+| :--- | :--- |
+| **Site web** | [restic.net](https://restic.net) |
+| **GitHub** | [restic/restic](https://github.com/restic/restic) |
+| **License** | BSD-2-Clause |
+| **Langage** | Go |
+| **Étoiles GitHub** | 33,9k ⭐ |
+| **Dernière MAJ** | 2026-06-05 |
+| **Catégorie** | [[cat-backups|Backups]] |
+
+## 📝 Description
+
+**restic** est un programme de sauvegarde **open source**, écrit en Go, conçu dès l'origine pour être à la fois **rapide**, **sécurisé** et **efficace**. Son auteur, Alexander Neumann, a voulu résoudre les trois défauts majeurs des outils traditionnels (`tar`, `rsync`) : pas de chiffrement natif, pas de déduplication, et des restaurations complexes.
+
+Le secret de restic tient à son architecture en **content-addressed storage** : chaque fichier sauvegardé est découpé en **blobs** découpés selon un algorithme CDC (Content-Defined Chunking, *buzhash* par défaut), puis chaque blob est identifié par son **hash SHA-256**. Deux fichiers identiques, ou deux versions d'un même fichier qui partagent ne serait-ce qu'un seul bloc, ne stockent physiquement qu'**une seule copie** du blob en question. Le résultat est une déduplication **transversale** (entre snapshots) extrêmement efficace, particulièrement sur les workloads de photos, bases de données ou arborescences de code source.
+
+Côté sécurité, **toutes les données sont chiffrées côté client** avec **AES-256-CTR** (mode *ctr*) avant d'être envoyées au backend. L'authentification et l'intégrité reposent sur le hash **SHA-256** des chunks et une **authentification polynomiale** (Poly1305-AES) par fichier. Sans le **mot de passe du repository** (et éventuellement le *keyfile* ou les *key files* ajoutés à un repo), les blobs sont mathématiquement irrécupérables. C'est une propriété essentielle : même le fournisseur de stockage (S3, B2, SFTP…) n'a aucun accès au contenu.
+
+restic supporte nativement une quantité impressionnante de **backends** : `local`, `sftp`, `s3` (et donc AWS S3, MinIO, Wasabi, Backblaze B2, Scaleway, OVH, etc.), `b2` (API native Backblaze B2), `azure`, `gs` (Google Cloud Storage), `rclone` (et donc tout ce que rclone supporte : WebDAV, S3-compatible, Google Drive, OneDrive, etc.), `rest` (son propre serveur HTTP), et même un mode `stdio` pour les pipes. Cette polyvalence explique pourquoi il est devenu **le** backend d'orchestrateurs comme [[app-backrest]], [[app-kopia]] (en mode repo), ou des solutions SaaS comme [[app-borgbase]] (qui héberge des repos restic et Borg clé-en-main).
+
+Comparé à ses principaux rivaux :
+- **vs [[app-borg|Borg]]** : restic est plus simple à mettre en place, plus rapide à froid (pas de cache local obligatoire), son format est **simple et ouvert** (on peut l'inspecter avec un peu de Python), mais Borg offre historiquement une compression et une vitesse de reconstitution supérieures. Voir [[app-borg]] pour les détails.
+- **vs [[app-kopia|Kopia]]** : Kopia offre une **UI desktop** et des **snapshot policies** plus riches nativement, mais restic reste plus minimaliste, plus scriptable, et dispose d'un écosystème d'orchestration plus large.
+- **vs [[app-duplicati|Duplicati]]** : Duplicati propose une UI web prête à l'emploi, mais repose sur des technologies web plus lourdes (.NET / Mono) et souffre d'une base d'utilisateurs vieillissante ; restic est le choix des sysadmins qui aiment la ligne de commande et les **formats ouverts**.
+
+**Public cible** : **intermédiaire à avancé**. Débutants motivés acceptables (un `restic init && restic backup /home` suffit pour démarrer), mais la pleine puissance (pruning, hooks, `forget --keep-*`) demande un peu de lecture.
+
+## 🚀 Installation
+
+### Option 1 : Docker Compose (orchestrateur générique)
+
+restic n'a pas besoin d'être servi via Docker pour fonctionner — c'est un **binaire** qu'on invoque dans des cron, des scripts ou des conteneurs *one-shot*. On le déploie souvent via un conteneur dédié qui exécute les sauvegardes.
+
+```yaml
+# docker-compose.yml
+version: '3.8'
+services:
+  restic:
+    image: restic/restic:latest
+    container_name: restic-backup
+    restart: unless-stopped
+    environment:
+      - RESTIC_REPOSITORY=s3:s3.eu-west-3.amazonaws.com/mon-bucket-backups
+      - AWS_ACCESS_KEY_ID=AKIAxxxxxxxxxxxxxxxx
+      - AWS_SECRET_ACCESS_KEY=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
+      - RESTIC_PASSWORD_FILE=/run/secrets/restic_password
+    secrets:
+      - restic_password
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      - /mnt/data:/data:ro
+      - restic-cache:/root/.cache/restic
+    command: >
+      sh -c "restic snapshots && restic check"
+    labels:
+      - "traefik.enable=false"
+
+  restic-ui:
+    # Backrest : interface web pour piloter plusieurs repos restic
+    image: garethgeorge/backrest:latest
+    container_name: backrest
+    restart: unless-stopped
+    volumes:
+      - /var/run/docker.sock:/var/run/docker.sock:ro
+      - backrest-data:/data
+      - /mnt/backups:/mnt/backups
+    ports:
+      - "9898:9898"
+    environment:
+      - BACKREST_DATA=/data
+    labels:
+      - "traefik.enable=true"
+      - "traefik.http.routers.backrest.rule=Host(`backrest.example.com`)"
+      - "traefik.http.routers.backrest.entrypoints=websecure"
+      - "traefik.http.routers.backrest.tls.certresolver=letsencrypt"
+
+secrets:
+  restic_password:
+    file: ./secrets/restic_password.txt
+
+volumes:
+  restic-cache:
+  backrest-data:
+```
+
+### Option 2 : Binaire natif (recommandé sur l'hôte)
+
+```bash
+# Linux (méthode officielle)
+sudo apt install restic      # Debian/Ubuntu
+sudo dnf install restic      # Fedora/RHEL
+brew install restic          # macOS
+
+# Vérification de l'installation
+restic version
+
+# Exemple d'init d'un repo S3
+export AWS_ACCESS_KEY_ID=...
+export AWS_SECRET_ACCESS_KEY=...
+export RESTIC_REPOSITORY=s3:s3.eu-west-3.amazonaws.com/mon-bucket
+export RESTIC_PASSWORD='un-très-long-mot-de-passe-généré-avec-passphrase-generator'
+
+restic init
+```
+
+## ⚙️ Configuration Initiale
+
+1. **Choisir et préparer le backend** : créer un bucket S3, un bucket B2, ou un répertoire local/SFTP. Récupérer les credentials (clé d'accès + secret) et noter le endpoint et la région. Le compte de stockage utilisé par restic doit avoir un **droit de lecture + écriture + list** (et `DeleteObject` pour le `prune`).
+2. **Générer un mot de passe de repo fort** : `pwgen -s 64 1` ou `gpg --gen-random --armor 1 32`. **Sauvegarder ce mot de passe ailleurs** (gestionnaire de mots de passe type Bitwarden/Vaultwarden, papier dans un coffre, etc.) — c'est le **seul moyen** de restaurer.
+3. **Initialiser le repo** : `restic -r s3:bucket/chemin init`. Vérifier qu'un fichier `config` est bien créé côté backend.
+4. **Premier backup test** : `restic -r s3:bucket/chemin backup /chemin/important`. Inspecter la sortie, vérifier qu'aucune erreur n'apparaît, et lister : `restic snapshots`.
+5. **Automatiser** : ajouter un cron `0 3 * * * restic backup /home /etc /var/lib --tag daily && restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 6 --prune`. Le `--prune` libère réellement l'espace (sans lui, les blobs orphelins restent sur le backend).
+6. **Tester la restauration** : sur une machine vierge ou un dossier temporaire, `restic restore latest --target /tmp/restore` puis comparer avec un diff. Les backups non testés ne sont **pas** des backups.
+
+## 🔄 Alternatives
+
+### Open Source
+
+- [[app-borg]] — Plus ancien (2010), format fermé, compression lz4/zstd/lzma, plus rapide sur de gros volumes locaux, mais format non interopérable.
+- [[app-kopia]] — UI desktop intégrée, snapshot policies déclaratives, support multi-cloud, format propriétaire (mais ouvert en lecture).
+- [[app-duplicati]] — UI web clé en main, multi-backend, idéal pour les non-techniciens, mais projet en perte de vitesse.
+- [[app-backrest]] — Orchestrateur web moderne **au-dessus de restic** : si vous aimez restic mais voulez une UI.
+- **rclone** — Pas un backup tool, mais le backend universel ; très complémentaire de restic via `rclone:`.
+
+### Comparaison des outils CLI / orchestrables
+
+| Critère | restic | [[app-borg]] | [[app-kopia]] | [[app-duplicati]] |
+| :--- | :--- | :--- | :--- | :--- |
+| Langage | Go | Python (C ext.) | Go | C# / Mono |
+| Déduplication | Bloc (CDC) | Bloc (fixed + variable) | Bloc (CDC) | Bloc |
+| Chiffrement | AES-256-CTR + Poly1305 | AES-256-OCB | AES-256-GCM | AES-256 |
+| Compression | Non (délibéré) | lz4 / zstd / lzma | Non (délibéré) | zstd |
+| UI native | Non (CLI pur) | Non (BorgWeb / [[app-borg-ui]]) | UI desktop | UI web |
+| Backends | 12+ natifs | local, ssh, sftp, rclone | local, S3, B2, GCS, Azure, SFTP | 20+ (S3, B2, GCS, SSH, WebDAV…) |
+| Format du repo | Ouvert, simple | Borg (spécifique) | Kopia (propriétaire) | Duplicati (propriétaire) |
+| Licence | BSD-2-Clause | BSD-3-Clause | Apache-2.0 | LGPL-2.1 |
+| Pruning intégré | `forget --prune` | `prune` | `policy` | Intégré UI |
+
+**Verdict** : restic est le **couteau suisse** des backups modernes. Si vous êtes à l'aise avec la CLI et que vous voulez un **format simple, ouvert et bien outillé**, c'est le choix par défaut. Pour une UI prête à l'emploi, regardez [[app-kopia]] (desktop) ou [[app-backrest]] (web au-dessus de restic).
+
+### Propriétaires (ce que restic remplace)
+
+- **BorgBase** — SaaS qui héberge des repos restic/Borg. Pas propriétaire du moteur, mais propriétaire de l'infrastructure.
+- **Arq Backup** — Outil macOS/Windows propriétaire, excellent pour les postes单人, mais pas self-hostable.
+- **Backblaze Personal** — Backup cloud infini clé en main, mais chiffré côté serveur (pas E2E).
+- **Veeam** — Standard entreprise pour VM, mais licence hors de prix pour un homelab.
+- **Acronis True Image** — Référence grand public, propriétaire, fermé.
+
+### Backends de stockage (côté *où* on stocke)
+
+| Service | Coût (~$ / To / mois) | Hot tier | Egress | Idéal pour |
+| :--- | :--- | :--- | :--- | :--- |
+| **Backblaze B2** | 6 $ | Oui | 10 $ / To | Homelab, petits volumes |
+| **Wasabi** | 7 $ (pas d'egress) | Oui | 0 $ | Backups volumineux, lectures fréquentes |
+| **AWS S3 Standard** | 23 $ | Oui | 90 $ / To | Pro, intégration AWS |
+| **AWS S3 Glacier IR** | 3,9 $ | Oui (latence ms) | 10 $ / To | Archives consultées rarement |
+| **AWS S3 Glacier Deep Archive** | 0,99 $ | Non (12h) | 0,10 $ / To | Cold storage long terme |
+| **Scaleway Object Storage** | 7,5 $ | Oui | 0,01 € / Go | EU, souverain |
+| **OVH Object Storage** | 7,2 € | Oui | trafic sortant facturé | EU |
+| **MinIO** (self-hosted) | Coût serveur | Oui | 0 $ | 100% on-prem |
+
+## 🔐 Sécurité
+
+- **Chiffrement at-rest et in-transit** : AES-256-CTR + Poly1305 côté client, TLS pour le transport vers le backend. Le fournisseur de stockage ne voit jamais les données en clair.
+- **Mot de passe du repository** : c'est la **clé du royaume**. Le sauvegarder dans un gestionnaire de mots de passe (Bitwarden, KeePassXC, Vaultwarden self-hosted) **hors-ligne** sur au moins deux supports distincts. **Un repo dont on a perdu le mot de passe est une poubelle chiffrée**.
+- **Règle 3-2-1** : 3 copies des données, sur **2 supports différents**, dont **1 offsite** (ex. : home NAS + disque USB local + B2/Wasabi dans le cloud).
+- **Test de restauration régulier** : programmer un job mensuel qui restaure un snapshot au hasard sur un serveur de test et vérifie son intégrité (`restic check` couvre la cohérence des blobs, mais pas leur *lisibilité applicative*).
+- **Air-gapped backup** : un disque USB branché une fois par mois pour un backup `local`, puis débranché. C'est l'ultime défense contre un rançongiciel qui chiffrerait aussi les partages réseau et les credentials S3.
+- **Rétention vérifiée** : `restic check` lit **tous** les blobs et vérifie leur intégrité cryptographique. À lancer au moins une fois par mois (c'est lourd en I/O, ne pas le faire pendant la fenêtre de backup).
+
+## 📚 Ressources
+
+- [Site officiel restic.net](https://restic.net)
+- [Documentation officielle](https://restic.readthedocs.io/)
+- [GitHub restic/restic](https://github.com/restic/restic)
+- [Forum communautaire](https://forum.restic.net/)
+- [Design principles (lecture recommandée)](https://restic.readthedocs.io/en/latest/080_design.html)
+
+## Pages Liées
+
+- [[cat-backups]] — Catégorie Backups
+- [[strategie-backup-321]] — La règle 3-2-1 expliquée
+- [[app-borg]] — Concurrent historique, format fermé
+- [[app-kopia]] — Concurrent avec UI desktop
+- [[app-duplicati]] — Concurrent avec UI web
+- [[app-backrest]] — UI web moderne *au-dessus* de restic
+- [[app-borg-ui]] — UI web pour Borg
+- [[app-portainer]] — Pour visualiser les conteneurs qui tournent
+- [[app-traefik]] — Reverse-proxy pour exposer l'UI Backrest
+- [[securisation-home-lab]] — Bonnes pratiques de sécurité
+- [[glossaire-homelab]] — Définitions (CAS, S3, B2, etc.)