(Modifié le 26/08/2019)

Outil de sauvegarde BorgBackup

Borg est un programme de sauvegarde dédupliquant qui prend également en charge la compression et le cryptage authentifié. Il fournit un moyen efficace et sécurisé de sauvegarder les données. La technique de déduplication des données utilisée rend Borg adapté aux sauvegardes quotidiennes puisque seules les modifications sont stockées. La technique de cryptage authentifiée permet d’effectuer des sauvegardes sur des cibles qui ne sont pas entièrement fiables.(Doc format PDF)*

Fonctionnalités

  • déduplication efficace ;
  • chiffrement (optionnel, activé par défaut) ;
  • compression (optionnelle, désactivée par défaut) ;
  • restauration aisée (archive montable comme une clef USB).
  • Une archive représente un ou plusieurs dossiers sauvegardés à une date/heure donnée , elle est contenue dans un dépôt, et est référencée par un chemin type ::.
  • Par exemple, si je nomme mes sauvegardes par date au sein du dépôt /mnt/sauvegarde/mamachine, mon archive pourra s’appeler /mnt/sauvegarde/mamachine::2016-05-04.
  • On peut choisir de compresser une archive (et donc les blocs auxquels elle fait référence).
  • L’archive ne contient pas les blocs, mais référence leurs hash (identifiants uniques) au sein du dépôt.

Chaque opération de sauvegarde crée une nouvelle archive et stocke le contenu des nouveaux blocs (nouveaux fichiers ou parties modifiées) au sein du dépôt.

Quelle que soit l’opération (sauvegarde, montage, restauration…), on appellera toujours la commande borg en utilisant ses différentes sous-commandes (borg create, borg mount, borg extract…). En cas de saine curiosité, borg –help ou borg --help sont vos amis.

Installation

Borg est inclus dans de nombreux dépôts de distributions Linux mais il est préférable de l’installer manuellement.

wget https://github.com/borgbackup/borg/releases/download/1.1.5/borg-linux64
chmod +x borg-linux64
mv borg-linux64 /usr/local/bin/borg

Un paquet borgbackup est disponible directement dans Ubuntu 16.04.

# apt install borgbackup

Debian Stretch avec les dépôts “backports”

sudo apt edit-sources # pour ajouter la ligne pour les dépôts "backports"
deb http://deb.debian.org/debian stretch-backports main contrib non-free

Votre fichier « /etc/apt/sources.list » a changé, veuillez lancer « apt-get update »

sudo apt update

Installer borgbackup

sudo apt -V -t=stretch-backports install borgbackup

Initialisation

L’initialisation d’un dépôt de sauvegarde Borg se fait à l’aide de la commande borg init. Le paramètre chemin passé en paramètre peut être un emplacement local (absolu ou relatif), ou un emplacement distant en utilisant la syntaxe <user>@<host>:<path>. Dans le cas d’un dépôt distant, l’accès se fait par SSH, et nécessite que Borg soit installé sur la machine distante.

Le paramètre –encryption (abrégé -e) permet de définir la manière dont la sauvegarde est chiffrée :

  • none : La sauvegarde n’est pas chiffrée.
  • repokey : La clé de chiffrement est écrite dans le fichier de configuration du dépôt de sauvegarde (par défaut).
  • keyfile : La clé de chiffrement est écrite dans un fichier séparé.

Le mode keyfile permet d’éviter qu’un attaquant ayant accès au dépôt de sauvegarde n’ait aussi la clé de déchiffrement. Il est bien évidemment fortement conseillé de sauvegarder la clé de chiffrement dans un emplacement séparé.

Lors de l’utilisation des modes repokey et keyfile, une phrase de passe optionnelle sera demandée, afin de protéger la clé de chiffrement. La phrase de passe est nécessaire pour débloquer la clé de chiffrment lors de la création de nouvelles sauvegarde, pas uniquement lors de la lecture des données. Il sera donc nécessaire d’utiliser l’une des variables d’environnement BORG_PASSPHRASE ou BORG_PASSCOMMAND pour automatiser la sauvegarde, si vous en définissez une.

Si la phrase de passe ne convient plus, ou qu’elle a été révélée à un tiers, il est possible de la changer avec la commande borg change-passphrase. Cela peut être utile aussi pour conserver une clé de chiffrement protégée par une phrase de passe sur un support externe, tout en laissant une clé de chiffrement sans phrase de passe sur la machine qui effectue les sauvegardes. De cette manière, il n’est pas nécessaire de mettre la phrase de passe en clair dans le script de sauvegarde, tout en sécurisant les sauvegardes de la clé de chiffrement.

Exemples :

$ # Initialiser un dépôt de sauvegarde non chiffré
$ borg init -e none <UnencryptedRepoPath>
$ # Initialiser un dépôt de sauvegarde chiffré
$ borg init -e keyfile <RepoPath>
$ # Changement de la phrase de passe
$ borg change-passphrase <RepoPath>

Création d’une sauvegarde

La sauvegarde de fichiers et de répertoires se fait à l’aide de la commande borg create. Le premier paramètre est le nom de la sauvegarde, de la forme <RepoPath::SaveName>, suivi des fichiers et répertoires à sauvegarder.

Le nom de la sauvegarde peut contenir des chaînes réservées, remplacées par une valeur spécifique, dont :

  • {hostname} : Le nom d’hôte court de la machine.
  • {fqdn} : Le nom d’hôte complet de la machine.
  • {now} : La date et l’heure locales.
  • {utcnow} : La date et l’heure UTC.
  • {user} : Le nom de l’utilisateur réalisant la sauvegarde.

Note : Pour les valeurs {now} et {utcnow}, il est possible de définir le format, au moyen de cette syntaxe : {now:%Y%m%d-%H%M%S}. Les éléments de formatage utilisés sont ceux disponibles de Python.

Il est possible d’utiliser - comme nom de fichier pour sauvegarder les données envoyées à l’entrée standard de la commande Borg. Ces données sont enregistrées dans un fichier nommé stdin, placé à la racine de la sauvegarde.

Pour compresser les données sauvegardées, il faut utiliser le paramètre –compress (abrégé -C). La valeur définit à la fois l’algorithme de compression (none, lz4, zlib ou lzma) et le niveau de compression, dans le cas des algorithme zlib et lzma, de 0 à 9, séparés par une virgule.

Pour exclure des chemins de la sauvegarde, il est possible d’utiliser le paramètre –exclude (abrégé -e), qui exclut un unique chemin, ou le paramètre –exclude-from, qui exclue tous les chemins présents dans un fichier donné.

Enfin, les paramètres –verbose (abrégé -v), –stats (abrégé -s) et –progress (abrégé -p) permettent d’afficher des informations sur les opérations effectuées pendant la sauvegarde et sur son contenu.

Exemples :

$ # Sauvegarde d'un fichier
$ borg create --verbose --stats --progress <RepoPath>::<SaveName> <Path>/<Filename>
$ # Sauvegarde d'un répertoire en le compressant
$ borg create --verbose --stats --progress --compress zlib,9 <RepoPath>::<SaveName> <Path>/<Directory>
$ # Sauvegarde d'une base de données PostgreSQL
$ pg_dump -Ft <DbName> | borg create --verbose --stats --progress <RepoPath>::<SaveName> -
$ # Sauvegarde du système complet, en le compressant, et en excluant certains chemins
$ borg create -v -s -p -C lzma,6 --exclude-from=<IgnoreFilePath> <RepoName>::{hostname}-{now:%Y%m%d-%H%M%S} /

Note : Lors de la sauvegarde d’un système complet, il est conseillé d’exclure tous les répertoires de montages spéciaux et temporaires (/dev, /media, /mnt, /proc, /run, /sys, /tmp, etc.). J’exclus aussi le répertoire de cache de Borg (par défaut ~/.cache/borg), puisqu’il est généré automatiquement, et qu’il peut atteindre une taille assez importante.

Automatisation

Nous utilisons la configuration par défaut de cron, qui s’arrange pour que les scripts placés dans /etc/cron.daily soient exécutés quotidiennement.

Puisque les sauvegardes sont poussées, l’automatisation est à configurer sur le client uniquement.

Jusqu’ici, Borg nous demandait la phrase de passe à chaque opération. À des fins d’automatisation, il nous faut désormais la stocker dans un fichier :

root@babasse # mkdir /root/.borg
root@babasse # cat > /root/.borg/passphrase
monmotdepasse

([Ctrl]+[D] pour valider)

et la protéger des autres utilisateurs de la machine :

root@babasse # chmod 700 /root/.borg/passphrase

Je vous propose ensuite un script de sauvegarde (notez l’usage de borg prune pour supprimer les archives trop anciennes). Cette version est fonctionnelle, mais simplifiée et commentée.

root@babasse # cat > /etc/cron.daily/borg-backup
#!/bin/sh
#
# Script de sauvegarde.
#
# Envoie les sauvegardes sur un serveur distant, via le programme Borg.
# Les sauvegardes sont chiffrées
#
 
set -e
 
