Télécharger un fichier depuis Internet ne garantit pas à lui seul qu’il provient bien de la source attendue ni qu’il n’a pas été modifié. Sous Linux, deux mécanismes complémentaires permettent d’effectuer ces vérifications : les sommes de contrôle pour l’intégrité et les signatures GPG pour l’authenticité.

GPG (GNU Privacy Guard) utilise la cryptographie asymétrique avec une clé privée et une clé publique. Une distribution Linux, un développeur ou un projet peut ainsi signer un fichier, une archive ou un fichier de sommes de contrôle comme SHA256SUMS. L’utilisateur peut ensuite vérifier cette signature avec la clé publique correspondante.

Dans ce guide, vous allez voir comment installer GnuPG sous Linux, importer et vérifier une clé publique, contrôler la signature d’un fichier avec gpg, vérifier une signature .sig ou .asc, valider une image ISO avec SHA256SUMS et comprendre les messages comme “Good signature”.

Nous verrons également comment distinguer intégrité et authenticité, et pourquoi il est important de vérifier l’empreinte de la clé publique avant de lui faire confiance.

Guide connexe : Vérifier la somme de contrôle d’un fichier sous Linux (MD5, SHA1, SHA256)

Qu’est-ce qu’une signature GPG ?

Une signature GPG permet de vérifier qu’un fichier ou un message provient bien de la personne ou de l’organisation qui affirme l’avoir publié, et qu’il n’a pas été modifié depuis sa signature.

GPG (GNU Privacy Guard, ou GnuPG) repose sur la cryptographie asymétrique, avec une paire de clés :

• une clé privée, conservée secrètement par son propriétaire et utilisée pour créer la signature ;
• une clé publique, distribuée aux utilisateurs afin qu’ils puissent vérifier cette signature.

Lorsqu’un développeur ou une distribution Linux signe un fichier, GPG calcule une empreinte du contenu puis crée une signature à l’aide de la clé privée.

L’utilisateur peut ensuite vérifier cette signature avec la clé publique correspondante.

Par exemple :

gpg --verify fichier.iso.sig fichier.iso

Si la vérification réussit, GPG indique que la signature est valide et précise quelle clé a été utilisée.

Une signature GPG apporte donc deux informations importantes :

• l’intégrité : le contenu signé n’a pas été modifié depuis la création de la signature ;
• l’authenticité : la signature a été créée avec la clé privée correspondant à la clé publique utilisée pour la vérification.

Cela va plus loin qu’une simple somme de contrôle SHA256. Un hash permet de vérifier qu’un fichier correspond à une empreinte donnée, mais si un attaquant parvient à remplacer à la fois le fichier et le hash publié, cette comparaison ne suffit plus.

Avec une signature GPG, l’attaquant devrait également disposer de la clé privée du signataire pour produire une nouvelle signature valide.

Il reste toutefois une étape essentielle : s’assurer que la clé publique utilisée pour la vérification appartient réellement à l’éditeur. Pour cela, il faut notamment vérifier son empreinte (fingerprint) à partir d’une source officielle.

Les signatures GPG sont ainsi couramment utilisées pour vérifier des images ISO Linux, des archives, des paquets logiciels ou des fichiers de sommes de contrôle comme SHA256SUMS.

Installer GnuPG sous Linux

GnuPG est disponible dans les dépôts de la plupart des distributions Linux. Le paquet s’appelle généralement gnupg ou gnupg2.

Sous Debian, Ubuntu et leurs dérivées :

sudo apt update
sudo apt install gnupg

Sous Fedora :

sudo dnf install gnupg2

Sous Arch Linux et dérivées :

sudo pacman -S gnupg

Une fois l’installation terminée, vérifiez que GPG fonctionne avec :

gpg --version

La commande affiche la version installée ainsi que les principaux algorithmes pris en charge.

Vous pouvez ensuite afficher le contenu du trousseau de clés avec :

gpg --list-keys

Si aucune clé n’a encore été importée, la liste peut être vide.

Pour la vérification de signatures, il n’est pas nécessaire de créer votre propre paire de clés. Il suffit généralement d’importer la clé publique de l’éditeur ou de la distribution dont vous souhaitez vérifier les fichiers.

La prochaine étape consiste donc à récupérer puis importer cette clé publique dans GnuPG.

Importer une clé publique GPG

Pour vérifier une signature GPG, vous devez disposer de la clé publique du signataire. Cette clé permet à GnuPG de vérifier qu’une signature a bien été créée avec la clé privée correspondante.

Il existe principalement trois façons de récupérer cette clé publique.

Télécharger directement le fichier de clé publique

De nombreux projets publient leur clé sous la forme d’un fichier .asc, .gpg ou similaire.

Par exemple :

gpg --import cle-publique.asc

C’est souvent la méthode la plus simple lorsque le site officiel fournit directement la clé.

Après l’import, vérifiez sa présence avec :

gpg --list-keys

Récupérer la clé depuis un serveur de clés

Voici les étapes pour récupérer la clé publique avec cette méthode :

Si vous connaissez l’identifiant de la clé, vous pouvez la télécharger depuis un serveur de clés :

gpg --keyserver hkp://keyserver.ubuntu.com --recv-keys ID_DE_LA_CLE

Le serveur de clés à utiliser dépend du projet. Il vaut mieux utiliser celui indiqué par la documentation officielle plutôt qu’un serveur choisi au hasard.

Dans le cas d’Ubuntu, par exemple, le serveur keyserver.ubuntu.com peut être utilisé.

Si vous ne connaissez pas encore l’identifiant de la clé, tentez d’abord de vérifier la signature :

gpg --keyid-format long --verify SHA256SUMS.gpg SHA256SUMS

GPG peut alors afficher :

gpg: Signature faite le jeu. 27 août 2026 22:43:09 UTC
gpg:  avec la clef RSA 843938DF228D22F7B3742BC0D94AA3F0EFE21092
gpg: Impossible de vérifier la signature : Pas de clef publique

La ligne using RSA key indique l’identifiant de la clé manquante. Vous pouvez ensuite la récupérer :

gpg --keyserver hkp://keyserver.ubuntu.com \
    --recv-keys 843938DF228D22F7B3742BC0D94AA3F0EFE21092

Une fois la clé importée, vérifiez son empreinte :

gpg --fingerprint 843938DF228D22F7B3742BC0D94AA3F0EFE21092

Suivre la méthode indiquée par le projet

Certains projets ne passent pas par un serveur de clés et fournissent leurs propres instructions : téléchargement direct d’une clé, paquet contenant le trousseau de clés, dépôt officiel, ou autre mécanisme.

Dans ce cas, suivez de préférence la méthode publiée par l’éditeur ou la distribution. C’est la meilleure façon d’éviter d’importer une clé non officielle ou périmée.

Quelle que soit la méthode utilisée, ne faites pas confiance à la clé uniquement parce qu’elle a été importée avec succès. Vérifiez ensuite son empreinte numérique avec :

gpg --fingerprint ID_DE_LA_CLE

Puis comparez-la avec celle publiée sur une source officielle.

