URL: https://linuxfr.org/news/installer-borgbackup-sur-un-nas
Title: Installer BorgBackup sur un NAS
Authors: Cyril Chaboisseau
 ZeroHeure, palm123, theojouedubanjo, Xavier Teyssier, Davy Defaud, Ysabeau 🧶 et bubar🦥
Date: 2020年02月08日T21:49:34+01:00
License: CC By-SA
Tags: nas, wiki, tutoriel, sauvegarde, borg, installer et borgbackup
Score: 40
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 BorgBackup](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 et 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‐serveur, 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 NFS v4).
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 l’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 d’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 GNU/Linux, FreeBSD ou encore sous macOS (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 paquets, 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 et écriture).
 
Afin de pouvoir se connecter via SSH à 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 l’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 paire de clés publique et privée spécifique avec l’algorithme [Ed25519](https://fr.wikipedia.org/wiki/EdDSA) 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 l’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 lequel 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 bogue](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 œuvre 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 pleinement qualifié ([[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 utilisateur ;
- 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 \
 --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/` puis attendre d’en avoir besoin, en ayant cependant pris soin de les avoir testées 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
```
</div><div class="naked_ctrl">
<form action="/index.cgi/contrast" method="get" name="gate">
<p><a href="http://altstyle.alfasado.net">AltStyle</a> によって変換されたページ <a href="httpS://linuxfr.org/news/installer-borgbackup-sur-un-nas.md">(-&gt;オリジナル)</a>
/ <label>アドレス: <input type="text" name="naked_post_url" value="httpS://linuxfr.org/news/installer-borgbackup-sur-un-nas.md" size="22" /></label> <label>モード: <select name="naked_post_mode">
<option value="default">デフォルト</option>
<option value="speech">音声ブラウザ</option>
<option value="ruby">ルビ付き</option>
<option value="contrast" selected="selected">配色反転</option>
<option value="larger-text">文字拡大</option>
<option value="mobile">モバイル</option>
</select>
<input type="submit" value="表示" />
</p>
</form>
</div>