BACKUP_DATE=`date +%Y-%m-%d`
LOG_PATH=/var/log/borg-backup.log
 
export BORG_PASSPHRASE="`cat ~root/.borg/passphrase`"
BORG_REPOSITORY=borg@nas.example.com:/var/lib/borg-backups/babasse
BORG_ARCHIVE=${BORG_REPOSITORY}::${BACKUP_DATE}
 
borg create \
-v --stats --compression lzma,9 \
$BORG_ARCHIVE \
/etc /var/mail /home \
>> ${LOG_PATH} 2>&1
 
# Nettoyage des anciens backups
# On conserve
# - une archive par jour les 7 derniers jours,
# - une archive par semaine pour les 4 dernières semaines,
# - une archive par mois pour les 6 derniers mois.
 
borg prune -v $BORG_REPOSITORY \
--keep-daily=7 \
--keep-weekly=4 \
--keep-monthly=6 \
>> ${LOG_PATH} 2>&1
 

[Ctrl]+[D] pour valider, puis rendre le script exécutable :

# chmod 775 /etc/cron.daily/borg-backup

Cron et ordinateur personnel

Un ordinateur personnel n’est pas forcément allumé 24h/24, il est donc peu pertinent de demander à un script de s’exécuter à la même heure tous les jours. Aussi, il convient d’installer anacron, qui s’arrangera pour exécuter les scripts contenus dans /etc/cron.d/daily quotidiennement, en rattrapant « intelligemment » la tâche plus tard si l’ordinateur était éteint à l’heure configurée (si l’ordinateur était éteint une semaine complète, l’exécution ne sera rattrapée qu’une fois).

# apt install anacron

Aucune configuration supplémentaire n’est nécessaire.
Par ailleurs, notons que Borg saura reprendre proprement s’il est interrompu.

Parcourir les données sauvegardées

Il est possible de lister le contenu du dépôt de sauvegarde au moyen de la commande borg list.

Lorsque le seul paramètre passé est l’emplacement d’un dépôt de sauvegarde, cette commande liste les différentes sauvegardes qui s’y trouvent. On peut y ajouter le nom d’une sauvegarde, pour lister le contenu complet de la sauvegarde.

Exemples :

$ # Lister les sauvegardes disponibles
$ borg list <RepoPath>
$ # Lister le contenu d'une sauvegarde
$ borg list <RepoPath>::<SaveName>

La commande borg info permet d’afficher quelques informations basiques sur une sauvegarde, comme les dates de début et de fin, la commande utilisée pour générer cette sauvegarde, la taille des données sauvegardées, ou encore l’espace disque total occupé :

$ borg info <RepoPath>::<SaveName>

Pour parcourir le contenu des sauvegardes de manière plus naturelle, la commande borg mount permet de monter le dépôt de sauvegarde dans un répertoire en utilisant fuse (Filesystem in USErspace). Le répertoire racine du point de montage contiendra alors une liste de répertoires, correspondant aux différentes sauvegardes disponibles, qu’il est possible d’explorer avec vos outils habituels, comme n’importe quel répertoire. Cette méthode est particulièrement pratique pour récupérer un fichier, voire une information précise dans un fichier, sans avoir à restaurer la totalité de la sauvegarde.

$ # Monter le dépôt de sauvegarde dans un répertoire
$ borg mount <RepoPath> <MountPointPath>
$ # Pour une sauvegarde réalisée en root, il est intéressant de permettre aux utilisateurs de la parcourir
$ sudo -i borg mount -o allow_other <RepoPath> <MountPointPath>

Borg propose une approche originale borg mount pour visualiser ou restaurer une archive : en les montant comme on le ferait avec une clef USB. Il devient alors aisé d’explorer le contenu d’une archive de sauvegarde et d’en restaurer certains fichiers par simple copie.

Montons une des archives :

# mkdir /mnt/borg_archive
# borg mount /mnt/sauvegarde/borg_repo::mercredi /mnt/borg_archive

Il suffit ensuite de copier un fichier pour le restaurer depuis une archive :

# cp /mnt/borg_archive/home/jdoe/Images/DSCN7725.JPG /home/jdoe/Images/

Une fois nos opérations de sauvetage accomplies, il nous suffit de démonter l’archive.

# umount /mnt/borg_archive

Pour information, il existe également une commande borg extract qui permet de restaurer tout ou partie d’une archive sans la monter, utilisez borg extract –help pour en savoir plus.

Faut-il faire ses sauvegardes en root ?
Pour sauvegarder le /home d’un utilisateur en particulier, mieux vaut que ça soit l’utilisateur en question qui fasse lui-même ses sauvegardes.
Pour sauvegarder tout le système ou bien des répertoires aux propriétaires divers, le faire en root reste la solution la moins complexe (et celle exposée ici).
Une autre solution est d’utiliser un utilisateur unix dédié et des ACL autorisant la lecture seule sur tous les fichiers.

Restauration d’une sauvegarde

La restauration d’une sauvegarde peut être effectuée au moyen de la commande borg extract. Cette commande prend en paramètre le nom de la sauvegarde à restaurer, ainsi qu’une liste optionelle de chemins à restaurer depuis cette sauvegarde. Si aucun chemin n’est donné, la totalité de la sauvegarde est restaurée.

Les fichiers et répertoires restaurés sont écrits dans le répertoire courant. Il est possible de restaurer des données sur la sortie standard, au moyen du paramètre –stdout. Cela est utile pour les données sauvegardées depuis l’entrée standard, mais permet aussi de transférer directement un fichier provenant d’une sauvegarde complète à un programme.

Exemples :

$ # Restaurer une sauvegarde complète
$ borg extract <RepoPath>::<SaveName>
$ # Restaurer une partie de la sauvegarde
$ borg extract <RepoPath>::<SaveName> <Filename> <Path>/<Directory>
$ # Restaurer une base de données PostgreSQL
$ borg extract --stdout <RepoPath>::<SaveName> stdin | pg_restore -d <DbName>
$ # Lister le contenu d'une archive tar présente dans la sauvegarde
$ borg extract --stdout <RepoPath>::<SaveName> <FileName>.tgz | tar zt

Contrôle d’intégrité

La commande borg check permet de vérifier l’intégrité des données sauvegardées. Elle peut travailler sur le dépôt complet, ou sur une ou plusieurs sauvegardes.

Le paramètre –prefix (abrégé -P) détermine le préfixe du nom des sauvegardes à vérifier. Par défaut, toutes sont vérifiées.

Exemples :

$ # Vérifier le dépôt complet
$ borg check <RepoPath>
$ # Vérifier une unique sauvegarde
$ borg check <RepoPath>::<SaveName>
$ # Vérifier toutes les branches de la machine desktop
$ borg check --prefix=desktop <RepoPath>

Note : Il existe aussi un paramètre –repair, permettant de tenter la réparation des données corrompues détectées, mais son utilisation est actuellement déconseillée, puisque cette fonctionnalité est encore expérimentale.

Libérer de l’espace disque

Lorsque le dépôt de sauvegarde devient trop gros, il peut être nécessaire de réduire l’espace disque utilisé.

Borg propose deux commandes pour cela :

  • borg delete : Supprime le dépôt complet, ou une sauvegarde précise.
  • borg prune : Supprime des sauvegardes selon des critères.

Suppression du dépôt complet

Lorsque seul le chemin du dépôt est passé en paramètre à la commande borg delete, le dépôt complet est supprimé. Le cache local associé à ce dépôt est alors lui aussi supprimé.

L’utilisation de cette commande provoque l’affichage d’un message d’avertissement, listant toutes les sauvegardes qui seront supprimées.

Suppression d’une sauvegarde

Lorsque le nom d’une sauvegarde est ajouté à la suite du nom du dépôt de sauvegarde dans les paramètres de la commande borg delete, cette sauvegarde est supprimée du dépôt. Cette commande est utile pour supprimer une sauvegarde ayant inclus un gros fichier temporaire par inadvertance, par exemple.

Cette commande n’affiche pas de message d’avertissement, il faut donc bien faire attention avant de la lancer.

Suppression de sauvegardes selon des critères

Un nettoyage automatique du dépôt de sauvegarde peut être réalisé au moyen de la commande borg prune. Cette commande prend en paramètres le dépôt à nettoyer, ainsi que le nombre de sauvegardes à conserver par période (heure, jour, semaine, mois, année).

Les paramètres possibles sont :

  • –prefix (abrégé -P) : Définit le préfixe des sauvegardes à prendre en compte (toutes par défaut).
  • –keep-within : Définit une période dans laquelle toutes les sauvegardes doivent être conservées.
  • –keep-hourly (abrégé -H) : Conserver la dernière sauvegarde des X dernières heures.
  • –keep-daily (abrégé -d) : Conserver la dernière sauvegarde des X derniers jours.
  • –keep-weekly (abrégé -w) : Conserver la dernière sauvegarde des X dernières semaines.
  • –keep-monthly (abrégé -m) : Conserver la dernière sauvegarde des X derniers mois.
  • –keep-yearly (abrégé -y) : Conserver la dernière sauvegarde des X dernières années.
  • –list : Associé à –verbose, permet d’afficher la liste des sauvegardes conservées et supprimées.
  • –dry-run (abrégé -n) : Permet de tester ce qui serait fait, sans supprimer réellement les données, avec –list.