Vérifier l’empreinte d’une clé publique

Avant d’utiliser une clé publique GPG pour vérifier une signature, il est important de contrôler son empreinte numérique, appelée fingerprint.

Cette empreinte est un identifiant unique associé à la clé. Elle permet de vérifier que la clé importée est bien celle publiée par l’éditeur, la distribution Linux ou le développeur concerné.

Pour afficher l’empreinte d’une clé :

gpg --fingerprint <ID_DE_LA_CLE>

Vous pouvez aussi afficher les empreintes de toutes les clés présentes dans votre trousseau :

gpg --fingerprint

GPG affiche alors une longue suite de caractères hexadécimaux, par exemple :

0123 4567 89AB CDEF 0123  4567 89AB CDEF 0123 4567

Comparez cette valeur avec l’empreinte publiée sur une source officielle : site du projet, documentation de la distribution, page de téléchargement ou autre canal de confiance.

Les deux empreintes doivent correspondre exactement.

Cette vérification est importante, car télécharger une clé depuis un serveur de clés ne suffit pas à prouver qu’elle appartient réellement à la personne ou au projet attendu. Un serveur de clés permet surtout de distribuer les clés, pas d’en garantir l’identité.

Une fois l’empreinte vérifiée, vous pouvez utiliser cette clé publique pour contrôler les signatures GPG des fichiers téléchargés.

Par exemple, pour afficher également l’identifiant court et l’empreinte dans un format plus lisible pour les scripts :

gpg --with-colons --fingerprint <ID_DE_LA_CLE>

Si l’empreinte ne correspond pas à celle publiée officiellement, n’utilisez pas la clé et récupérez-la à nouveau depuis une source fiable.

Vérifier la signature GPG d’un fichier

Une fois la clé publique du signataire importée et son empreinte vérifiée, vous pouvez utiliser GnuPG pour contrôler la signature d’un fichier.

Le cas le plus courant est celui d’une signature détachée, fournie dans un fichier séparé comme .sig, .asc ou .gpg.

Par exemple, si vous disposez de :

fichier.iso
fichier.iso.sig

utilisez :

gpg --verify fichier.iso.sig fichier.iso

GPG vérifie alors que la signature correspond bien au contenu du fichier et qu’elle a été créée avec la clé privée associée à la clé publique présente dans votre trousseau.

Si la vérification réussit, vous obtenez un message du type :

gpg: Good signature from "Nom du signataire"

Cela signifie que le fichier n’a pas été modifié depuis sa signature.

Attention toutefois : un message Good signature confirme que la signature est techniquement valide, mais il faut encore s’assurer que la clé utilisée appartient bien à la personne ou au projet attendu. C’est pourquoi la vérification préalable de l’empreinte de la clé publique reste indispensable.

Si le fichier a été modifié ou si la signature ne correspond pas, GPG affiche au contraire un message comme :

gpg: BAD signature from "Nom du signataire"

Dans ce cas, n’utilisez pas le fichier avant d’avoir vérifié son origine ou effectué un nouveau téléchargement.

Vérifier une signature détachée .sig ou .asc

Lorsque la signature est intégrée directement dans un fichier signé, GPG peut parfois déterminer automatiquement le contenu à vérifier, mais pour les téléchargements logiciels et images ISO, la signature détachée reste le cas le plus fréquent.

Une signature détachée est stockée dans un fichier séparé du fichier d’origine. Elle porte souvent l’extension .sig, .asc ou parfois .gpg.

Par exemple :

logiciel.tar.xz
logiciel.tar.xz.asc

ou :

image.iso
image.iso.sig

Pour vérifier une signature détachée, utilisez :

gpg --verify fichier.sig fichier

Par exemple :

gpg --verify logiciel.tar.xz.asc logiciel.tar.xz

ou :

gpg --verify image.iso.sig image.iso

GPG contrôle alors deux éléments :

• que la signature correspond bien au fichier ;
• que cette signature a été créée avec une clé privée correspondant à une clé publique présente dans votre trousseau.

Si la signature est valide, GPG affiche un message comme :

gpg: Good signature from "Nom du signataire"

Si le fichier a été modifié ou si la signature ne correspond pas :

gpg: BAD signature from "Nom du signataire"

L’extension .asc indique généralement une signature encodée en ASCII, tandis qu’un fichier .sig peut contenir une signature binaire. Dans les deux cas, la commande gpg --verify fonctionne de la même manière.

Il est également fréquent que la signature porte simplement le même nom que le fichier d’origine avec une extension supplémentaire. Cela facilite l’identification du fichier à vérifier.

Enfin, même avec une Good signature, vérifiez toujours que l’empreinte de la clé publique correspond bien à celle publiée par l’éditeur. Une signature valide n’est utile que si vous faites confiance à la bonne clé.

Vérifier une image ISO Linux avec SHA256SUMS et GPG

Certaines distributions Linux publient plusieurs fichiers permettant de vérifier leurs images ISO :

• l’image ISO elle-même ;
• un fichier de sommes de contrôle, par exemple SHA256SUMS ;
• une signature GPG de ce fichier, par exemple SHA256SUMS.gpg ou SHA256SUMS.sign.

La vérification se fait alors en deux étapes.

Commencez par vérifier la signature du fichier SHA256SUMS :

gpg --verify SHA256SUMS.gpg SHA256SUMS

Si la signature est valide, GPG indique qu’elle a été créée avec une clé connue de votre trousseau.

Vous pouvez ensuite vérifier l’image ISO avec :

sha256sum -c SHA256SUMS

Si l’empreinte correspond :

ubuntu.iso: OK

Cette procédure apporte deux niveaux de vérification :

• GPG permet de vérifier que le fichier SHA256SUMS a bien été signé avec la clé privée correspondant à la clé publique importée ;
• SHA256 permet de vérifier que l’image ISO correspond exactement à l’empreinte contenue dans SHA256SUMS.

Il faut toutefois avoir vérifié au préalable que l’empreinte de la clé publique GPG correspond bien à celle publiée par la distribution Linux.

Le flux complet est donc :

Cette méthode est plus robuste qu’une simple comparaison du hash affiché sur une page web, car elle ajoute une vérification cryptographique de l’origine du fichier contenant les sommes de contrôle.

La procédure exacte peut varier selon la distribution. Certaines utilisent SHA256SUMS.gpg, d’autres .sig, .sign ou .asc, mais le principe reste le même.

Vérifier manuellement la signature d’un dépôt APT avec GPG

APT vérifie normalement automatiquement les dépôts configurés avec apt update, en contrôlant la signature du fichier Release ou InRelease. Il est néanmoins possible de reproduire cette vérification manuellement avec GPG, ce qui peut être utile pour comprendre la chaîne de confiance d’un dépôt.

Commencez par récupérer les métadonnées du dépôt, par exemple :

wget https://exemple.org/dists/stable/Release
wget https://exemple.org/dists/stable/Release.gpg

Vous devez ensuite disposer de la clé publique utilisée pour signer le dépôt. Importez-la dans votre trousseau GPG, par exemple :

