URL: https://linuxfr.org/news/installer-borgbackup-sur-un-nas Title: Installer BorgBackup sur un NAS Authors: Cyril Chaboisseau ZeroHeure, theojouedubanjo, palm123, Xavier Teyssier, tankey et Ysabeau Date: 2020-02-08T21:49:34+01:00 License: CC by-sa Tags: backup, nas, wiki, tutoriel et sauvegarde Score: 4 Borg est un outil de sauvegardes pour les systèmes Unix/Linux, écrit en Python et activement développé (Borg est un fork d’[Attic](https://attic-backup.org/) qui n’évolue plus). Borg cherche à fournir une solution efficace et sécurisée : la déduplication et la compression des blocs de données réduisent la place occupée par la sauvegarde, et le chiffrement protège et authentifie les données. La restauration est réalisable facilement et ne nécessite pas d’avoir les droits administrateur (montage de la sauvegarde par un utilisateur via [FUSE](https://borgbackup.readthedocs.io/en/stable/usage/mount.html)). ![Logo de Borg](https://borgbackup.readthedocs.io/en/stable/_static/logo.svg) Cet article est une présentation de Borg autour d’un cas pratique. Il explique pas-à-pas comment installer et configurer le logiciel Borg sur un [[NAS]] pour effectuer des sauvegardes en mode client-serveur via SSH. L’exemple donné se base sur un NAS Synology, mais est facilement transposable à n’importe quel autre serveur de stockage réseau. ---- [Site officiel de BorgBackup](https://www.borgbackup.org/) [Documentation de BorgBackup](https://borgbackup.readthedocs.io/) [borgbackup : avantages, mémo, liens (SebSauvage)](https://sebsauvage.net/wiki/doku.php?id=borgbackup) [Ressources de la communauté Borg](https://github.com/borgbackup/community) ---- # Introduction Inutile d’insister sur l’importance de réaliser des sauvegardes : que ce soit pour se prémunir de la perte accidentelle de fichiers (destruction, écrasement), d’acte de malveillance (rançongiciel) ou plus pragmatiquement pour retrouver une ancienne version d’un document. Comme le dit l’adage : « il y a deux types d’utilisateurs : ceux qui ont déjà perdu des données, et ceux qui vont en perdre ». Le cas de figure typique auquel répond ce tutoriel est vaste : offrir pour soi-même, mais aussi pour des amis ou la famille un espace de stockage permettant une sauvegarde régulière et sécurisée d’un ordinateur quelconque. On sauvegarde un répertoire, un point de montage ou tout un disque. En effet, la démocratisation de la fibre permet de mettre à disposition une telle ressource et par conséquent de réaliser des sauvegardes hors site (ce qui protège contre le vol ou les incendies...) en passant par Internet, sans que ça prenne des heures. > Dans mon cas, j’ai pu réaliser une sauvegarde initiale d’un dossier de 7 Go en moins de quatre minutes (une fois les données compressées et dédupliquées il n’y avait plus que 4,73 Go), sachant que les sauvegardes suivantes du même répertoire ne prennent généralement que trente secondes (350 Mo dédupliqués). Au niveau local, le client Borg suffit pour déposer les sauvegardes à travers un serveur de fichiers réseau tels que CIFS ou NFS, mais dès que l’on veut le faire sur une machine hors réseau local, on est obligé de passer par le protocole SSH, par exemple en [SSHFS] (https://blog.m0le.net/2018/04/01/backup-avec-borg-via-sshfs-sur-synology/) ou encore [SFTP](https://www.memoiresecondaire.fr/?p=859). Une bien meilleure approche consiste à utiliser BorgBackup à travers SSH en installant la partie serveur sur une machine distante ce qui offre l’avantage d’avoir un contrôle plus fin à travers les options de `borg serve` : gestion des quotas, mode en écriture seule (`--append-only`) interdisant les destructions/_prune_ des anciennes sauvegardes, restriction à un dépôt unique ou à un répertoire, et plus généralement le fait que l’on n’a pas besoin de mettre à disposition un accès complet à un partage comme on le ferait via SSHFS. Un autre bénéfice du mode client/server, c’est de permettre une opération de vérification de l’intégrité des sauvegardes ([`borg check`](https://borgbackup.readthedocs.io/en/stable/usage/check.html)) directement par le serveur, ce qui évite un fort trafic réseau si la vérification des blocs de données chiffrés devait se faire par le client qui est le seul connaître la clé de chiffrement des données. Il faut cependant avoir à l’esprit que les performances sont moindres lorsque l’on utilise le protocole SSH (66 % en moyenne d’après un test avec [`borg benchmark`](https://borgbackup.readthedocs.io/en/stable/usage/benchmark.html) par rapport à un montage NFSv4). Les avantages de BorgBackup sont multiples : - les sauvegardes sont **sécurisées** en ce sens où les données sont authentifiées et chiffrées (on peut se permettre de stocker ses sauvegardes chez un hébergeur en qui on n’a pas nécessairement confiance, une personne qui accéderait aux fichiers sauvegardés ne pourra rien en faire dès lors qu’on a choisi un mot de passe solide) ; - la sauvegarde à travers le réseau utilise le protocole SSH, lui aussi réputé comme étant très sûr et sécurisé en plus d’être largement répandu ; - la place prise par la sauvegarde est optimisée : les données sont **compressées** (si on le désire) avec un [algorithme plus ou moins efficace](https://borgbackup.readthedocs.io/en/stable/usage/create.html) selon qu’on privilégie la rapidité de la compression sur le gain de place — pour autant que les données le permettent. Pour les blocs de données identiques, une **déduplication** va se faire ce qui permet encore un gain de place, mais surtout lors de sauvegardes régulières qui sont de facto incrémentales. # Installation et configuration Le but de ce tutoriel est d’installer le serveur de Borg sur un NAS Synology afin d’y déposer des sauvegardes depuis Internet ou le réseau local. Il faut bien sûr posséder un serveur de stockage (NAS) sur lequel on a les droits administrateur et le NAS doit être accessible en SSH. Dans l’explication qui suit, on fait référence à deux machines : - _NAS_ : c’est le serveur de stockage qui va héberger toutes les sauvegardes ; - _Client_ : c’est une machine à partir de laquelle on va effectuer les sauvegardes. Ça peut être un ordinateur sous Linux, FreeBSD ou encore sous Mac OS X (voir les différentes façons de l’[installer](https://borgbackup.readthedocs.io/en/stable/installation.html)). ## Installation sur _NAS_ Pour cet article, on utilise un NAS Synology. Il faut activer les paquets « Communauté » (section Community) depuis le centre de paquet, pour ensuite installer le paquet [`Borg`](https://repology.org/project/borgbackup/versions) ce qui permet d’avoir le binaire du serveur qui tourne sur le NAS. Enfin, il faut créer un compte et un groupe dédiés pour faire tourner la partie serveur de Borg (par exemple `borg-backup`). Il faut aussi créer un répertoire `NetBackup` pour les sauvegardes, auquel on donne à l’utilisateur et au groupe dédiés un accès total (lecture/écriture). Afin de pouvoir se connecter via SSH sur ce compte, il est nécessaire sur un NAS Synology de l’affecter au groupe « administrators » : ![borg-backup admin](https://pix.toile-libre.org/upload/original/1582155211.jpg) Après tout cela, on se connecte au compte nouvellement créé sur le serveur de stockage et on s’assure que Borg est bien installé (on notera que contrairement aux paquets fournis par l’éditeur, les paquets « Communautaires » (SynoCommunity) sont installés dans `/usr/local/bin` au lieu de `/usr/bin`) : ```bash borg-backup@nas:~$ which borg /usr/local/bin/borg ``` ## Installation sur _Client_ Borg est disponible pour [la plupart des distributions et sur les divers BSD](https://borgbackup.readthedocs.io/en/stable/installation.html#distribution-package). Faites cependant attention d'utiliser la même version côté _Client_ et côté _NAS_. Au besoin, téléchargez [des binaires prêts à l'emploi](https://borgbackup.readthedocs.io/en/stable/installation.html#pyinstaller-binary) ou bien installez via [pip](https://borgbackup.readthedocs.io/en/stable/installation.html#using-pip). ## Créer une clé SSH sur _Client_ On va avoir besoin de créer une clé SSH depuis un compte `root` si on a besoin de sauvegarder des fichiers nécessitants des droits administrateur, ou bien depuis un compte utilisateur standard si c’est seulement son propre compte que l’on veut sauvegarder. Prenons le cas où c’est l’utilisateur `root` qui fait une sauvegarde de plusieurs répertoires comme `/etc` et `/home`. On génère la clé SSH (on part du principe que le répertoire `/root/.ssh` existe sinon il faut le créer et positionner les droits à 0700) : ```bash ssh-keygen -t ed25519 -f ~/.ssh/id_borg-backup ``` La commande ci-dessus a pour effet de créer une clé publique et privée spécifique avec l’algorithme ed25519 permettant de se connecter au serveur de stockage. Si votre NAS ne gère pas l’Ed25519, vous pouvez choisir n’importe quel autre type de clé (RSA, ECDSA), la sécurisation de la session ssh n’étant pas cruciale du fait que Borg gère l’authentification et le chiffrement des sauvegardes. Voici la configuration que j’ai dû rajouter pour que l’utilisateur root depuis la machine _Client_ puisse accéder au serveur de stockage _NAS_ (`nas.local`) avec la clé nouvellement créée : ```bash client:~# cat ~/.ssh/config Host nas.local User borg-backup IdentityFile ~/.ssh/id_borg-backup # on fait tourner ssh sur un port différent Port 2222 # on gagne un peu de performances en désactivant la compression Compression no # https://borgbackup.readthedocs.io/en/stable/usage/serve.html ServerAliveInterval 10 ServerAliveCountMax 30 ``` Comme on a spécifié le nom du compte à utiliser et le port dans le fichier de configuration SSH, l’URL du dépôt s’écrit `nas.local:/chemin/vers/le/dépôt`. Si on préfère spécifier les paramètres de connexion dans l’URL, on écrit : `borg-backup@nas.local:2222/chemin/vers/le/dépôt`. Il ne reste plus qu’à copier la clé publique de l’utilisateur root sur le serveur : ```bash client:~# ssh-copy-id -i ~/.ssh/id_borg-backup.pub nas.local ``` Une fois la clé copiée, il est possible de se connecter sans avoir besoin de taper le mot de passe. # Mise en œuvre sur _NAS_ : configurer ssh en mode restreint Le chemin d’accès à Borg est `/usr/local/bin` sur _NAS_ alors que le binaire se trouve généralement sous `/usr/bin`. En se connectant via un accès SSH non restreint, le client borg va tenter de lancer un `borg serve` avec un chemin d’accès différent ce qui va renvoyer l’erreur suivante : `Remote: sh: borg: command not found Connection closed by remote host. Is borg working on the server?` Plutôt que de chercher à avoir deux chemins d’accès identiques ([certains sites](https://serverfault.com/questions/973995/borg-backup-remotely-gives-error) vont proposer de contourner le problème en créant un lien symbolique), la bonne pratique est de spécifier le paramètre `command` du côté serveur dans le fichier `authorized_keys`, ce qui aura comme avantage supplémentaire de limiter la session ssh à la partie serveur (RPC) de Borg. Se connecter en tant que `borg-backup` pour configurer le côté serveur / en écoute d’OpenSSH sur laquelle le client va se connecter. ```bash borg-backup@nas:~$ mkdir .ssh borg-backup@nas:~$ chmod 700 .ssh borg-backup@nas:~$ vi ~/.ssh/authorized_keys ``` si la clé publique (`~/.ssh/id_borg-backup.pub`) n’est pas déjà présente, il faut la rajouter ; la clé doit ressembler à : ```bash ssh-ed25519 AAAAC3Nza...P0S27t root@client ``` (il faut bien sûr copier la clé publique générée depuis le poste client) Dernière étape, sécuriser les accès SSH de l’utilisateur root (sur _Client_) en leur restreignant les accès sur le serveur de stockage. Cette opération a pour objectif que les utilisateurs effectuant les sauvegardes et ayant un compte sur _nas.local_ puissent uniquement faire des sauvegardes Borg à travers leur accès SSH. Voici à quoi ressemble le fichier `authorized_keys` une fois les modifications effectuées : ```bash borg-backup@nas:~$ cat .ssh/authorized_keys ssh-ed25519 AAAAC3Nza...BW09/R7Bm cyril@client command="/usr/local/bin/borg serve --restrict-to-path /volume1/NetBackup/chezmoi/",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty,no-user-rc ssh-ed25519 AAAAC3Nza...P0S27t root@client command="/usr/local/bin/borg serve --restrict-to-repository /volume1/NetBackup/copain/ --storage-quota 128G",no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty,no-user-rc ssh-ed25519 AAAAC3Nza...SRW55E user@client2 ``` Quelques explications s’imposent : - la première ligne, qui contient uniquement la clé `cyril@client`, permet de se connecter sur le NAS depuis un compte utilisateur pour effectuer la configuration ; - la partie `command="..."` que l’on rajoute sur les deux lignes suivantes permet de limiter la session ssh à une commande `borg serve` qui interagira avec la partie cliente lancée depuis les postes à sauvegarder ; - les options de restriction SSH après la commande : `no-port-forwarding,no-X11-forwarding,no-agent-forwarding,no-pty,no-user-rc` sont pour éviter des redirections de ports/X11 ou d’agent au sein de la session ssh (normalement on n’a pas tout ça sur le serveur de stockage, mais c’est une bonne pratique de sécurité de limiter les fonctionnalités d’OpenSSH à uniquement la communication client/serveur du logiciel Borg) ; - il faut indiquer le chemin complet pour la commande `borg serve` ; - l’option `--restrict-to-path` permet à l’utilisateur root sur _Client_ de créer plusieurs sauvegardes sous le dépôt qui lui est attribué, tandis que `--restrict-to-repository` limite l’utilisateur `user@client2` à ne pouvoir faire la sauvegarde que dans le dépôt/répertoire spécifié et pas les sous-répertoires ; - l’option `--storage-quota` impose un quota disque (c’est aussi possible d’avoir une limitation à l’initialisation, mais vu que c’est l’utilisateur distant qui effectue la création du dépôt, c’est plus sûr de le forcer sur le serveur de stockage). N.B. Il y avait [un bug](https://github.com/borgbackup/borg/issues/4093), corrigé avec la version 1.1.8 (la version installée par défaut sur Synology et QNAP à l’heure où ces lignes sont écrites est la 1.1.7), qui permettait à un client de contourner le quota supposé être imposé par le serveur. # Mise en oeuvre sur _Client_ On stocke le mot de passe en clair dans le fichier `~/.borg/passphrase` ... ```bash umask 077 mkdir ~/.borg vi ~/.borg/passphrase [création d’une clé secrète si possible de façon totalement aléatoire] ``` ... puis on définit une variable d’environnement pour ne pas avoir à retaper le mot de passe : ```bash export BORG_PASSPHRASE="`cat ~/.borg/passphrase`" ``` **Afin de pouvoir accéder et déchiffrer les sauvegardes sur le serveur, il faut s’assurer de copier la clé (mot de passe Borg) autre part que sur l’ordinateur qui déclenche les sauvegardes en cas de perte ou dysfonctionnement de ce dernier (la copier dans un endroit sécurisé)**. On initialise avec le mode `repokey-blake2` qui permet d’avoir une sauvegarde [chiffrée et authentifiée avec AES](https://borgbackup.readthedocs.io/en/stable/usage/init.html#encryption-modes) : ``` borg init --encryption=repokey-blake2 'nas.local:/volume1/NetBackup/chezmoi/{hostname}' ``` et pour vérifier que le dépôt est créé : `borg info 'nas.local:/volume1/NetBackup/chezmoi/{hostname}'` ## Cas d'un _Client_ distant Lorsque l’on fait une sauvegarde depuis Internet, à moins de rajouter une entrée dans le fichier `/etc/hosts`, on ne peut pas utiliser _nas.local_ car c’est le nom complet ([[FQDN]]) de la machine qui héberge le dépôt qui doit être utilisé. Petit mémo : - refaire la configuration client SSH ; - régénérer la clé depuis le compte user ; - la copier sur _NAS_ comme précédemment ; - ne pas oublier de changer le fichier `~/.ssh/config` sur _NAS_ ; - initialiser `borg init --encryption=repokey-blake2 'nas.example.com:/volume1/NetBackup/chezmoi/{hostname}'` # Exemples Voici un exemple de script qui sauvegarde régulièrement les répertoires `/etc`, `/var` et `/home` : ```sh #!/usr/bin/env bash set -e LOG_PATH=/var/log/borg-backup.log export BORG_PASSPHRASE="`cat ~root/.borg/passphrase`" BORG_REPOSITORY="nas.local:/volume1/NetBackup/chezmoi/{hostname}" BORG_ARCHIVE=${BORG_REPOSITORY}::{now:%Y-%m-%d} borg create \ --verbose --stats \ $BORG_ARCHIVE \ /etc /var /home \ --exclude-caches \ --exclude-nodump \ --exclude /home/cyril/tmp --exclude-if-present Trash --exclude-if-present .thumbnails \ --noatime \ >> ${LOG_PATH} 2>&1 # Nettoyage des anciennes sauvegardes # On conserve # - une archive par jour les 7 derniers jours, # - une archive par semaine pour les 6 dernières semaines, # - une archive par mois pour les 8 derniers mois. borg prune --verbose \ $BORG_REPOSITORY \ --keep-daily=7 \ --keep-weekly=6 \ --keep-monthly=8 \ >> ${LOG_PATH} 2>&1 ``` Il ne vous reste plus qu’à lancer vos sauvegardes régulièrement en copiant le script dans le répertoire `/etc/cron.daily/`, et attendre d’en avoir besoin tout en ayant pris soin de les avoir testés pour s’assurer que l’on est en mesure de récupérer les données depuis un nouvel ordinateur (**copiez la clé dans un endroit sûr** ! ;-). La récupération peut se faire depuis n’importe quelle machine y compris depuis un compte utilisateur normal pourvu qu’il possède ces deux éléments : - une clé SSH permettant de se connecter au NAS (au processus `borg serve`) - la clé de chiffrement (ici `repokey-blake2`) pour s’authentifier et déchiffrer les données sauvegardées Si les deux conditions sont réunies, voici comment on peut monter un dépôt Borg distant sur un répertoire quelconque : ```bash $ export BORG_PASSPHRASE="`cat ~/.borg/passphrase`" $ borg list nas.local:/volume1/NetBackup/chezmoi/client | tail -n 2 2020-04-16 Thu, 2020-04-16 06:58:43 [2f3824...f6e] 2020-04-17 Fri, 2020-04-17 07:39:03 [ed3b98...c79] $ mkdir /tmp/localborg/ $ borg mount nas.local:/volume1/NetBackup/chezmoi/client::2020-04-16 /tmp/localborg $ cat /tmp/localborg/etc/issue.net Debian GNU/Linux bullseye/sid $ umount /tmp/localborg ```