Lors de l’évaluation des paramètres, les sauvegardes marquées comme devant être conservées par les précédents ne sont pas prises en compte. Ainsi, demander à conserver la dernière sauvegarde des 48 dernières heures, ainsi que la dernière sauvegarde des 15 derniers jours conservera les 48 dernières sauvegardes, plus une sauvegarde des quinza derniers jours. Si le critère “sauvegardes des 48 dernières heures” prend toutes les sauvegardes des deux derniers jours, le critère “sauvegardes des 15 derniers jours” commencera à partir du troisième jour, jusqu’au dix-huitième.

Exemples :

$ # Supprimer toutes les sauvegardes plus vieilles que deux semaines
$ borg prune --keep-within 2w
$ # Supprimer les sauvegardes selon des critères plus précis
$ borg prune --keep-within 1w --keep-hourly 24 --keep-daily 14 --keep-monthly 6

Débloquer un dépôt verrouillé

Lorsqu’il travaille sur le dépôt, Borg le verrouille pour empêcher qu’une autre opération ne se lance en parallèle dessus. Tenter de lancer la création d’une sauvegarde, la restauration, ou simplement de lister les sauvegardes disponible renverra alors une erreur, indiquant que le dépôt de sauvegarde est verouillé.

Cependant, il peut arriver que le dépôt reste bloqué, suite à une coupure de la connexion réseau, ou un crash de Borg ou du système, par exemple. Dans ce cas, il est nécessaire de forcer le déverrouillage, au moyen de la commande borg break-lock.

Attention : Le dépôt est verrouillé lors de toutes les opérations. Par exemple, monter le dépôt dans un répertoire avec la commande borg mount verrouille aussi le dépôt. Vérifiez donc bien qu’aucune opération ne soit en cours avant de forcer le déverrouillage du dépôt, pour éviter toute corruption de données.

Sauvegarder et restaurer la clé de chiffrement

Sauvegarder la clé de chiffrement est fortement conseillé, surtout lorsqu’elle est conservée dans un fichier séparé du dépôt de sauvegarde. En effet, sans cette clé, les sauvegardes sont inutilisables.

Lors de l’utilisation du mode repokey, la clé étant sauvegardée dans le fichier de configuration du dépôt, il n’est pas vraiment nécessaire de la sauvegarder. Cependant, dans le cas où ce fichier serait endommagé, il peut être utile de le faire.

Borg propose plusieurs formats pour sauvegarder la clé de chiffrement, avec la commande borg key export :

  • Par défaut : Enregistrement de la clé directement dans un fichier.
  • –paper : Génération d’une série de valeurs, destinées à être imprimées, ou écrites à la main sur un papier.
  • –qr-html : Génération d’un QR Code contenant la clé de chiffrement, destiné à être imprimé.

Les deux formats destinés à être imprimés permettent de sauvegarder la clé de chiffrement hors de tout système informatique. Dans le cas du QR Code, le scanner avec un lecteur compatible permet de retrouver le contenu original de la clé. Dans le cas de la série de valeurs générée, elle est faite de manière à pouvoir vérifier, ligne par ligne, s’il y a eu des fautes de frappe, et ainsi simplifier la recherche d’une erreur dans ce cas.

L’import d’une clé est réalisé grâce à la commande borg key import. De la même manière que pour l’export, le paramètre –paper active le mode papier, permettant de saisir les séries de valeurs, ligne par ligne, en vérifiant la somme de contrôle de chaque ligne. Le mode par défaut demande, en plus du chemin du dépôt de sauvegarde, un paramètre désignant le fichier contenant la clé de chiffrement à importer.

Sauvegarde locale

  • Archlinux : Sauvegarde des données avec BORG
  • La sauvegarde sera exécutée avec l’utilisateur borg sous root pour les dossiers et fichiers systèmes
  • /root/.borg : Le dossier des fichiers (script, passphrase et exclusions)
  • /srv/savlocal/borg-backups : Le dossier qui contient les dépôts

Créer les dossiers

sudo mkdir -p /srv/savlocal/borg-backups /root/.borg

Création d’un fichier passphrase ( ex: qui contient 6 mots aléatoires séparés par un espace) qui servira à automatiser la procédure de sauvegarde sauvegarde (/root/.borg/passphrase)

sudo nano /root/.borg/passphrase # contient la "phrase de passe"

Création d’un fichier exclusions qui contient toutes les exclusions de dossiers et fichiers , une exclusion par ligne (/root/.borg/exclusions)

sudo nano /root/.borg/exclusions
/home/yannick/Téléchargements 
/home/yannick/media  
/home/yannick/videos-series  
/home/yannick/virtuel  
/home/yannick/DevelNFS  
/home/yannick/Sauvegarde-Locale  
/home/yannick/Partage  
/home/yannick/Vidéos   
/home/yannick/.thumbnails 
/home/yannick/.xsession-errors  
/home/yannick/Sauvegarde-Locale  
/home/yannick/temp  
/home/yannick/.cache  
/mnt/dplus/temp  
/mnt/dplus/iso  
/mnt/dplus/.Trash-1000 

Initialisation dépôt

Initialisation dépôt “yannick-pc” de sauvegarde chiffré, la “phrase de passe” sera demandée

sudo borg init --encryption=repokey-blake2 /srv/savlocal/borg-backups/yannick-pc

Création du script

Borg a la déduplication, le contrôle de cohérence, le cryptage, est configurable par des variables d’environnement, la récupération des fichiers avec FUSE pour le montage des dépôts. En utilisant borg prune, on peut avoir une haute fréquence de sauvegardes avec une gestion du cycle des repo : 6 heures, 7 jours, 4 semaines, et 6 mois.

Le fichier script /root/.borg/borg-backup

sudo nano /root/.borg/borg-backup
#!/bin/bash

set -e
 
# Vérifier si utilisateur est root
if [ $(id -u) != "0" ]; then
    echo "Erreur : Vous devez être root pour exécuter ce script !"
    exit 1
fi

# Sauvegarde des partages NFS si présent
if [ ! -d "/net/shuttle/srv" ];then
  echo "Les partages NFS ne sont pas montés !" 
  exit 1
fi

BACKUP_DATE=`date +%Y-%m-%d-%Hh%M`
echo "Exécution borg-backup yannick-pc $BACKUP_DATE" 
export BORG_PASSPHRASE="`cat /root/.borg/passphrase`"
BORG_REPOSITORY=/srv/savlocal/borg-backups/yannick-pc
BORG_ARCHIVE=${BORG_REPOSITORY}::${BACKUP_DATE}

# Sauvegarde de tout /home à l'exception de quelques répertoires et fichiers exclus
borg create \
-v --stats --compression lzma,9 \
--exclude-from /root/.borg/exclusions --exclude-caches \
$BORG_ARCHIVE \
/mnt/Musique \
/mnt/BiblioCalibre \
/mnt/yanspm-md \
/home/yannick \
/mnt/Musique \
/mnt/BiblioCalibre \
/mnt/yanspm-md \
/mnt/dplus \
/mnt/gitea 


# En cas d'erreur de sauvegarde, réinitialiser le mot de passe et quitter.
if [ "$?" = "1" ] ; then
    export BORG_PASSPHRASE=""
    exit 1
fi

# Prune la repo de sauvegardes supplémentaires
borg prune \
-v --list --stats --keep-daily=7 --keep-weekly=4 --keep-monthly=6 \
$BORG_REPOSITORY 
 
# Inclure la capacité restante de l'appareil dans le journal.
echo "--------------------------------------------------------------" 
echo "Pourcentage volume utilisé par les backups" 
echo  $(df -h |egrep 'Taille') 
echo -e $(df -h |egrep '/srv/savlocal') 
echo "--------------------------------------------------------------" 
 
borg list $BORG_ARCHIVE
 
# réinitialiser le mot de passe
export BORG_PASSPHRASE=""
echo "Fin exécution borg-backup" 
exit 0

Comment utiliser Borg avec SystemD service + timer

Pour une automatisation en utilisant systemd :

  • vous devez créer un fichier borg-backup.service et le mettre dans le dossier /etc/systemd/system/system/
  • Pour une exécution régulière (parce que ce n’est pas un processus “daemon”), un fichier borg-backup.timer , dans le même dossier que borg-backup.service
  • Le nom de fichier avant le suffixe “.service” et “.timer” doit correspondre pour que systemd reconnaisse ce qu’il doit faire.

Service : /etc/systemd/system/borg-backup.service

[Unit]
Description=Borg Backup Service
After=network-online.target
 
[Service]
Type=simple
ExecStart=/bin/bash /root/.borg/borg-backup 
StandardError=journal
Restart=on-abort


[Install]
WantedBy=multi-user.target

Adapter User= et Group= dans le fichier borg-backup.service pour un utilisateur qui a les droits sur la sauvegarde. Exécuter le service par défaut mettrait la propriété root:root sur la sauvegarde.