gpg --import depot-public-key.asc

Vérifiez ensuite son empreinte :

gpg --fingerprint ID_DE_LA_CLE

Comparez cette empreinte avec celle publiée sur le site officiel du dépôt.

Une fois la clé validée, vérifiez la signature du fichier Release :

gpg --verify Release.gpg Release

Si tout est correct, GPG affiche notamment :

gpg: Good signature from "Nom du dépôt"

Certains dépôts utilisent plutôt un fichier InRelease, qui contient directement les métadonnées et leur signature OpenPGP. Dans ce cas :

gpg --verify InRelease

APT effectue normalement cette vérification automatiquement. Pour les dépôts tiers modernes, il est recommandé d’associer explicitement leur clé avec Signed-By et de placer les clés gérées localement dans /etc/apt/keyrings/, plutôt que d’utiliser apt-key, désormais déprécié.

Par exemple :

deb [signed-by=/etc/apt/keyrings/exemple.gpg] https://exemple.org/debian stable main

Ainsi, APT n’accepte ce dépôt que si ses métadonnées sont signées avec une clé présente dans le trousseau indiqué.

Que signifient « Good signature » et les avertissements GPG ?

Lors d’une vérification avec gpg --verify, GnuPG affiche plusieurs messages qui permettent de savoir si la signature est valide et si la clé utilisée est considérée comme fiable.

Le message le plus important est :

gpg: Good signature from "Nom du signataire"

Cela signifie que la signature correspond bien au fichier vérifié et qu’elle a été créée avec la clé privée associée à la clé publique présente dans votre trousseau.

En revanche, cela ne signifie pas automatiquement que vous pouvez faire confiance à cette clé.

GPG peut par exemple afficher :

gpg: WARNING: This key is not certified with a trusted signature!
gpg:          There is no indication that the signature belongs to the owner.

Ce message signifie que la signature est techniquement correcte, mais que GPG ne peut pas garantir que la clé publique appartient réellement à la personne ou au projet indiqué.

C’est pourquoi il faut vérifier l’empreinte de la clé publique auprès d’une source officielle.

À l’inverse, si GPG affiche :

gpg: BAD signature from "Nom du signataire"

la signature ne correspond pas au fichier. Celui-ci a pu être modifié, corrompu ou ne pas correspondre à la signature téléchargée.

Vous pouvez aussi rencontrer un message du type :

gpg: Can't check signature: No public key

Dans ce cas, la signature est présente, mais la clé publique nécessaire à sa vérification n’a pas encore été importée.

Enfin, GPG affiche généralement l’identifiant ou l’empreinte de la clé utilisée. Vérifiez cette valeur avec :

gpg --fingerprint ID_DE_LA_CLE

En résumé :

Une Good signature est donc nécessaire, mais elle doit être associée à une clé publique dont l’empreinte a été vérifiée auprès d’une source de confiance.

Supprimer ou gérer les clés du trousseau GPG

Au fil du temps, votre trousseau GPG peut contenir plusieurs clés publiques importées pour vérifier des signatures. Vous pouvez les afficher, exporter ou supprimer selon vos besoins.

Pour lister les clés publiques présentes dans le trousseau :

gpg --list-keys

Pour afficher également leur empreinte :

gpg --fingerprint

Si vous souhaitez obtenir plus de détails sur une clé précise :

gpg --list-keys ID_DE_LA_CLE

Pour supprimer une clé publique devenue inutile :

gpg --delete-key ID_DE_LA_CLE

GPG vous demande une confirmation avant de retirer la clé du trousseau.

Si vous gérez aussi vos propres clés privées, leur suppression doit être effectuée séparément :

gpg --delete-secret-key ID_DE_LA_CLE

Attention : supprimer une clé privée peut vous empêcher de déchiffrer d’anciens fichiers ou de créer de nouvelles signatures avec cette identité. Sauvegardez-la avant toute suppression si elle vous appartient encore.

Vous pouvez également exporter une clé publique afin de la sauvegarder ou de la transférer vers une autre machine :

gpg --export --armor ID_DE_LA_CLE > cle-publique.asc

Pour une clé privée :

gpg --export-secret-keys --armor ID_DE_LA_CLE > cle-privee.asc

Conservez évidemment les exports de clés privées dans un emplacement sécurisé.

Enfin, si vous avez importé plusieurs clés portant des noms similaires, utilisez toujours leur empreinte complète pour les identifier sans ambiguïté avant de les supprimer ou de les exporter.

Intégrité et authenticité : quelle différence ?

Lorsqu’on vérifie un fichier téléchargé, il faut distinguer deux notions : l’intégrité et l’authenticité.

L’intégrité consiste à vérifier que le fichier n’a pas été modifié ou corrompu. Pour cela, on utilise généralement une somme de contrôle comme SHA256.

Par exemple :

sha256sum -c SHA256SUMS

Si le résultat affiche :

ubuntu.iso: OK

cela signifie que le fichier correspond bien à l’empreinte enregistrée dans SHA256SUMS.

Mais cette vérification ne prouve pas que le fichier SHA256SUMS lui-même provient bien de l’éditeur officiel.

C’est là qu’intervient l’authenticité.

Une signature GPG permet de vérifier que le fichier de sommes de contrôle, ou le fichier lui-même, a été signé avec la clé privée correspondant à une clé publique connue.

Par exemple :

gpg --verify SHA256SUMS.gpg SHA256SUMS

Si la signature est valide et que vous avez vérifié l’empreinte de la clé publique auprès d’une source officielle, vous pouvez alors avoir davantage confiance dans l’origine du fichier.

On peut résumer ainsi :

Pour une image ISO Linux, la méthode la plus complète consiste donc à :

• vérifier l’empreinte de la clé publique GPG ;
• vérifier la signature GPG du fichier SHA256SUMS ;
• vérifier ensuite l’image ISO avec sha256sum -c.

Ainsi, SHA256 vérifie le contenu, tandis que GPG permet de vérifier l’origine de la référence utilisée pour ce contrôle.

Ressources utiles et articles liés

• Qu’est-ce qu’une somme de contrôle (checksum) et à quoi cela sert ?
• Vérifier la somme de contrôle d’un fichier sous Windows 11/10 (MD5, SHA1, SHA256)
• Vérifier la somme de contrôle d’un fichier sous Linux (MD5, SHA1, SHA256)
• 10 meilleurs logiciels pour calculer le hash d’un fichier sous Windows
• hashcat : cracker des hashs, empreintes MD5, SHA1, SHA256
• Certificats électroniques et signatures numériques : fonctionnement et sécurité
• Signature numérique des fichiers sur Windows et sécurité
• Le chiffrement (cryptage) des données : comment ça marche et pourquoi l’utiliser
• Résoudre CMOS checksum error au démarrage du PC

L’article Vérifier la signature GPG d’un fichier sous Linux : gpg, clés publiques et empreintes est apparu en premier sur malekal.com.

Trois actualités à retenir cette semaine dans le cyberespace : une cyberattaque qui prive de télésurveillance les nouveaux pacemakers d'un géant de la santé, l'infrastructure de Linux à bout de souffle face aux scrapers IA, et des sessions Claude piratées qui alimentent un marché parallèle.

