Comment créer des sauvegardes avec Rsnapshot sous Linux

Rsnapshot est un utilitaire gratuit et open source qui fonctionne comme un wrapper autour de Rsync pour effectuer des instantanés incrémentiels de systèmes locaux ou distants via SSH. Les liens physiques sont utilisés pour économiser de l’espace lors de la sauvegarde de fichiers inchangés, pour préserver de l’espace tout en affichant des systèmes de fichiers complets à l’utilisateur. Dans ce tutoriel, nous apprenons à installer et configurer Rsnapshot sur certaines des distributions Linux les plus utilisées.

Dans ce tutoriel, vous allez apprendre :

• Comment installer rsnapshot sur certaines des distributions Linux les plus utilisées
• Comment configurer rsnapshots pour sauvegarder des machines locales et distantes via SSH

Installation

Étant donné que rsnapshot est un utilitaire gratuit et open source, il est disponible dans les dépôts officiels ou tiers de confiance de toutes les distributions Linux les plus utilisées. Pour installer l’utilitaire sur Fedora, par exemple, tout ce que nous avons à faire est de lancer notre émulateur de terminal préféré, et d’émettre la commande suivante :

sudo dnf install rsnapshot

Nous pouvons installer Rsnapshot sur RHEL (Red Hat Enterprise Linux) et ses clones, en utilisant la même commande ; sur ces distributions, cependant, nous devons ajouter au préalable le dépôt EPEL en tant que source logicielle.

Pour effectuer l’installation sur Debian, Ubuntu et d’autres distributions basées sur Debian, nous utilisons le gestionnaire de paquets apt :

sudo apt install rsnapshot

Rsnapshot est également disponible dans le dépôt « extra » d’Archlinux. Nous pouvons l’installer à l’aide de pacman :

sudo pacman -S rsnapshot

Une fois que nous avons installé Rsnapshot dans notre distribution Linux préférée, nous pouvons l’utiliser pour créer des sauvegardes incrémentielles. Voyons comment.

Configuration de Rsnapshot

Pour configurer rsnapshot, nous modifions son fichier de configuration : /etc/rsnapshot.conf. Comme indiqué dans le gros avertissement au début du fichier, seuls les onglets doivent être utilisés entre les éléments ; L’utilisation d’espaces produirait des erreurs de syntaxe :

#################################################
                                              #
PLEASE BE AWARE OF THE FOLLOWING RULE:        #
                                              #
This file requires tabs between elements      #
                                              #
#################################################

La première directive que nous voulons définir dans le fichier est snapshot_root. Comme son nom l’indique, il sert à spécifier le répertoire où tous les instantanés doivent être enregistrés. Dans l’exemple suivant, nous utilisons le répertoire /snapshots comme racine des instantanés:

All snapshots will be stored under this root directory.
#
snapshot_root /snapshots/

Si le répertoire n’existe pas, il est automatiquement créé lors de la première sauvegarde, sauf si la directive no_create_root est activée (la valeur par défaut est normalement 0) :

If no_create_root is enabled, rsnapshot will not automatically create the
snapshot_root directory. This is particularly useful if you are backing
up to removable media, such as a FireWire or USB drive.
#
#no_create_root 1

Pointage de Rsnapshot vers le chemin d’accès rsync

Rsnapshot utilise rsync pour effectuer les sauvegardes, nous devons donc spécifier l’emplacement du binaire rsync via la directive cmd_rsync. Ceci est défini sur /usr/bin/rsync par défaut, et ne nécessite aucune modification, sauf si nous avons installé rsync à un autre emplacement :

rsync must be enabled for anything to work. This is the only command that
must be enabled.
#
cmd_rsync /usr/bin/rsync

Établir une politique de rétention

Avant de commencer à créer nos sauvegardes, nous devons établir une politique de rétention : nous devons définir les différents types de sauvegarde, et spécifier combien de snapshots d’un type spécifique doivent être conservés. Pour établir la politique de rétention, nous utilisons le mot-clé retain suivi du nom d’un « type » de sauvegarde (le nom est complètement arbitraire), et d’un entier qui spécifie combien de sauvegardes de ce type doivent être conservées. Voici la configuration par défaut sur un système Ubuntu :

#########################################
BACKUP LEVELS / INTERVALS             #
Must be unique and in ascending order #
e.g. alpha, beta, gamma, etc.         #
#########################################
retain alpha 6
retain beta 7
retain gamma 4

Par défaut, « alpha », « beta » et « gamma » sont utilisés comme identifiants, cependant, ces noms ne sont pas vraiment indicatifs. Nous pouvons vouloir utiliser des modèles plus conviviaux et significatifs, par exemple :

retain daily 6
retain weekly 7 
retain monthly 4

Encore une fois, rappelez-vous que les noms sont complètement arbitraires et que Rsnapshot ne sait pas ce qu’ils signifient. Nous spécifions un type de sauvegarde lorsque nous invoquons rsnapshot : tout ce qu’il sait, c’est combien de sauvegardes d’un type spécifique il doit conserver.

Spécification des éléments de sauvegarde

Pour spécifier quels fichiers et répertoires doivent être inclus dans les instantanés, nous utilisons la directive backup et passons le chemin que nous voulons inclure et l’hôte sur lequel il se trouve. Voici une configuration typique, qui inclut les répertoires /home/, /etc/ et /usr/local/ sur localhost dans le cadre des sauvegardes :

backup /home/      localhost/
backup /etc/       localhost/
backup /usr/local/ localhost/