Il est possible de tester le service avec un simple

sudo systemctl daemon-reload         # on vient de créer un nouveau service
systemctl start borg-backup.service

l’état de votre système de sauvegarde

systemctl status borg-backup

Le journal

journalctl   -u borg-backup 
janv. 30 12:24:57 yannick-pc systemd[1]: Starting Borg User Backup...
janv. 30 12:24:58 yannick-pc bash[8873]: Creating archive at "/srv/savlocal/borg-backups/yannick-pc::2019-01-30-12h24"
janv. 30 12:25:36 yannick-pc bash[8873]: ------------------------------------------------------------------------------
janv. 30 12:25:36 yannick-pc bash[8873]: Archive name: 2019-01-30-12h24
janv. 30 12:25:36 yannick-pc bash[8873]: Archive fingerprint: 149d79c638fd2c219cf53ccd0ff9293a45a441a7aab669121078902e5fc55842
janv. 30 12:25:36 yannick-pc bash[8873]: Time (start): Wed, 2019-01-30 12:24:58
janv. 30 12:25:36 yannick-pc bash[8873]: Time (end):   Wed, 2019-01-30 12:25:34
janv. 30 12:25:36 yannick-pc bash[8873]: Duration: 36.26 seconds
janv. 30 12:25:36 yannick-pc bash[8873]: Number of files: 258618
janv. 30 12:25:36 yannick-pc bash[8873]: Utilization of max. archive size: 0%
janv. 30 12:25:36 yannick-pc bash[8873]: ------------------------------------------------------------------------------
janv. 30 12:25:36 yannick-pc bash[8873]:                        Original size      Compressed size    Deduplicated size
janv. 30 12:25:36 yannick-pc bash[8873]: This archive:              154.74 GB            135.56 GB              4.43 MB
janv. 30 12:25:36 yannick-pc bash[8873]: All archives:              309.48 GB            271.11 GB             75.54 GB
janv. 30 12:25:36 yannick-pc bash[8873]:                        Unique chunks         Total chunks
janv. 30 12:25:36 yannick-pc bash[8873]: Chunk index:                  205248               624341
janv. 30 12:25:36 yannick-pc bash[8873]: ------------------------------------------------------------------------------
janv. 30 12:25:37 yannick-pc bash[8873]: Keeping archive: 2019-01-30-12h24                     Wed, 2019-01-30 12:24:58 [149d79c638fd2c219cf53ccd0ff9293a45a441a7aab669121078902e5fc55842]
janv. 30 12:25:37 yannick-pc bash[8873]: Pruning archive: 2019-01-30-06h29                     Wed, 2019-01-30 06:29:41 [52d14020c37f519d1d900b63c1a81834401c09e7af7deaa59f2646fcf8ea535f] (1/1)
janv. 30 12:25:41 yannick-pc bash[8873]: ------------------------------------------------------------------------------
janv. 30 12:25:41 yannick-pc bash[8873]:                        Original size      Compresse[yannick@yannick-pc ~]$ sudo systemctl enable borg-backup

Valider le service borg-backup.service

sudo systemctl enable borg-backup

Timer : /etc/systemd/system/borg-backup.timer

[Unit]
Description=Borg Backup Timer
 
[Timer]
#
OnBootSec=15min
OnUnitActiveSec=1d
Unit=borg-backup.service
 
[Install]
WantedBy=timers.target
  • OnCalendar permet d’indiquer l’occurrence et la fréquence d’exécution du script. Il y a les abréviations classiques (“minutely”, “hourly”, “daily”, “monthly”, “weekly”, “yearly”, “quarterly”, “semiannually”, etc) mais vous pouvez avoir des choses plus complexes comme “Mon,Tue --01..04 12:00:00” - voir systemd.time
  • Persistent va forcer l’exécution du script si la dernière exécution a été manquée suite à un reboot de serveur ou autre événement.
  • Install va créer la dépendance pour que votre “timer” soit bien exécuté et pris en compte par systemd.

Activation et démarrage du timer

Ensuite, pour qu’il soit actif, il faut prévenir systemd

sudo systemctl enable borg-backup.timer
sudo systemctl start borg-backup.timer

Vous pouvez vérifier quand votre prochaine sauvegarde se déclenchera à l’aide des minuteries

systemctl list-timers 

Sauvegarde locale (exemple)

Nous allons ici sauvegarder un dossier local : /home/jdoe dans un autre dossier local : /mnt/sauvegarde/. Il est possible que ce dossier local soit une clef USB, un montage SshFS, NFS…

Initialiser un dépôt vide

# borg init /mnt/sauvegarde/borg_repo

Le système vous demande une phrase de passe :

Enter new passphrase:
Enter same passphrase again:
Do you want your passphrase to be displayed for verification? [yN]:

Cette phrase de passe sert à déverrouiller la clef chiffrant/déchiffrant (clef symétrique) les sauvegardes du dépôt.

Sauvegarder une première archive dans le dépôt

Nous allons ensuite sauvegarder une première archive dans ce dépôt (les options –stats et –info nous permettent de savoir en détail ce qui s’est passé), la phrase de passe choisie précédemment va vous être demandée.

# borg create --info --stats /mnt/sauvegarde/borg_repo::lundi /home/jdoe/
Enter passphrase for key /mnt/sauvegarde/borg_repo:
------------------------------------------------------------------------------
Archive name: lundi
Archive fingerprint: 4cc91816b246b817970f76655eec9b692a58e929bb92d05542998a407bd87b4a
Time (start): Fri, 2016-05-20 18:22:14
Time (end): Fri, 2016-05-20 18:22:25
Duration: 10.83 seconds
Number of files: 100
------------------------------------------------------------------------------
Original size Compressed size Deduplicated size
This archive: 269.18 MB 269.19 MB 253.34 MB
All archives: 269.18 MB 269.19 MB 253.34 MB
 
Unique chunks Total chunks
Chunk index: 173 182
------------------------------------------------------------------------------

Le dossier sauvegardé contient 100 photos, la différence entre Compressed size et Deduplicated size laisse à supposer qu’il y ait probablement plusieurs fichiers identiques dans mon dossier, et que Borg les a dédupliqués.

Compression
Par défaut, aucune compression n’est activée, l’option **–compression ** de la commande **borg create** permet de sélectionner un algorithme de compression parmi les suivants :

_ Force de la compression Vitesse de compression
lz4 faible rapide
zlib,N intermédiaire intermédiaire
lzma,N forte lente

N est la force de la compression entre 0 et 9 (9 est le plus efficace, mais le plus lent). Il n’y a pas de degré de compression idéal, cela dépend des situations et demande quelques essais et ajustements (attention toutefois, changer de compression obligera à retransférer tous les fichiers, modifiés ou non).
Si vous choisissez de compresser, gardez un œil sur d’éventuels ralentissements prolongés de la machine sauvegardée (notamment pour un poste de travail, qui est sauvegardé en même temps qu’il est utilisé), ils pourraient signifier une compression trop forte. Par exemple, sur un de mes serveurs, les sauvegardes sont envoyées via d’une connexion ADSL (lente), et le processeur de la machine n’est occupé à aucune autre tâche au moment d’effectuer les sauvegardes (la nuit) : j’utilise donc la compression la plus forte : lzma,9.

Sauvegarder une seconde archive dans le dépôt

Si nous recréons une nouvelle archive immédiatement (aucun changement sur les fichiers sauvegardés), nous pouvons constater que celle-ci s’opère instantanément (0.11s) avec un surcoût en stockage quasiment nul :

# borg create --info --stats /mnt/sauvegarde/borg_repo::mardi /home/jdoe/
Enter passphrase for key /mnt/sauvegarde/borg_repo:
------------------------------------------------------------------------------
Archive name: mardi
Archive fingerprint: 54ca4a2d9993680b1abe25c1068eff4f712db966f4307d5027bdc5123f8bbde3
Time (start): Fri, 2016-05-20 18:24:46
Time (end): Fri, 2016-05-20 18:24:46
Duration: 0.11 seconds
Number of files: 100
------------------------------------------------------------------------------
Original size Compressed size Deduplicated size
This archive: 269.18 MB 269.19 MB 17.59 kB
All archives: 538.35 MB 538.37 MB 253.35 MB
 
Unique chunks Total chunks
Chunk index: 175 364

Modifions ensuite quelques fichiers (j’ai ajouté 10 photos et en ai supprimé 2), puis refaisons une sauvegarde :

# borg create --info --stats /mnt/sauvegarde/borg_repo::mercredi /home/jdoe/
Enter passphrase for key /mnt/sauvegarde/borg_repo:
------------------------------------------------------------------------------
Archive name: mercredi
Archive fingerprint: 48a57e48f5cf79d554edf699e59d39b295533599ffb7fb90ce0712d06fdaa08c
Time (start): Fri, 2016-05-20 18:29:37
Time (end): Fri, 2016-05-20 18:29:37
Duration: 0.32 seconds
Number of files: 108
------------------------------------------------------------------------------
Original size Compressed size Deduplicated size
This archive: 274.13 MB 274.13 MB 7.90 MB
All archives: 812.48 MB 812.50 MB 261.26 MB
 