Trois actualités à retenir cette semaine dans le cyberespace : une cyberattaque qui prive de télésurveillance les nouveaux pacemakers d'un géant de la santé, l'infrastructure de Linux à bout de souffle face aux scrapers IA, et des sessions Claude piratées qui alimentent un marché parallèle.

Source

Source

Linux, une série de correctifs apporte un premier support USB 4 et Thunderbolt aux puces M1, M2 et M3 d'Apple.

Cet article Linux et les processeurs Apple, l’USB4 et le Thunderbolt arrivent sur les puces M1, M2 et M3 a été publié en premier par GinjFo.

Source

De nouveaux correctifs Linux détaillent la gestion CPPC des futurs Ryzen Zen 6. AMD utilise trois valeurs de fréquence de référence, 5025, 3524 et 2399 MHz.

Cet article Zen 6 : Linux révèle l’écart de performances entre les trois types de cœurs d’AMD a été publié en premier par GinjFo.

Une série de 19 patchs apporte l'USB4 et le Thunderbolt aux Mac M1, M2 et M3 sous Linux. Mais les écrans externes et les boîtiers PCIe devront encore patienter.

Le post Le Thunderbolt arrive sur les Mac sous Linux, mais pas pour tous les modèles a été publié sur IT-Connect.

Source

De nouveaux correctifs Linux apportent des réglages EPP spécifiques aux futurs Ryzen Zen 6. Ils confirment l'exploitation de trois types de cœurs.

Cet article Zen 6 : AMD confirme trois types de cœurs a été publié en premier par GinjFo.

Les développeurs Debian ont voté : l'IA générative n'est ni interdite ni recommandée, mais celui qui soumet une contribution en assume toute la responsabilité.

Le post Debian autorise officiellement l’IA générative, mais le contributeur reste responsable a été publié sur IT-Connect.

Source

Source

Git.kernel.org, la plateforme qui héberge le code source de Linux, est sous pression. En cause : les scrapers qui aspirent en masse le contenu des sites pour nourrir des IA. Le problème n'est pas tant leur présence que leur façon d'avaler ce contenu.

Git.kernel.org, la plateforme qui héberge le code source de Linux, est sous pression. En cause : les scrapers qui aspirent en masse le contenu des sites pour nourrir des IA. Le problème n'est pas tant leur présence que leur façon d'avaler ce contenu.

Restic est un logiciel de sauvegarde gratuit et open source qui permet de protéger ses fichiers sous Windows, Linux et macOS. Il se distingue par son fonctionnement en ligne de commande, son chiffrement intégré, la déduplication des données et la gestion des sauvegardes sous forme de snapshots.

Avec Restic, vous pouvez sauvegarder des dossiers vers un disque local, un disque externe, un NAS, un serveur distant ou encore un stockage cloud via rclone. Les sauvegardes suivantes ne recopient pas inutilement les données déjà présentes, ce qui permet de réduire l’espace utilisé et d’accélérer les opérations.

L’outil permet également de restaurer une sauvegarde complète ou seulement certains fichiers, d’exclure des dossiers, de gérer une politique de rétention avec forget et prune, de vérifier l’intégrité du repository et d’automatiser les sauvegardes avec PowerShell, cron ou systemd.

Dans ce tutoriel, vous allez voir comment installer Restic, créer un repository, sauvegarder et restaurer vos fichiers, gérer les snapshots, supprimer les anciennes sauvegardes, vérifier leur intégrité et automatiser les sauvegardes.

Restic est particulièrement adapté si vous recherchez une solution de sauvegarde légère, chiffrée et scriptable, sans dépendre d’une interface graphique.

Qu’est-ce que Restic ?

Restic est un logiciel de sauvegarde en ligne de commande, gratuit et open source, conçu pour créer des sauvegardes rapides, chiffrées et dédupliquées.

Il fonctionne sous Windows, Linux, macOS et d’autres systèmes, et permet de sauvegarder des fichiers vers différents types de destinations : un disque local, un disque USB, un NAS, un serveur distant ou certains stockages cloud.

Restic repose sur deux notions principales :

• le repository : l’emplacement dans lequel les données de sauvegarde sont stockées ;
• le snapshot : une photographie de l’état des fichiers au moment d’une sauvegarde.

À chaque nouvelle sauvegarde, Restic ne recopie pas inutilement toutes les données déjà présentes. Il réutilise les blocs déjà sauvegardés et n’ajoute que les nouvelles données ou celles qui ont été modifiées. Cela permet de réduire l’espace disque utilisé et d’accélérer les sauvegardes suivantes.

Les données enregistrées dans le dépôt sont également chiffrées. Le contenu des fichiers, leurs noms et les métadonnées sont protégés par le mot de passe du repository.

Restic permet notamment de :

• sauvegarder un ou plusieurs dossiers ;
• conserver plusieurs versions grâce aux snapshots ;
• restaurer une sauvegarde complète ou seulement certains fichiers ;
• exclure des fichiers ou dossiers ;
• vérifier l’intégrité du repository ;
• supprimer automatiquement les anciennes sauvegardes ;
• automatiser les sauvegardes avec le Planificateur de tâches de Windows, cron ou systemd ;
• utiliser un stockage local ou distant.

Restic est donc particulièrement adapté si vous recherchez une solution de sauvegarde légère, fiable et scriptable, sans dépendre d’une interface graphique.

Son principal inconvénient est justement son fonctionnement en ligne de commande : il faut se familiariser avec quelques commandes pour créer le dépôt, lancer les sauvegardes et effectuer les restaurations. Une fois cette logique comprise, son utilisation reste toutefois assez simple.

Installer Restic sur Windows et Linux

Restic est disponible sous Windows et Linux. Il s’agit d’un programme en ligne de commande : une fois installé, vous l’utilisez depuis PowerShell, l’Invite de commandes ou un terminal Linux.

Installer Restic sous Windows

Sous Windows, Restic est disponible sous la forme d’un exécutable autonome. Il n’est donc pas nécessaire de passer par un programme d’installation classique.

Téléchargez la dernière version stable de Restic depuis la page officielle :

Choisissez l’archive correspondant à votre architecture, généralement Windows AMD64 pour un PC Windows 64 bits.

Après le téléchargement :

• décompressez l’archive ;
• renommez éventuellement le fichier en restic.exe ;
• placez-le dans un dossier dédié, par exemple C:\Program Files\Restic\ ;
• ajoutez ce dossier à la variable d’environnement PATH afin de pouvoir lancer Restic depuis n’importe quel terminal.

Vous pouvez ensuite vérifier que Restic fonctionne avec :

restic version

La version installée doit alors s’afficher.

Si vous ne souhaitez pas modifier le PATH, ouvrez PowerShell directement dans le dossier de Restic puis utilisez :

.\restic.exe version

Installer Restic sous Linux

Sous Linux, Restic est disponible dans les dépôts de nombreuses distributions.

Sur Debian, Ubuntu et dérivées :