Exclusion et inclusion de fichiers dans les sauvegardes

Tout comme lorsque vous utilisez rsync directement, nous pouvons vouloir exclure ou inclure explicitement des fichiers spécifiques de nos sauvegardes. Pour définir des motifs d’inclusion et d’exclusion lors de l’utilisation de rsnapshot, nous utilisons les directives include et exclude, et spécifions un motif par ligne :

exclude <exclude-pattern>

De même, pour spécifier un motif d’inclusion, nous écririons :

include <include-pattern>

Comme stratégie alternative, nous pouvons écrire des motifs d’inclusion et d’exclusion dans des fichiers dédiés, puis passer le chemin de ces fichiers en tant que valeurs des directives include_file et exclude_file :

include_file /path/to/include/file
exclude_file /path/to/exclude/file

Vérification de la configuration de Rsnapshot

Une fois que nous avons modifié le fichier de configuration Rsnapshot pour répondre à nos besoins, nous pouvons vouloir vérifier que notre configuration est syntaxiquement valide. Nous pouvons le faire en utilisant la commande configtest :

sudo rsnapshot configtest

Si tout se passe comme prévu, la commande doit renvoyer le message suivant :

Syntax OK

Encore une fois, notez que seuls les onglets doivent être utilisés dans le fichier de configuration rsnapshot. Les espaces ne sont pas autorisés : leur utilisation sera considérée comme une erreur de syntaxe.

Test et création de notre première sauvegarde

Pour que Rsnapshot affiche la commande qu’il exécuterait lors d’une sauvegarde, sans l’effectuer réellement, nous pouvons utiliser l’option -t, comme dans l’exemple ci-dessous :

sudo rsnapshot -t daily

La commande doit renvoyer une sortie similaire à celle ci-dessous :

echo 6080 > /var/run/rsnapshot.pid 
mkdir -m 0755 -p /snapshots/daily.0/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
    /home/ /snapshots/daily.0/localhost/ 
mkdir -m 0755 -p /snapshots/daily.0/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded /etc/ \
    /snapshots/daily.0/localhost/ 
mkdir -m 0755 -p /snapshots/daily.0/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
    /usr/local/ /snapshots/daily.0/localhost/ 
touch /snapshots/daily.0/

Pour créer notre première sauvegarde, nous omettons simplement l’option -t, donc, pour créer notre première sauvegarde quotidienne, nous exécuterions :

sudo rsnapshot daily

Une fois la sauvegarde terminée, un répertoire lié à notre première sauvegarde quotidienne sera créé sous la racine des snapshots :

/snapshots/
└── daily.0
    └── localhost
        ├── etc
        ├── home
        └── usr

Voyons maintenant ce qui se passerait si nous devions créer notre deuxième sauvegarde quotidienne :

sudo rsnapshot -t daily

La commande renvoie le résultat suivant :

bin/cp -al /snapshots/daily.0 /snapshots/daily.1 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
    /home/ /snapshots/daily.0/localhost/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded /etc/ \
    /snapshots/daily.0/localhost/ 
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
    /usr/local/ /snapshots/daily.0/localhost/ 
touch /snapshots/daily.0/

Comme vous pouvez le voir, la sauvegarde du répertoire daily.0 serait d’abord copiée en tant que daily.1, en exécutant cp avec les options -a et -l : la première est nécessaire pour préserver toutes les permissions et propriétés des fichiers, tandis que la seconde fait en sorte que les fichiers soient liés en dur au lieu d’être copiés, afin de préserver l’espace. La nouvelle sauvegarde utilisera le répertoire daily.0 d’origine comme cible, c’est pourquoi elle hébergera toujours l’instantané le plus récent.

Création d’une sauvegarde d’une machine distante

Nous pouvons utiliser Rsnapshot pour effectuer des sauvegardes incrémentielles de machines distantes via SSH, en mettant en œuvre une stratégie de sauvegarde « pull » : au lieu que les clients poussent les fichiers vers le serveur de sauvegarde, le serveur se connecte aux clients et effectue les sauvegardes en « extrayant » les fichiers de ceux-ci.

La première chose que nous devons faire, afin de sauvegarder une machine distante, est de nous assurer que la directive cmd_ssh existe et n’est pas commentée dans le fichier de configuration rsnapshot. La valeur de la directive est le chemin de l’exécutable du client ssh, qui est normalement installé sous la forme /usr/bin/ssh :

cmd_ssh /usr/bin/ssh

Maintenant, supposons que nous voulions sauvegarder le contenu du répertoire /etc d’une machine distante avec l’IP 192.168.122.49, en nous connectant en tant qu’utilisateur « ubuntu ». Voici ce que nous écririons dans le fichier de configuration de rsnapshot :

backup ubuntu@192.168.122.49:/etc client0

Où « client0 » n’est que l’identifiant de la machine (il peut s’agir de n’importe quoi). Pour que la sauvegarde réussisse, un serveur SSH fonctionnel doit être opérationnel sur la cible, et la clé publique que nous voulons utiliser pour la connexion doit déjà être autorisée.

Conclusions

Rsnapshot est un utilitaire gratuit et open source qui fonctionne comme un wrapper autour de Rsync pour effectuer des sauvegardes incrémentielles. Dans ce tutoriel, nous avons appris à installer et à configurer rsnapshot sur certaines des distributions Linux les plus utilisées. Nous avons vu comment spécifier les répertoires que nous voulons sauvegarder sur les machines locales et distantes, comment établir une politique de rétention et comment spécifier où les instantanés doivent être enregistrés.