Unique chunks Total chunks
Chunk index: 190 555
------------------------------------------------------------------------------

Seuls les 7.90 MB de données nouvelles ont été copiés ; cela reste très rapide.

Sauvegarde distante (exemple)

Il est souvent judicieux lorsque la connectivité le permet de déporter ses sauvegardes sur un autre lieu, qui n’est pas soumis aux mêmes aléas (incendie, vol…).
Borg offre de sauvegarder sur n’importe quel volume monté, local ou distant (SSHFS, NFS, samba…).
Une fois le système de fichiers distant monté, la procédure est strictement la même que pour une sauvegarde locale.

Borg sait manipuler « nativement » une connexion SSH :
notre machine à sauvegarder « pousse » ses sauvegardes, via une connexion SSH, sur une autre machine sur laquelle Borg est également installé.
Cette méthode est plus performante. Les commandes borg à utiliser sont similaires.

Il est à noter que les sauvegardes étant chiffrables, il n’y a pas besoin d’avoir une confiance infinie dans le serveur accueillant les sauvegardes puisqu’il ne peut les lire (la passphrase qui déverrouille la sauvegarde ne quitte jamais le client).

Pour cet exemple :

  • babasse est la machine à sauvegarder, le client ;
  • nas est la machine accueillant les sauvegardes, le serveur.

Préparation du client (babasse)

S’il n’y a pas encore de clef SSH associée à l’utilisateur root, il faut en générer une :

root@babasse # ssh-keygen
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):
Enter passphrase (empty for no passphrase):
Enter same passphrase again:
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
52:fa:b0:99:0e:0e:54:e2:2b:44:af:e9:cf:e1:79:16 root@nas

Vous pouvez accepter l’emplacement de stockage de la clef par défaut, et laisser une phrase de passe vide (sinon il sera compliqué d’automatiser les sauvegardes).

Préparation du serveur (nas)

Commencer par installer Borg (Installation sur Debian Stretch avec les dépôts “backports”) et openssh-server si ça n’est pas déjà le cas.
Il est préférable de créer un utilisateur dédié aux sauvegardes :

root@nas # useradd borg --create-home --home-dir /var/lib/borg-backups/

Vous pouvez changer /var/lib/borg-backups pour n’importe quel emplacement où vous êtes susceptible d’avoir suffisamment d’espace disque.

Cet utilisateur n’a pas de mot de passe, nous nous y connecterons uniquement avec une clef SSH ; autorisons d’ailleurs la clef précédemment créée :

root@nas # mkdir /var/lib/borg-backups/.ssh
root@nas # cat >> /var/lib/borg-backups/.ssh/authorized_keys

Copier/coller le contenu du fichier du fichier de clef publique (située sur dans /root/.ssh/id_rsa.pub) dans ce terminal, et presser [Ctrl]+[D] pour valider.

Le fichier /var/lib/borg-backups/.ssh/authorized_keys devrait ressembler à quelque chose comme ça :

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD0BJAd6IDkJxw2etlizm8SxL+6XQVwln02Pw7uadlQMSp/xVToC+2mb7KIMVZIVySPUG+ceD4ZqXlPInh+BnqDDWHCjpKYMdHEx6T+Fx61gjHVLL3P6+CVVIQKbi1PmzfUZ+PSvtGxd/fRWRO5qxXCeT4cguL30ee6WAwKx2L9aaM+D5FsliXcY0AL91lqXMkG7XjyexDYE5kg6rx0sKly5YJmGe6K5r+OPF4cw44y67/aktJGm9bltpl7RIvOQB3vko5VWA+h7801kEPIaahIrir2FuCCLQF2Tzu+4Uxz0NsghK+ilqv+BwOL39cNNbYOEXYpZM7dN3or9R46Y5Yp root@babasse

Sauvegardons !

La sauvegarde est très similaire à une sauvegarde locale, sauf qu’on utilise un nom de dépôt distant :

root@babasse # borg init borg@nas.example.com:/var/lib/borg-backups/babasse
root@babasse # borg create borg@nas.example.com:/var/lib/borg-backups/babasse::2016-05-23 /home/jdoe

De même, le montage d’une archive se fait de manière transparente à travers le réseau :

root@babasse # borg mount borg@nas.example.com:/var/lib/borg-backups/babasse::2016-05-23

Références

Annexe

Dépôts URLs

Système de fichiers local (ou système de fichiers réseau monté localement) :

/path/to/repo # chemin du système de fichiers vers le répertoire repo, chemin absolu
path/to/repo  # chemin du système de fichiers vers le répertoire repo, chemin relatif

Aussi, des choses comme ~/path/to/repo ou ~other/path/to/repo fonctionne (ceci est développé par votre shell).

Dépôts distants accessibles via ssh user@host :

user@host:/path/to/repo           # repo distant, chemin absolu
ssh://user@host:port/path/to/repo # même, syntaxe alternative, port peut être donné

Remote repositories with relative paths can be given using this syntax:

user@host:path/to/repo            # chemin relatif au répertoire courant
user@host:~/path/to/repo          # chemin relatif au répertoire personnel de l'utilisateur
user@host:~other/path/to/repo     # chemin relatif au répertoire d'origine d'autres utilisateurs

Remarque : donner user@host:/./path/to/repo ou user@host:/~/path/to/repo ou user@host:/~other/path/to/repo est également supporté, mais pas obligatoire ici.

Dépôts distants avec chemins relatifs, syntaxe alternative avec port :

ssh://user@host:port/./path/to/repo      # chemin relatif au répertoire courant
ssh://user@host:port/~/path/to/repo      # chemin relatif au répertoire personnel de l'utilisateur
ssh://user@host:port/~other/path/to/repo # chemin relatif au répertoire d'origine d'autres utilisateurs

Si vous avez fréquemment besoin de la même URL de repo, c’est une bonne idée de définir la variable d’environnement BORG_REPO pour définir une valeur par défaut pour l’URL de repo :

export BORG_REPO='ssh://user@host:port/path/to/repo'

Ensuite, laissez simplement l’URL du repo si seulement une URL de repo est nécessaire et que vous voulez utiliser la valeur par défaut - elle sera lue à partir de BORG_REPO alors.
Utiliser : : syntaxe pour donner l’URL du repo lorsque la syntaxe nécessite de donner un argument positionnel pour le repo (par exemple borg mount : : /mnt).

Scripts bash

borg-script-simple

#!/bin/sh
#
# Script de sauvegarde.
#
# Envoie les sauvegardes sur un serveur distant, via le programme borg.
# Les sauvegardes sont chiffrées
#
# http://borgbackup.readthedocs.or/g
#
# Est lancé quotidiennement.

set -e

ts_log()
{
    echo `date '+%Y-%m-%d %H:%m:%S'` $1 >> ${LOG_PATH}
}

# Trap on non-zero exit
trap '[ "$?" -eq 0 ] || cleanup' EXIT

BACKUP_DATE=`date +%Y-%m-%d`
LOG_PATH=/var/log/borg-backup.log

BORG=/usr/bin/borg
# Fichier dans lequel est stocké la passphrase du dépôt borg 
# (attention aux permissions)
export BORG_PASSPHRASE="`cat ~root/.borg/passphrase`"
BORG_REPOSITORY=borg@nas.example.com:/var/lib/borg-backups/
BORG_ARCHIVE=${BORG_REPOSITORY}::${BACKUP_DATE}

ts_log "Starting new backup ${BACKUP_DATE}..."

ts_log "Pushing archive ${BORG_ARCHIVE}"
$BORG create \
     -v --stats --compression lzma,9 \
     $BORG_ARCHIVE \
     /etc /var/mail /home \
     >> ${LOG_PATH} 2>&1

ts_log "Rotating old backups."
$BORG prune -v $BORG_REPOSITORY \
      --keep-daily=7 \
      --keep-weekly=4 \
      --keep-monthly=6 \
      >> ${LOG_PATH} 2>&1

borg-script-yunohost

#!/bin/sh
#
# Script de sauvegarde.
#
# Envoie les sauvegardes sur un serveur distant, via le programme borg.
# Les sauvegardes sont chiffrées
#
# http://borgbackup.readthedocs.org/
#
# Sauvegarde :
# - mails
# - config
# - /home
#
# Est lancé quotidiennement.

set -e

cleanup()
{
    echo "Something bad happened during backup, check ${LOG_PATH}"
    exit $1
}

ts_log()
{
    echo `date '+%Y-%m-%d %H:%m:%S'` $1 >> ${LOG_PATH}
}

# Trap on non-zero exit
trap '[ "$?" -eq 0 ] || cleanup' EXIT

BACKUP_DATE=`date +%Y-%m-%d`
LOG_PATH=/var/log/borg-backup.log