sudo apt update
sudo apt install restic

Sur Fedora :

sudo dnf install restic

Sur Arch Linux et dérivées :

sudo pacman -S restic

Une fois l’installation terminée, vérifiez la version :

restic version

Vous pouvez aussi télécharger directement le binaire depuis le site officiel de Restic si vous souhaitez disposer d’une version plus récente que celle fournie par les dépôts de votre distribution.

Après l’installation, Restic est prêt à être utilisé. L’étape suivante consiste à créer un repository, c’est-à-dire l’emplacement dans lequel seront stockées les sauvegardes.

Créer un dépôt de sauvegarde Restic

Avant de pouvoir sauvegarder des fichiers avec Restic, il faut créer un dépôt, appelé repository. Il s’agit de l’emplacement dans lequel Restic va stocker les données, les métadonnées et les différents snapshots de sauvegarde.

Le dépôt peut se trouver sur un disque local, un disque USB, un NAS, un serveur distant ou un stockage cloud. Pour commencer simplement, vous pouvez créer un dépôt sur un autre disque.

• Sous Windows, par exemple :

restic init --repo D:\Sauvegardes\Restic

• Sous Linux :

restic init --repo /mnt/sauvegardes/restic

Lors de l’initialisation, Restic vous demande de définir un mot de passe. Celui-ci sert à chiffrer le contenu du dépôt.

• Choisissez un mot de passe solide et conservez-le précieusement. Sans ce mot de passe, il ne sera pas possible d’accéder aux sauvegardes ni de restaurer les fichiers.
• Le mot de passe ne peut pas être récupéré par Restic : conservez-en une copie dans un gestionnaire de mots de passe ou un emplacement sécurisé.
• Une fois le dépôt créé, Restic affiche un message confirmant son initialisation.
• Vous pouvez ensuite vérifier que le dépôt est accessible avec :

restic -r D:\Sauvegardes\Restic snapshots

• ou sous Linux :

restic -r /mnt/sauvegardes/restic snapshots

Comme aucune sauvegarde n’a encore été effectuée, la liste des snapshots sera vide.

À partir de ce moment, le repository est prêt à recevoir les premières sauvegardes. Lors des commandes suivantes, l’option -r ou --repo permet d’indiquer à Restic quel dépôt utiliser.

Sauvegarder un dossier avec Restic

Une fois le repository créé, vous pouvez lancer votre première sauvegarde avec la commande backup.

• Sous Windows, par exemple pour sauvegarder le dossier Documents :

restic -r D:\Sauvegardes\Restic backup C:\Users\VotreNom\Documents

• Sous Linux :

restic -r /mnt/sauvegardes/restic backup /home/votre_nom/Documents

Restic demande alors le mot de passe du repository, analyse les fichiers puis enregistre les données dans le dépôt.

À la fin de l’opération, un résumé indique notamment :

• le nombre de fichiers analysés ;
• le volume de données ajouté ;
• la quantité réellement stockée après déduplication ;
• la durée de la sauvegarde ;
• l’identifiant du nouveau snapshot.

Lors des sauvegardes suivantes, Restic ne recopie pas inutilement les données déjà présentes dans le repository. Il détecte les nouveaux fichiers et les blocs modifiés, ce qui réduit le temps de sauvegarde et l’espace utilisé.

Vous pouvez également sauvegarder plusieurs dossiers dans une seule commande :

restic -r D:\Sauvegardes\Restic backup C:\Users\VotreNom\Documents C:\Users\VotreNom\Pictures

Sous Linux :

restic -r /mnt/sauvegardes/restic backup /home/votre_nom/Documents /home/votre_nom/Images

Il est aussi possible de sauvegarder un dossier complet contenant plusieurs sous-dossiers. Restic parcourt automatiquement son contenu de manière récursive.

Par exemple :

restic -r D:\Sauvegardes\Restic backup C:\Users\VotreNom

Cette commande sauvegarde tout le profil utilisateur, sauf les éléments éventuellement exclus avec des options spécifiques.

Sauvegarder sans saisir le mot de passe à chaque fois

Vous pouvez aussi faire en sorte d’éviter de devoir saisir le mot de passe à chaque commande.
Voici deux méthodes différentes pour y parvenir.

Avec une variable

Pour éviter de saisir le chemin du repository à chaque commande, vous pouvez définir la variable d’environnement RESTIC_REPOSITORY.

Sous Linux :

export RESTIC_PASSWORD_FILE="/root/.restic-password"

Sous PowerShell :

$env:RESTIC_REPOSITORY="D:\Sauvegardes\Restic"

Vous pouvez ensuite lancer simplement :

restic backup C:\Users\VotreNom\Documents

Restic utilise alors automatiquement le repository défini dans la variable d’environnement.

Avec un fichier

Vous pouvez aussi stocker le mot de passe dans un fichier sur une seule ligne.
Par exemple C:\Restic\password.txt ou /root/.restic-password.

Sous Windows :

restic -r D:\Sauvegardes\Restic `
  --password-file C:\Restic\password.txt `
  backup C:\Users\VotreNom\Documents

Sous Linux :

restic -r /mnt/sauvegardes/restic \
  --password-file /root/.restic-password \
  backup /home/votre_nom/Documents

Lister les sauvegardes et snapshots

Restic conserve chaque sauvegarde sous la forme d’un snapshot. Un snapshot représente l’état des fichiers au moment où la commande backup a été exécutée.

Pour afficher la liste des sauvegardes disponibles, utilisez :

restic -r D:\Sauvegardes\Restic snapshots

Sous Linux :

restic -r /mnt/sauvegardes/restic snapshots

Restic affiche alors un tableau contenant notamment :

• l’identifiant du snapshot ;
• la date et l’heure de la sauvegarde ;
• le nom de l’ordinateur ;
• l’utilisateur ;
• les chemins sauvegardés.

L’identifiant du snapshot est particulièrement utile pour effectuer une restauration précise.

Par exemple, si Restic affiche un snapshot avec l’identifiant :

4f3a9c2b

Vous pourrez ensuite l’utiliser dans une commande de restauration.

Il est aussi possible d’afficher les informations détaillées d’un snapshot avec :

restic -r D:\Sauvegardes\Restic stats 4f3a9c2b

Pour afficher le contenu d’un snapshot sans restaurer les fichiers, utilisez :

restic -r D:\Sauvegardes\Restic ls 4f3a9c2b

Vous pouvez également utiliser le mot-clé latest pour cibler automatiquement la sauvegarde la plus récente :

restic -r D:\Sauvegardes\Restic ls latest

Cela évite d’avoir à recopier l’identifiant du dernier snapshot.

Enfin, si vous avez défini la variable RESTIC_REPOSITORY, la commande peut être simplifiée :

restic snapshots

Cette liste des snapshots permet de vérifier que les sauvegardes sont bien présentes et de choisir celle à utiliser pour restaurer des fichiers.

Restaurer des fichiers avec Restic

Restic permet de restaurer une sauvegarde complète ou seulement certains fichiers à partir d’un snapshot existant.