BORG=/usr/bin/borg
export BORG_RSH="ssh -i /root/.ssh/id_rsa"
# Fichier dans lequel est stocké la passphrase du dépôt borg 
# (attention aux permissions)
export BORG_PASSPHRASE="`cat ~root/.borg/passphrase`"
BORG_REPOSITORY=borg@nas.example.com:/var/lib/borg-backups/
BORG_ARCHIVE=${BORG_REPOSITORY}::${BACKUP_DATE}

# Fichier dans lequel est stocké le mot de passe root mysql 
# (attention aux permissions)
MYSQL_ROOT_PASS=`cat /etc/yunohost/mysql`
MYSQL_TMP_DUMP_FILE=/root/mysql_all_db.sql
LDAP_TMP_DUMP_FILE=/root/ldap_all_db.ldif


ts_log "Starting new backup ${BACKUP_DATE}..."

ts_log 'Dumping MySQL db...'
mysqldump --all-databases --events -p$MYSQL_ROOT_PASS > $MYSQL_TMP_DUMP_FILE

ts_log 'Dumping LDAP...'
slapcat -l $LDAP_TMP_DUMP_FILE

ts_log "Pushing archive ${BORG_ARCHIVE}"
$BORG create \
     -v --stats --compression lzma,9 \
     $BORG_ARCHIVE \
     /etc /var/mail /home $MYSQL_TMP_DUMP_FILE $LDAP_TMP_DUMP_FILE \
     >> ${LOG_PATH} 2>&1

ts_log "Rotating old backups."
$BORG prune -v $BORG_REPOSITORY \
      --keep-daily=7 \
      --keep-weekly=4 \
      --keep-monthly=6 \
      >> ${LOG_PATH} 2>&1

ts_log 'Cleaning up...'
rm $MYSQL_TMP_DUMP_FILE
rm $LDAP_TMP_DUMP_FILE

Sauvegarde sur ordinateur distant avec SSH

#!/bin/bash
#
## BEGIN CONFIG ##
HOST=$(uname -n)
OPENKM_DB="okmdb"
OPENKM_HOME="/home/openkm"
TOMCAT_HOME="$OPENKM_HOME/tomcat"
DATABASE_EXP="$OPENKM_HOME/db"
BACKUP_HOST="backup@bk-server.com"
BACKUP_DIR="/mnt/backup/$HOST"
BACKUP_REPO="${BACKUP_HOST}:${BACKUP_DIR}"
## END CONFIG ##

# Check root user 
if [ $(id -u) != 0 ]; then echo "You should run this script as root"; exit; fi

echo "Backup destination ${BACKUP_REPO}"
if (ssh ${BACKUP_HOST} "[ ! -d ${BACKUP_DIR} ]"); then
  echo "Initialize backup repository: ${BACKUP_DIR}"
  ssh ${BACKUP_HOST} "mkdir -p ${BACKUP_DIR}"
  borg init -e none ${BACKUP_REPO}
fi

# Database
echo "Backup MySQL databases"
mkdir -p ${DATABASE_EXP}
echo "- Backuping $OPENKM_DB..."
mysqldump --single-transaction --add-drop-table --quick ${OPENKM_DB} > ${DATABASE_EXP}/mysql_$OPENKM_DB.sql

borg create -v --stats ${BACKUP_REPO}::'{now:%Y-%m-%d_%H:%M}' ${OPENKM_HOME}
borg prune -v ${BACKUP_REPO} --list --keep-daily=7 --keep-weekly=4 --keep-monthly=6

Ceci est une version améliorée de SSH

#!/bin/bash

# Configuration
DATABASE_EXP="/home/openkm/db"
BACKUP_HOST="backup@bk-server.com"
BACKUP_DIR="/mnt/backup/$HOST"
BACKUP_REPO="${BACKUP_HOST}:${BACKUP_DIR}"

echo "### BEGIN: $(date +"%x %X") ###"
echo "Backup destination ${BACKUP_REPO}"
TBEGIN=$(date +"%s")

# Check if the repository is already initialized
borg list ${BACKUP_REPO} > /dev/null
RESULT=$?; if [[ ${RESULT} != 0 ]]; then
  echo "Initializing backup repository..."
  borg init -e none ${BACKUP_REPO}
fi

# Database
echo "Backup MySQL databases"
mkdir -p ${DATABASE_EXP}
MYSQL_DBS=$(mysqlshow | awk '(NR > 2) && (/[a-zA-Z0-9]+[ ]+[|]/) { print $2 }');
for DB in $MYSQL_DBS; do
  if [[ $DB != "mysql" && $DB != "test" && $DB != "information_schema" && $DB != "performance_schema" ]]; then
    echo "- Backuping $DB..."
    mysqldump --single-transaction --add-drop-table --quick ${DB} > ${DATABASE_EXP}/mysql_$DB.sql
  fi
done

borg create -v --stats ${BACKUP_REPO}::'{now:%Y-%m-%d_%H:%M}' /opt /var /etc /root /home
RESULT=$?; if [[ ${RESULT} != 0 ]]; then
  echo "****************************************************"
  echo " Backup error => exit code: ${RESULT}"
  echo "****************************************************"
fi

# Prune old backups
echo "Prune old backups"
borg prune -v --list --keep-within=30d ${BACKUP_REPO}
RESULT=$?; if [[ ${RESULT} != 0 ]]; then
  echo "****************************************************"
  echo " Backup error => exit code: ${RESULT}"
  echo "****************************************************"
fi

TEND=$(date +"%s")
TDIFF=$(($TEND-$TBEGIN))
echo "### END: $(date +"%x %X") - $(($TDIFF / 60)) mins and $(($TDIFF % 60)) secs ###"

Sauvegarde sur le réseau mappé

#!/bin/bash
#
## BEGIN CONFIG ##
HOST=$(uname -n)
OPENKM_DB="okmdb"
OPENKM_HOME="/home/openkm"
TOMCAT_HOME="$OPENKM_HOME/tomcat"
DATABASE_EXP="$OPENKM_HOME/db"
BACKUP_DIR="/mnt/backup"
BACKUP_REPO="${BACKUP_DIR}/${HOST}"
## END CONFIG ##

# Check root user
if [ $(id -u) != 0 ]; then echo "You should run this script as root"; exit; fi

# Mount disk
if mount | grep "$BACKUP_DIR type" > /dev/null; then
  echo "$BACKUP_DIR already mounted";
else
  mount "$BACKUP_DIR";

  if mount | grep "$BACKUP_DIR type" > /dev/null; then
    echo "$BACKUP_DIR mounted";
  else
    echo "$BACKUP_DIR error mounting";
    exit -1;
  fi
fi

# Initialize repository
echo "Backup destination ${BACKUP_REPO}"
if ! ls -l ${BACKUP_DIR} | grep '^d' | grep "${HOST}" > /dev/null; then
  echo "Initialize backup repository: ${BACKUP_REPO}"
  mkdir ${BACKUP_REPO}
  borg init -e none ${BACKUP_REPO}
fi

# Database
echo "Backup MySQL databases"
mkdir -p ${DATABASE_EXP}
echo "- Backuping $OPENKM_DB..."
mysqldump --single-transaction --add-drop-table --quick ${OPENKM_DB} > ${DATABASE_EXP}/mysql_$OPENKM_DB.sql

# Data backup
echo "File system backup: ${BACKUP_REPO}"
borg create -v --stats ${BACKUP_REPO}::'{now:%Y-%m-%d_%H:%M}' ${OPENKM_HOME}
borg prune -v ${BACKUP_REPO} --list --keep-daily=7 --keep-weekly=4 --keep-monthly=6

# Umount disk
sync
umount "$BACKUP_DIR"
echo "$BACKUP_DIR umounted";

Configurer crontab, ajouter une tâche cron

$ sudo mkdir /root/logs
$ sudo crontab -e

Ajouter ces lignes en fonction de votre configuration personnelle :

MAILTO=nomail@openkm.com
PATH=/usr/sbin:/usr/bin:/sbin:/bin:/usr/local/bin
@daily /root/backup.sh 2>&1 | tee /root/logs/backup.$(date +\%Y.\%m.\%d_\%H.\%M.\%S).log

Quelques commandes borg

création d’un point de montage temporaire pour visualiser les “archives de sauvegarde” (backups)

mkdir -p /mnt/temp  
export BORG_PASSPHRASE="`cat ~root/.borg/passphrase`"  # Pour ne pas avoir à saisir la phrase mot de passe 
export BORG_RSH='ssh -i /root/.ssh/yanspm_ed25519'     # Si la clé SSH n'est pas celle par défaut **id_rsa**
borg list ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanspm.com  # Liste des archives

Liste des archives

2019-01-11                           Fri, 2019-01-11 16:58:11 [91fa5ecb886d72587395983aa928d968421047618fa9038e248a1c86e8ba4ab2]
  • xoyize.xyz : serveur qui archive les sauvegardes
  • 55029 : Port d’entrée SSH sur le serveur
  • /srv/ssd-two/borg-backups/yanspm.com : Le dépôt borgbackup

Le montage d’une archive (backup) se fait de manière transparente à travers le réseau :

borg mount ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanspm.com::2019-01-11 /mnt/temp

Vue

ls /mnt/temp/home/yanspm/
archives   dead.letter	gitea-repositories  shaarli  stubby
compil.sh  getdns	netdata		    Shaarli  stubby.yml

Démontage

borg umount /mnt/temp

Purger les anciennes “archives de sauvegarde” (backups)

Exemple: On va garder 1 backup par jour sur les 7 derniers jours, et 1 backup par semaine sur les 4 dernières semaines et 1 backup par mois sur les 6 derniers mois.

borg prune -v --list --stats --keep-daily=7 --keep-weekly=4 --keep-monthly=6 /repo

Si vous avez préfixé vos archives, vous pouvez purger sélectivement avec –prefix=nommachine
Vous pouvez supprimer un backup précis. Par exemple:

borg delete /repo::2017-12-11T12:25:38

Problème de verrouillage, le dossier archive n’est pas accessible, pour le déverrouiller

borg break-lock ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanspm.com

Compte rendu au PREMIER passage (sauvegarde debian yanspm.com → xoyize.xyz)

borg create -v --stats --compression lzma,9 $BORG_ARCHIVE /bin /boot /etc /home /lib /lib64 /opt /root /sbin /srv /usr /var vmlinuz vmlinuz.old

Creating archive at "ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanspm.com::2019-01-12-07h-58"
------------------------------------------------------------------------------
Archive name: 2019-01-12-07h-58
Archive fingerprint: 53b19ccc50ba819c46809681a98572f5262c8e6cd9269af352180b0003558b71
Time (start): Sat, 2019-01-12 08:05:07
Time (end):   Sat, 2019-01-12 09:25:56
Duration: 1 hours 20 minutes 49.20 seconds
Number of files: 73818
Utilization of max. archive size: 0%
------------------------------------------------------------------------------
                       Original size      Compressed size    Deduplicated size
This archive:                3.21 GB              1.10 GB            948.95 MB
All archives:                3.36 GB              1.19 GB              1.03 GB

                       Unique chunks         Total chunks
Chunk index:                   67629                78964
------------------------------------------------------------------------------

Compte rendu au SECOND passage (sauvegarde debian yanspm.com → xoyize.xyz)

Creating archive at "ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanspm.com::2019-01-12-14h-25"
------------------------------------------------------------------------------
Archive name: 2019-01-12-14h-25
Archive fingerprint: 704e11a803614adc8ac53b61e9b4ad0ea87d35c08f3ce190d7ce21fe81d6d342
Time (start): Sat, 2019-01-12 14:25:16
Time (end):   Sat, 2019-01-12 14:25:45
Duration: 28.22 seconds
Number of files: 73863
Utilization of max. archive size: 0%
------------------------------------------------------------------------------
                       Original size      Compressed size    Deduplicated size
This archive:                3.21 GB              1.10 GB              3.70 MB
All archives:                6.57 GB              2.28 GB              1.04 GB

                       Unique chunks         Total chunks
Chunk index:                   67743               152918
------------------------------------------------------------------------------

Machine distante à sauvegarder “yanfi” , Machine qui stocke les sauvegardes “xoyize.xyz”

  • Machine à sauvegarder : yanfi.net
  • Machine qui stocke les sauvegardes : xoyize.xyz

Préparation de la machine distante à sauvegarder “yanfi”

On se connecte sur la machine et on passe en mode su

sudo -s

Installation BorgBackup
Installation en utilisant les dépôts “backports”

apt edit-sources # pour ajouter la ligne pour les dépôts "backports"
deb http://deb.debian.org/debian stretch-backports main contrib non-free

Votre fichier « /etc/apt/sources.list » a changé, veuillez lancer « apt-get update »

apt update

Installer borgbackup

apt -V -t=stretch-backports install borgbackup

Créer un jeu de clé sur machine à sauvegarder
Créer un utilisateur borg dédié aux sauvegardes par BorgBackup :

useradd borg

Générer un jeu de clé sur /root/.ssh

mkdir -p /root/.ssh
ssh-keygen -t ed25519 -o -a 100 -f /root/.ssh/yanfi_ed25519

Le jeu de clé

ls /root/.ssh
    yanfi_ed25519  yanfi_ed25519.pub

Autoriser utilisateur borg à exécuter /usr/bin/borg uniquement

echo "borg ALL=NOPASSWD: /usr/bin/borg" >> /etc/sudoers

Préparation de la machine qui stocke les sauvegardes “xoyize.xyz”

Commencer par installer Borg (Installation sur Debian Stretch avec les dépôts “backports”) et openssh-server si ça n’est pas déjà le cas.

Il est préférable de créer un utilisateur dédié aux sauvegardes :

root@shuttle # useradd borg --create-home --home-dir /var/lib/borg-backups/

Vous pouvez changer /var/lib/borg-backups pour n’importe quel emplacement où vous êtes susceptible d’avoir suffisamment d’espace disque.

Cet utilisateur n’a pas de mot de passe, nous nous y connecterons uniquement avec une clef SSH ; autorisons d’ailleurs la clef précédemment créée :

root@shuttle # mkdir /var/lib/borg-backups/.ssh
root@shuttle # cat >> /var/lib/borg-backups/.ssh/authorized_keys

Copier/coller le contenu du fichier du fichier de clef publique (située sur dans /root/.ssh/id_rsa.pub) dans ce terminal, et presser [Ctrl]+[D] pour valider.

Le fichier /var/lib/borg-backups/.ssh/authorized_keys devrait ressembler à quelque chose comme ça :

ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD0BJAd6IDkJxw2etlizm8SxL+6XQVwln02Pw7uadlQMSp/xVToC+2mb7KIMVZIVySPUG+ceD4ZqXlPInh+BnqDDWHCjpKYMdHEx6T+Fx61gjHVLL3P6+CVVIQKbi1PmzfUZ+PSvtGxd/fRWRO5qxXCeT4cguL30ee6WAwKx2L9aaM+D5FsliXcY0AL91lqXMkG7XjyexDYE5kg6rx0sKly5YJmGe6K5r+OPF4cw44y67/aktJGm9bltpl7RIvOQB3vko5VWA+h7801kEPIaahIrir2FuCCLQF2Tzu+4Uxz0NsghK+ilqv+BwOL39cNNbYOEXYpZM7dN3or9R46Y5Yp root@yanspm

Ajout clé publique sur la machine qui stocke les sauvegardes “xoyize.xyz”

Se connecter sur la machine xoyize.xyz en ssh et ajouter de la clé publique

sudo -s
mkdir -p /srv/ssd-two/borg-backups/.ssh
cat >> /srv/ssd-two/borg-backups/.ssh/authorized_keys

Copier/coller le contenu du fichier du fichier de clef publique (fichier /root/.ssh/yanfi_ed25519.pub de la machine à sauvegarder ) dans ce terminal, et presser [Ctrl]+[D] pour valider.

Le dossier de base pour les sauvegardes sur le serveur xoyize.xyz : /srv/ssd-two/borg-backups/

Création dépôt et lancement des sauvegardes depuis la machine distante à sauvegarder “yanfi”

machine cliente yanfi.net
On se connecte sur la machine et on passe en mode su

sudo -s

Création du dépôt distant (A FAIRE UNE SEULE FOIS)

export BORG_RSH='ssh -i /root/.ssh/yanfi_ed25519' # ce n'est pas la clé par défaut id_rsa
borg init --encryption=repokey-blake2 ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanfi.net
The authenticity of host '[xoyize.xyz]:55029 ([2a01:e34:eebf:df3::1]:55029)' can't be established.
ECDSA key fingerprint is SHA256:RQJzuV1z2w3o8NHlbQ3110/822ozKiosobS6ohpIrTs.
Are you sure you want to continue connecting (yes/no)? yes
Remote: Warning: Permanently added '[xoyize.xyz]:55029,[2a01:e34:eebf:df3::1]:55029' (ECDSA) to the list of known hosts.
Enter new passphrase: 
Enter same passphrase again: 
Do you want your passphrase to be displayed for verification? [yN]: 

By default repositories initialized with this version will produce security
errors if written to with an older version (up to and including Borg 1.0.8).

If you want to use these older versions, you can disable the check by running:
borg upgrade --disable-tam ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanfi

See https://borgbackup.readthedocs.io/en/stable/changes.html#pre-1-0-9-manifest-spoofing-vulnerability for details about the security implications.

IMPORTANT: you will need both KEY AND PASSPHRASE to access this repo!
Use "borg key export" to export the key, optionally in printable format.
Write down the passphrase. Store both at safe place(s).

Sauvegarder la “passphrase” dans un fichier pour une procédure automatique

mkdir -p /root/.borg
nano /root/.borg/passphrase

Générer une sauvegarde d’un dossier local vers le dépôt distant

borg create ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanfi.net::2019-01-11 /home/yanfi
Enter passphrase for key ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanfi.net: 

Automatiser la procédure de sauvegarde pour le client yanfi.net

script de sauvegarde (notez l’usage de borg prune pour supprimer les archives trop anciennes)

nano /etc/cron.daily/borg-backup

Pour lancement à une heure précise