Pour restaurer le dernier snapshot disponible vers un dossier spécifique sous Windows :

restic -r D:\Sauvegardes\Restic restore latest --target C:\Restauration

Sous Linux :

restic -r /mnt/sauvegardes/restic restore latest --target /tmp/restauration

Restic recrée alors l’arborescence de la sauvegarde dans le dossier indiqué par --target.

Si vous souhaitez restaurer un snapshot précis, utilisez son identifiant :

restic -r D:\Sauvegardes\Restic restore 4f3a9c2b --target C:\Restauration

Vous pouvez retrouver les identifiants disponibles avec :

restic -r D:\Sauvegardes\Restic snapshots

Pour restaurer uniquement certains fichiers ou dossiers, utilisez l’option --include.

Par exemple :

restic -r D:\Sauvegardes\Restic restore latest --target C:\Restauration --include "/C/Users/VotreNom/Documents"

Vous pouvez également exclure certains éléments avec --exclude.

Par exemple :

restic -r D:\Sauvegardes\Restic restore latest --target C:\Restauration --exclude "*.tmp"

Avant de restaurer, il peut être utile d’afficher le contenu du snapshot :

restic -r D:\Sauvegardes\Restic ls latest

Cela permet de vérifier les chemins présents dans la sauvegarde et d’éviter de restaurer des données inutiles.

Une fois la restauration terminée, contrôlez le contenu du dossier cible avant de remplacer d’éventuels fichiers existants sur le système.

Pour une restauration importante, il est préférable de restaurer d’abord vers un dossier temporaire, puis de recopier manuellement les fichiers souhaités à leur emplacement d’origine. Cela limite le risque d’écraser par erreur une version plus récente d’un fichier.

Exclure des fichiers et dossiers de la sauvegarde

Lors d’une sauvegarde, il peut être utile d’exclure certains fichiers inutiles, temporaires ou volumineux afin de réduire la taille du repository et d’accélérer l’opération.

Restic propose pour cela l’option --exclude.

Par exemple, pour exclure tous les fichiers temporaires :

restic -r D:\Sauvegardes\Restic backup C:\Users\VotreNom --exclude "*.tmp"

Vous pouvez également exclure un dossier précis :

restic -r D:\Sauvegardes\Restic backup C:\Users\VotreNom --exclude "C:\Users\VotreNom\Downloads"

Plusieurs exclusions peuvent être ajoutées dans la même commande :

restic -r D:\Sauvegardes\Restic backup C:\Users\VotreNom `
  --exclude "*.tmp" `
  --exclude "*.log" `
  --exclude "C:\Users\VotreNom\Downloads"

Sous Linux, le principe est identique :

restic -r /mnt/sauvegardes/restic backup /home/votre_nom \
  --exclude "*.tmp" \
  --exclude "/home/votre_nom/Téléchargements"

Pour un grand nombre de règles, il est plus pratique d’utiliser un fichier d’exclusion.

Créez par exemple un fichier excludes.txt contenant :

*.tmp
*.log
Thumbs.db
C:\Users\VotreNom\Downloads
C:\Users\VotreNom\AppData\Local\Temp

Puis indiquez ce fichier à Restic :

restic -r D:\Sauvegardes\Restic backup C:\Users\VotreNom --exclude-file C:\Restic\excludes.txt

Cette méthode est particulièrement utile pour automatiser les sauvegardes, car vous pouvez modifier les règles d’exclusion sans avoir à réécrire toute la commande.

Avant d’exclure un dossier, vérifiez toutefois qu’il ne contient pas de données importantes. Une exclusion mal définie peut empêcher certains fichiers d’être présents dans les snapshots suivants.

Supprimer les anciennes sauvegardes avec forget et prune

Au fil du temps, Restic peut conserver de nombreux snapshots. Pour éviter que le repository ne grossisse indéfiniment, vous pouvez supprimer les anciennes sauvegardes selon une politique de rétention.

Restic utilise principalement deux commandes pour cela :

• forget : supprime les références aux snapshots devenus inutiles ;
• prune : supprime réellement du repository les données qui ne sont plus utilisées par aucun snapshot.

Il est donc important de comprendre que forget seul ne libère pas forcément immédiatement tout l’espace disque.

Pour afficher d’abord les snapshots disponibles :

restic -r D:\Sauvegardes\Restic snapshots

Vous pouvez ensuite supprimer un snapshot précis avec son identifiant :

restic -r D:\Sauvegardes\Restic forget 4f3a9c2b

Pour appliquer une politique de rétention automatique, utilisez les options --keep-*.

Par exemple, pour conserver :

• les 7 dernières sauvegardes quotidiennes ;
• les 4 dernières sauvegardes hebdomadaires ;
• les 6 dernières sauvegardes mensuelles ;

utilisez :

restic -r D:\Sauvegardes\Restic forget `
  --keep-daily 7 `
  --keep-weekly 4 `
  --keep-monthly 6

Sous Linux :

restic -r /mnt/sauvegardes/restic forget \
  --keep-daily 7 \
  --keep-weekly 4 \
  --keep-monthly 6

Cette commande supprime les snapshots qui ne correspondent plus aux règles de conservation, mais les blocs de données devenus inutiles peuvent encore rester dans le repository.

Pour réellement récupérer l’espace disque, lancez ensuite :

restic -r D:\Sauvegardes\Restic prune

Il est également possible d’effectuer les deux opérations en une seule commande :

restic -r D:\Sauvegardes\Restic forget `
  --keep-daily 7 `
  --keep-weekly 4 `
  --keep-monthly 6 `
  --prune

Cette méthode est particulièrement pratique dans un script de sauvegarde automatisé.

Avant de supprimer des snapshots, vérifiez toutefois que votre politique de rétention correspond bien à vos besoins. Une sauvegarde supprimée avec forget puis nettoyée avec prune ne pourra plus être restaurée.

Il est donc recommandé de commencer avec une rétention prudente, puis d’ajuster les valeurs en fonction de l’espace disponible et de la fréquence de vos sauvegardes.

Vérifier l’intégrité des sauvegardes avec restic check

Il est important de vérifier régulièrement que le repository Restic ne contient pas d’erreur et que les sauvegardes restent exploitables.

Pour cela, Restic propose la commande check.

Sous Windows :

restic -r D:\Sauvegardes\Restic check

Sous Linux :

restic -r /mnt/sauvegardes/restic check

Cette commande vérifie la structure du repository, les index, les snapshots et les références entre les différents objets stockés.

Si tout est correct, Restic termine l’analyse sans signaler d’erreur.

Pour effectuer une vérification plus poussée des données enregistrées, vous pouvez utiliser :

restic -r D:\Sauvegardes\Restic check --read-data

Cette option demande à Restic de lire les données présentes dans le repository afin de vérifier leur intégrité.

Attention toutefois : sur un repository volumineux, --read-data peut être beaucoup plus long qu’un simple check, car l’ensemble des données doit être parcouru.

Il est également possible de limiter la vérification à une partie des données, par exemple :

restic -r D:\Sauvegardes\Restic check --read-data-subset=10%