nano /root/.borg/borg-backup # après création on exécute crontab -e
#!/bin/sh
#
# Script de sauvegarde.
#
# Envoie les sauvegardes sur un serveur distant, via le programme Borg.
# Les sauvegardes sont chiffrées
#
 
set -e
 
BACKUP_DATE=`date +%Y-%m-%d-%Hh%M`
LOG_PATH=/var/log/borg-backup.log
 
export BORG_PASSPHRASE="`cat ~root/.borg/passphrase`"
export BORG_RSH='ssh -i /root/.ssh/yanfi_ed25519'
BORG_REPOSITORY=ssh://borg@xoyize.xyz:55029/srv/ssd-two/borg-backups/yanfi.net
BORG_ARCHIVE=${BORG_REPOSITORY}::${BACKUP_DATE}
 
borg create \
-v --stats --compression lzma,9 \
$BORG_ARCHIVE \
/bin /boot /etc /home /lib /lib64 /opt /root /sbin /srv /usr /var \
>> ${LOG_PATH} 2>&1
 
# Nettoyage des anciens backups
# On conserve
# - une archive par jour les 7 derniers jours,
# - une archive par semaine pour les 4 dernières semaines,
# - une archive par mois pour les 6 derniers mois.
 
borg prune \
-v --list --stats --keep-daily=7 --keep-weekly=4 --keep-monthly=6 \
$BORG_REPOSITORY \
>> ${LOG_PATH} 2>&1

Le rendre exécutable

chmod +x /root/.borg/borg-backup

Programmer la tâche à 2h30 du matin

crontab -e
# Sauvegarde sur distant avec BorgBackup
30 02 * * * /root/.borg/borg-backup > /dev/null

Machine à sauvegarder “Dell Latitude e6230” , Machine qui stocke les sauvegardes “xoyize.xyz” (srvxo/192.168.0.45)

  • Machine à sauvegarder : Portable Dell Latitude e6230
  • Machine qui stocke les sauvegardes : xoyize.xyz (srvxo/192.168.0.45)

Préparation de la machine à sauvegarder “Portable Dell Latitude e6230”

On se connecte sur le portable et on passe en mode su

sudo -s

Installer borgbackup

pacman -S borgbackup

Créer un jeu de clé sur "Portable Dell Latitude e6230"
Créer un utilisateur “borg” dédié aux sauvegardes par BorgBackup :

useradd borg

Générer un jeu de clé sur /root/.ssh

mkdir -p /root/.ssh
ssh-keygen -t ed25519 -o -a 100 -f /root/.ssh/dell_latitude_e6230

Le jeu de clé

ls /root/.ssh
    dell_latitude_e6230  dell_latitude_e6230.pub

Autoriser utilisateur borg à exécuter /usr/bin/borg uniquement

echo "borg ALL=NOPASSWD: /usr/bin/borg" >> /etc/sudoers

Préparation de la machine qui stocke les sauvegardes “xoyize.xyz”

Passer au paragraphe suivant si le serveur “xoyize” est initialisé

Commencer par installer Borg (Installation sur Debian Stretch avec les dépôts “backports”) et openssh-server si ça n’est pas déjà le cas.

Il est préférable de créer un utilisateur dédié aux sauvegardes :

root@shuttle # useradd borg --create-home --home-dir /srv/data/borg-backups/

Vous pouvez changer /srv/data/borg-backups/ pour n’importe quel emplacement où vous êtes susceptible d’avoir suffisamment d’espace disque.

Etape 2
Cet utilisateur n’a pas de mot de passe, nous nous y connecterons uniquement avec une clef SSH ; autorisons d’ailleurs la clef précédemment créée :

root@shuttle # mkdir -p /srv/data/borg-backups/.ssh
root@shuttle # cat >> /srv/data/borg-backups/.ssh/authorized_keys

Copier/coller le contenu du fichier de clef publique (situé sur dans /root/.ssh/<Nom_Clef>.pub de la machine à sauvegarder) dans ce terminal, et presser [Ctrl]+[D] pour valider.

La ligne ajoutée au fichier /srv/data/borg-backups/.ssh/authorized_keys devrait ressembler à quelque chose comme ça :

ssh-ed25519 AAAAC3NzaC1lZDI1NTE5AAAAIkJxw2etlizm8SxL+6XQVwln02Pw7uadlQMSp root@MachineAsauvegarder

Ajout clé publique sur la machine qui stocke les sauvegardes “xoyize.xyz”

Se connecter sur la machine xoyize.xyz en ssh et ajouter de la clé publique

sudo -s
mkdir -p /srv/data/borg-backups/.ssh
cat >> /srv/data/borg-backups/.ssh/authorized_keys

Copier/coller le contenu du fichier du fichier de clef publique (fichier /root/.ssh/dell_latitude_e6230.pub de la machine à sauvegarder ) dans ce terminal, et presser [Ctrl]+[D] pour valider.

Le dossier de base pour les sauvegardes sur le serveur xoyize.xyz : /srv/data/borg-backups/

Création dépôt et lancement des sauvegardes depuis la machine à sauvegarder “Dell Latitude e6230”

machine cliente "Dell Latitude e6230"
On se connecte sur la machine et on passe en mode su

sudo -s

Créer et sauvegarder une “passphrase”
La “passphrase” est une suite de 6 mots séparés par un espace

mkdir -p /root/.borg
nano /root/.borg/passphrase

Création du dépôt distant (A FAIRE UNE SEULE FOIS)

export BORG_RSH='ssh -i /root/.ssh/dell_latitude_e6230'
borg init --encryption=repokey-blake2 ssh://borg@xoyize.xyz:55035/srv/data/borg-backups/Dell_Latitude_e6230 
The authenticity of host '[xoyize.xyz]:55035 ([2a01:e34:eebf:df3::1]:55035)' can't be established.
ECDSA key fingerprint is SHA256:+GzOWS1At1azSUcJk6aiVWnq5oNJKX6/veIxNaxe4u0.
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Remote: Warning: Permanently added '[xoyize.xyz]:55035,[2a01:e34:eebf:df3::1]:55035' (ECDSA) to the list of known hosts.
Enter new passphrase: 
Enter same passphrase again: 
Do you want your passphrase to be displayed for verification? [yN]: 

By default repositories initialized with this version will produce security
errors if written to with an older version (up to and including Borg 1.0.8).

If you want to use these older versions, you can disable the check by running:
borg upgrade --disable-tam ssh://borg@xoyize.xyz:55035/srv/data/borg-backups/Dell_Latitude_e6230

See https://borgbackup.readthedocs.io/en/stable/changes.html#pre-1-0-9-manifest-spoofing-vulnerability for details about the security implications.

IMPORTANT: you will need both KEY AND PASSPHRASE to access this repo!
Use "borg key export" to export the key, optionally in printable format.
Write down the passphrase. Store both at safe place(s).

Générer une sauvegarde d’un dossier local vers le dépôt distant (exemple)

borg create ssh://borg@xoyize.xyz:55035/srv/data/borg-backups/Dell_Latitude_e6230::2019-01-11 /home/yann
Enter passphrase for key ssh://borg@xoyize.xyz:55035/srv/data/borg-backups/yanfi.net: 

Automatiser la procédure de sauvegarde pour le “Portable Dell Latitude e6230”

Création du bash

nano /root/.borg/borg-backup # Pour lancement à une heure précise ,après création on exécute crontab -e
#!/bin/sh
#
# Script de sauvegarde.
#
# Envoie les sauvegardes sur un serveur distant, via le programme Borg.
# Les sauvegardes sont chiffrées
#
 
set -e
 
BACKUP_DATE=`date +%Y-%m-%d-%Hh%M`
LOG_PATH=/var/log/borg-backup.log
 
export BORG_PASSPHRASE="`cat ~root/.borg/passphrase`"
export BORG_RSH='ssh -i /root/.ssh/dell_latitude_e6230'
BORG_REPOSITORY=ssh://borg@xoyize.xyz:55035/srv/data/borg-backups/Dell_Latitude_e6230
BORG_ARCHIVE=${BORG_REPOSITORY}::${BACKUP_DATE}
 
borg create \
-v --stats --compression lzma,9 \
--exclude-caches --progress \
$BORG_ARCHIVE \
/bin /data /etc /images /lib64 /opt /root /sbin /usr \
/boot /home /lib /srv /var
 \
>> ${LOG_PATH} 2>&1
 
# Nettoyage des anciens backups
# On conserve
# - une archive par jour les 7 derniers jours,
# - une archive par semaine pour les 4 dernières semaines,
# - une archive par mois pour les 6 derniers mois.
 
borg prune \
-v --list --stats --keep-daily=7 --keep-weekly=4 --keep-monthly=6 \
$BORG_REPOSITORY \
>> ${LOG_PATH} 2>&1

Le rendre exécutable

chmod +x /root/.borg/borg-backup

Programmer la tâche à 2h30 du matin (Utile pour un serveur mais pas pour un portable)

crontab -e
# Sauvegarde sur distant avec BorgBackup
30 02 * * * /root/.borg/borg-backup > /dev/null