Cette méthode permet d’effectuer régulièrement un contrôle partiel sans relire tout le repository à chaque fois.

Dans une stratégie de sauvegarde sérieuse, vous pouvez par exemple :

• lancer restic check régulièrement ;
• effectuer ponctuellement un contrôle avec --read-data ;
• tester de temps en temps une restauration réelle de quelques fichiers.

En effet, une sauvegarde n’est réellement fiable que si elle peut être restaurée correctement. Vérifier le repository est donc utile, mais il est également recommandé de tester périodiquement une restauration vers un dossier temporaire.

Sauvegarder vers un disque externe, un NAS ou un serveur distant

Restic peut enregistrer ses sauvegardes sur différents types de destinations. Le repository n’a pas besoin de se trouver sur le disque principal du PC : il peut être stocké sur un disque USB, un NAS ou un serveur distant.

Sauvegarder sur un disque externe

Pour un disque USB ou un second disque interne, il suffit d’utiliser son chemin comme repository.

Sous Windows :

restic -r E:\ResticBackup backup C:\Users\VotreNom\Documents

Sous Linux :

restic -r /media/sauvegarde/restic backup /home/votre_nom/Documents

Cette solution est simple à mettre en place et convient bien pour conserver une copie hors du disque système.

Pour une meilleure protection contre les ransomwares ou une panne matérielle, évitez toutefois de laisser le disque externe connecté en permanence.

Sauvegarder sur un NAS

Si le NAS expose un partage réseau SMB ou NFS monté dans Windows ou Linux, Restic peut l’utiliser comme un dossier classique.

Sous Windows, avec un partage réseau monté sur Z: :

restic -r Z:\ResticBackup backup C:\Users\VotreNom\Documents

Vous pouvez aussi utiliser un chemin UNC :

restic -r \\NAS\Sauvegardes\Restic backup C:\Users\VotreNom\Documents

Sous Linux, si le partage du NAS est monté dans /mnt/nas :

restic -r /mnt/nas/restic backup /home/votre_nom/Documents

Le principe reste identique : le repository doit d’abord être créé avec restic init, puis vous pouvez utiliser la commande backup.

Sauvegarder sur un serveur distant avec SFTP

Restic prend également en charge les repositories accessibles en SFTP.

Par exemple :

restic -r sftp:utilisateur@serveur:/srv/restic backup /home/votre_nom/Documents

Sous Windows, le principe est identique depuis PowerShell si l’accès SSH au serveur est correctement configuré :

restic -r sftp:utilisateur@serveur:/srv/restic backup C:\Users\VotreNom\Documents

L’authentification peut s’effectuer avec un mot de passe SSH ou, de préférence, avec une clé SSH.

Avant la première sauvegarde, initialisez le repository distant :

restic -r sftp:utilisateur@serveur:/srv/restic init

Restic chiffre les données avant leur envoi. Le serveur distant stocke donc le contenu chiffré du repository.

Utiliser un stockage distant avec rclone

Restic peut aussi s’appuyer sur rclone pour accéder à de nombreux services de stockage cloud ou protocoles distants.

Après avoir configuré une destination dans rclone, vous pouvez par exemple utiliser :

restic -r rclone:remote:ResticBackup backup /home/votre_nom/Documents

Sous Windows :

restic -r rclone:remote:ResticBackup backup C:\Users\VotreNom\Documents

Cette méthode permet notamment d’utiliser les nombreux fournisseurs compatibles avec rclone sans que Restic ait besoin de gérer directement chacun d’eux.

Quelle destination choisir ?

Pour une sauvegarde locale simple, un disque externe est souvent suffisant. Un NAS est plus pratique pour automatiser les sauvegardes de plusieurs machines, tandis qu’un serveur distant ou un stockage cloud permet de conserver une copie hors du domicile ou de l’entreprise.

Pour une meilleure protection des données, l’idéal reste de disposer d’au moins une copie de sauvegarde stockée sur un support ou un emplacement différent du PC sauvegardé.

Automatiser les sauvegardes Restic

Restic se prête très bien à l’automatisation. Une fois la commande de sauvegarde définie, vous pouvez la lancer régulièrement avec le Planificateur de tâches de Windows, cron sous Linux ou un service systemd.

L’objectif est généralement d’exécuter automatiquement une commande de ce type :

restic -r D:\Sauvegardes\Restic backup C:\Users\VotreNom\Documents

Le principal point à gérer est le mot de passe du repository. Pour éviter une saisie manuelle à chaque exécution, vous pouvez utiliser un fichier contenant le mot de passe.

Par exemple :

C:\Restic\password.txt

Puis lancer Restic avec :

restic -r D:\Sauvegardes\Restic --password-file C:\Restic\password.txt backup C:\Users\VotreNom\Documents

Protégez soigneusement ce fichier, car toute personne pouvant le lire pourra ouvrir le repository.

Automatiser Restic sous Windows

Le plus pratique consiste à créer un script PowerShell, par exemple :

$repo = "D:\Sauvegardes\Restic"
$password = "C:\Restic\password.txt"
$source = "C:\Users\VotreNom\Documents"

restic -r $repo --password-file $password backup $source

Enregistrez-le par exemple sous :

C:\Restic\backup-restic.ps1

Vous pouvez ensuite créer une tâche planifiée :

• ouvrez le Planificateur de tâches ;
• cliquez sur Créer une tâche ;
• choisissez un déclencheur, par exemple tous les jours à 20 h ;
• dans Actions, ajoutez le programme powershell.exe ;
• utilisez comme argument :

-ExecutionPolicy Bypass -File "C:\Restic\backup-restic.ps1"

La sauvegarde sera alors exécutée automatiquement selon la fréquence choisie.

Ajouter une politique de rétention

Vous pouvez également nettoyer automatiquement les anciens snapshots après la sauvegarde.

Par exemple :

$repo = "D:\Sauvegardes\Restic"
$password = "C:\Restic\password.txt"
$source = "C:\Users\VotreNom\Documents"

restic -r $repo --password-file $password backup $source

restic -r $repo --password-file $password forget `
  --keep-daily 7 `
  --keep-weekly 4 `
  --keep-monthly 6 `
  --prune

Cette configuration conserve plusieurs générations de sauvegardes tout en évitant que le repository ne grossisse indéfiniment.

Automatiser Restic sous Linux avec cron

Sous Linux, vous pouvez créer un script :

#!/bin/bash

export RESTIC_REPOSITORY="/mnt/sauvegardes/restic"
export RESTIC_PASSWORD_FILE="/root/.restic-password"

restic backup /home/votre_nom/Documents
restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 6 --prune

Rendez-le exécutable :

chmod +x /usr/local/bin/backup-restic.sh

Puis ouvrez la crontab :

crontab -e

Par exemple, pour lancer la sauvegarde chaque jour à 2 h :

0 2 * * * /usr/local/bin/backup-restic.sh

Conserver un journal des sauvegardes

Pour une tâche automatisée, il est conseillé de conserver les sorties de Restic afin de pouvoir vérifier qu’une sauvegarde s’est bien déroulée.

Sous Windows :

restic -r $repo --password-file $password backup $source *>> C:\Restic\restic.log

Sous Linux :

restic backup /home/votre_nom/Documents >> /var/log/restic.log 2>&1

Vous pourrez ainsi consulter le journal en cas d’échec ou vérifier la date de la dernière sauvegarde réussie.

Enfin, même avec une automatisation parfaitement configurée, contrôlez régulièrement la présence des snapshots avec restic snapshots et testez ponctuellement une restauration. Une tâche qui s’exécute automatiquement ne garantit pas à elle seule que les sauvegardes sont réellement exploitables.

Quelques commandes Restic utiles

Restic propose de nombreuses commandes pour gérer les sauvegardes, consulter les snapshots, restaurer des fichiers ou entretenir le repository. Voici les principales à connaître.

Afficher la version installée :

restic version

Créer un nouveau repository :

restic -r /chemin/du/repository init

Sauvegarder un dossier :

restic -r /chemin/du/repository backup /chemin/a/sauvegarder

Afficher les snapshots disponibles :

restic -r /chemin/du/repository snapshots

Afficher le contenu du dernier snapshot :

restic -r /chemin/du/repository ls latest

Afficher des statistiques sur un snapshot :

restic -r /chemin/du/repository stats latest

Restaurer le dernier snapshot :

restic -r /chemin/du/repository restore latest --target /chemin/restauration

Restaurer un snapshot précis :

restic -r /chemin/du/repository restore ID_DU_SNAPSHOT --target /chemin/restauration

Sauvegarder en excluant certains fichiers :

restic -r /chemin/du/repository backup /chemin/a/sauvegarder --exclude "*.tmp"

Utiliser un fichier d’exclusions :

restic -r /chemin/du/repository backup /chemin/a/sauvegarder --exclude-file excludes.txt

Supprimer un ancien snapshot :

restic -r /chemin/du/repository forget ID_DU_SNAPSHOT

Appliquer une politique de rétention :

restic -r /chemin/du/repository forget \
  --keep-daily 7 \
  --keep-weekly 4 \
  --keep-monthly 6

Supprimer les données devenues inutiles dans le repository :

restic -r /chemin/du/repository prune

Appliquer la rétention et nettoyer le repository en une seule commande :

restic -r /chemin/du/repository forget \
  --keep-daily 7 \
  --keep-weekly 4 \
  --keep-monthly 6 \
  --prune

Vérifier la structure et l’intégrité du repository :

restic -r /chemin/du/repository check

Effectuer une vérification complète des données :

restic -r /chemin/du/repository check --read-data

Vérifier seulement une partie des données :

restic -r /chemin/du/repository check --read-data-subset=10%

Enfin, si vous avez défini la variable RESTIC_REPOSITORY, vous pouvez simplifier les commandes et omettre l’option -r :

restic snapshots
restic backup /chemin/a/sauvegarder
restic check

Ces commandes couvrent l’essentiel des opérations courantes avec Restic : création du dépôt, sauvegarde, restauration, gestion des snapshots et vérification des données.

Restic : avantages et limites

Restic est une solution de sauvegarde particulièrement intéressante si vous recherchez un outil léger, fiable, chiffré et facilement automatisable.

Ses principaux avantages sont :

• le chiffrement intégré : les sauvegardes sont protégées avant leur stockage ;
• la déduplication : les blocs déjà présents dans le repository ne sont pas recopiés inutilement ;
• les snapshots : il est possible de conserver plusieurs états successifs des fichiers ;
• la compatibilité multiplateforme : Restic fonctionne sous Windows, Linux et macOS ;
• le support de nombreuses destinations : disque local, disque USB, NAS, serveur SFTP ou stockage distant via rclone ;
• la simplicité de l’automatisation : les commandes peuvent facilement être intégrées à PowerShell, cron ou systemd ;
• la vérification d’intégrité : la commande restic check permet de contrôler régulièrement l’état du repository ;
• la restauration sélective : il est possible de restaurer un snapshot complet ou seulement certains fichiers.

Restic présente toutefois quelques limites.

La principale est son fonctionnement essentiellement en ligne de commande. Pour un utilisateur habitué aux logiciels de sauvegarde avec interface graphique, la prise en main peut demander un petit temps d’adaptation.

La gestion du mot de passe du repository demande également de la rigueur. Si vous perdez ce mot de passe, les données chiffrées ne pourront plus être restaurées.

Les opérations d’entretien comme forget, prune ou check --read-data peuvent aussi devenir longues sur de gros repositories, en particulier lorsque le stockage est distant ou relativement lent.

Enfin, Restic sauvegarde avant tout des fichiers et dossiers. Ce n’est pas un logiciel d’image système complet destiné à restaurer Windows entier, les partitions, le secteur de démarrage et toutes les applications après une panne de disque.
Il ne remplace donc pas une image système si votre objectif est de restaurer Windows, les partitions et le démarrage après une panne complète du disque
 À lire :

Sauvegarde, image système, clone et image disque : différences et méthode à choisir

Restic convient donc très bien pour :

• sauvegarder régulièrement ses documents et données personnelles ;
• conserver plusieurs versions de fichiers ;
• envoyer des sauvegardes chiffrées vers un NAS ou un serveur distant ;
• automatiser une stratégie de sauvegarde avec des scripts.

En revanche, si votre objectif est de pouvoir restaurer intégralement un PC après une panne du disque système, il est préférable de compléter Restic avec une sauvegarde d’image système.

Les meilleurs logiciels de sauvegarde pour Windows

Restic est donc particulièrement adapté aux utilisateurs qui recherchent une solution de sauvegarde sobre, sécurisée et scriptable, à condition d’être à l’aise avec quelques commandes.

Ressources utiles et articles liés

• 20 meilleurs logiciels de sauvegarde pour Linux (open source)
• Sauvegarder/restaurer des fichiers sur Linux avec Deja-dup
• Déja Dup : Comment sauvegarder et restaurer ses fichiers sur Ubuntu
• Timeshift : créer et restaurer une sauvegarde système sur Linux (ligne de commandes)

• Sauvegarder Windows : méthodes pour protéger ses données efficacement
• Liste des logiciels de sauvegardes/images systèmes sur Windows
• Windows 11/10 : sauvegarder ses données personnelles avec l’historique de fichiers
• Faire une sauvegarde de son PC en Windows 11
• Utiliser “Sauvegarder et restaurer (Windows 7)” pour créer une sauvegarde de fichiers ou une image système
• Créer une image système complète sur Windows 11 et 10 (sauvegarde intégrée)

L’article Restic : sauvegarder et restaurer ses fichiers sous Windows et Linux est apparu en premier sur malekal.com.

Source

Valve publie SteamOS 3.9.0 Preview avec Linux 7.2, KDE Plasma 6.7.3 et un premier support de l’hibernation. La mise à jour améliore également la compatibilité avec certaines cartes mères et les machines virtuelles.

Cet article SteamOS 3.9 débarque en Preview, Valve passe à Linux 7.2 et prépare l’hibernation a été publié en premier par GinjFo.