Auteur Sujet: Sauvegarde incrémentielle et différentielle d'un serveur ou PC Linux (Lu 12344 fois)

vivien · « **le:** 06 novembre 2021 à 14:01:14 »

Script bash pour faire une sauvegarde incrémentielle et différentielle d'un serveur ou d'un PC via le port SSH et garder plusieurs sauvegardes, en ne stockant que les différences entre deux sauvegardes.

Le principe se base sur des liens physiques proposés par Linux : Cela permet de donner plusieurs noms/chemin d'accès à un même fichier en pointant sur un numéro de fichier. En interne, Linux enregistre les fichiers sur la base d'un numéro (appelé numéro d'index ou inode) et pas sur la base d'un nom. Un fichier peut donc avoir plusieurs noms, et existera tant qu'il est utilisé dans une des sauvegardes. Quand aucune sauvegarde n'utilise l'inode le fichier est supprimé. Contrairement aux liens symboliques, les liens physiques ne peuvent pointer que vers un autre élément du même système de fichiers.

Donc chacune des sauvegardes appariait comme une sauvegarde complète et non une sauvegarde différentielle. Toutefois, sur le disque dur, la place occupée est celle d'une sauvegarde différentielle pour toutes les sauvegardes, sauf la plus ancienne qui prend la place d'une sauvegarde complète. Merci à Bad Max pour le script d'origine que j'ai adapté à mon besoin.

La sauvegarde peut se faire sur un autre serveur / PC, mais je vais vous partager ma technique qui permet de consacrer peu d'argent pour avoir des sauvegardes chiffrées à domicile et même sur un autre site, en déplaçant les disques dur de sauvegarde.

Pour avoir une sauvegarde chiffrée, le plus simple est d'installer un système d'exploitation en mode chiffré : Sur chaque disque dur de sauvegarde, j'ai un Ubuntu (j'ai coché la case pour avoir une installation minimale) avec le disque qui est chiffré (il demande un mot de passe au début de la phase de boot). Pour le PC, c'est mon vieux PC qui sert à cette tâche (Core 2 duo). C'est bien suffisant pour faire de la sauvegarde. Il est également possible d'utiliser un vieux PC portable avec des disques dur externes, connectés en USB.

Le script me sert aussi bien à sauvegarder des serveurs, des PC distants de ma famille, mais aussi mon PC local. Afin d'avoir toujours les données sur deux sites distincts, j'ai deux disques dur de sauvegarde pour le "PC Vivien" : J'emporte mon disque dur quand je vais voir ma famille et je rapporte celui qui était sur place. J'ai donc toujours une sauvegarde locale et une sauvegarde sur un autre site. Pas besoin NAS qui tourne 24h/24 sur un autre site, je me contente de déplacer les disques dur.

Le script peut fonctionner avec des disques dur externes, mais dans mon cas, il est rapide et simple de changer de disque dur sur mon PC : Je me suis donc basé sur des disques internes que je change facilement. Chaque disque dur de sauvegarde a son système d'exploitation, je n'ai pas besoin d'un autre disque.

vivien · « **Réponse #1 le:** 06 novembre 2021 à 14:01:59 »

Tutoriel testé avec Ubuntu version 20.04 LTS, Ubuntu 22.04 LTS et Ubuntu 24.04 LTS

Pré-requis coté serveur / PC à sauvegarder : L'utilisateur SSH du serveur doit avoir accès en lecture aux fichiers à sauvegarder. Un fichier lisible uniquement par "root" ne peut pas être sauvegardé par ce script.

Pré-requis coté PC de sauvegarde : avoir un Linux (avec ou sans interface graphique, peu importe) et pouvoir se connecter en SSH au serveur / PC à sauvegarder.

1/ Coté PC qui fait la sauvegarde

A/ Génération d'une clé publique / privée pour l'authentification par clé SSH

La clé publique n'a pas beaucoup d'importance, car, par définition, elle peut être rendue publique. La clé privée ne doit pas sortir du PC de sauvegarde. Je conseille de chiffrer le disque du PC de sauvegarde afin de limiter les risques.

$ ssh-keygen -t rsa : On génère une clé au format RSA avec la commande ssh-keygen. On doit exécuter cette commande avec l'utilisateur qui sera utilisé pour la sauvegarde (pas de sudo, on ne fera pas fonctionner le script avec les droits root)

ssh-keygen vous demande l'emplacement de la clef. Appuyer entrée pour accepter /home/[utilisateur]/.ssh/id_rsa

ssh-keygen propose de mettre une "passphrase" : Enter passphrase (empty for no passphrase):
Appuyer pour entrer pour de pas rentrer de "passphrase" car elle sera demandée à chaque connexion.

Le répertoire de l’utilisateur contient maintenant un répertoire .ssh dans lequel :

id_rsa.pub contient la clé publique.
id_rsa contient la clé privée qui doit rester sur la machine.

Ligne de commande à exécuter coté PC de sauvegarde sans être root pour récupérer la clé publique : cat ~/.ssh/id_rsa.pub

B/ Uniquement si la machine sauvegardée n'a pas de nom de domaine : modification du fichier /etc/hosts

Faire la sauvegarde avec une IP en dur dans le script n'est pas une bonne solution, car le dossier de sauvegarde va porter comme nom l'IP et en cas de changement d'IP, cela va créer une seconde sauvegarde, comme si c'était une seconde machine à sauvegarder.

Je préconise d'utiliser un nom de domaine et s'il n'y en a pas.
En cas de changement d'IP, je modifierais uniquement le fichier / etc/hosts, sans toucher au script de sauvegarde.

sudo nano /etc/hosts

On rajoute une nouvelle ligne avec en premier l'IP du serveur à sauvegarder puis après un ou plusieurs espaces / tabulations, le nom de la machine à sauvegarder.

Exemple : Cette machine se nomme "Sauvegarde2", la machine à sauvegarder est "vivien1" et l'IP de vivien1 est "192.168.0.20".

C/ Facultatif : Optimisation pour limiter le SWAP et permettre la montée du débit de la connexion TCP (tout sera sur une connexion TCP)

Sans cette configuration, lors d'une grosse sauvegarde, même si le PC qui fait la sauvegarde à de la RAM, Linux a tendance à déplacer la mémoire peu utilisée sur disque, ce qui est appelé swap.
La ligne vm.swappiness = 1 dans le fichier ci-dessous permet de limiter le phénomène de swap que si le PC manque réellement de mémoire.
Dans ce même fichier, on augmente la taille de la fenetre TCP, afin de pouvoir monter en débit, même si la latence est élevée.

sudo nano /etc/sysctl.d/90-optimisation.conf
Copier-coller le code ci-dessous

Code: [Sélectionner]

# Paramétrage de la fenêtre TCP à 32 Mio
net.ipv4.tcp_rmem=4096 131072 33554432
net.ipv4.tcp_wmem=4096 87380 33554432
net.core.rmem_max=33554432
net.core.wmem_max=33554432

# Limiter l’utilisation du swap
vm.swappiness = 1

Cela sera actif au prochain démarrage du PC.

vivien · « **Réponse #2 le:** 06 novembre 2021 à 14:02:20 »

2/ Côté serveur sauvegardé

A/ Installation du serveur OpenSSH

sudo apt install ssh

B/ Changement de port de SSH, pour limiter d'être la cible des attaques sur le port 22 : (le port 2222 est un exemple, choisissez le port de votre choix)

Ubuntu 24.10 Le port d'écoute de SSH se configure dans systemd :
sudo systemctl edit ssh.socket
Ajouter les 4 lignes suivantes :
[Socket]
ListenStream=
ListenStream=0.0.0.0:2222
ListenStream=[::]:2222 (En remplaçant 2222 par le port de votre choix, prendre de préférence un port au-dessus de 10 000)

Application des paramètres : sudo systemctl daemon-reload puis redémarrer le PC (sudo systemctl restart ssh ne semble pas suffisant pour éviter le redméarrage).

Ubuntu 24.04 LTS Le port d'écoute de SSH se configure dans systemd :
sudo systemctl edit ssh.socket
Ajouter les 3 lignes suivantes :
[Socket]
ListenStream=
ListenStream=2222 (En remplaçant 2222 par le port de votre choix, prendre de préférence un port au-dessus de 10 000)

Application des paramètres : sudo systemctl daemon-reload puis redémarrer le PC (sudo systemctl restart ssh ne semble pas suffisant pour éviter le redméarrage).

Ubuntu 18.04 LTS / 20.04 LTS / 22.04 LTS Le port d'écoute de SSH se configure dans sshd_config
sudo nano /etc/ssh/sshd_config
Changer la ligne #Port 22 par Port 2222, puis redémarrez le PC.

C/ Copier la clé publique du PC qui réaliser la sauvegarde sur le serveur sauvegardé

cd ~/.ssh : Se rendre dans le répertoire .ssh du compte auquel vous souhaitez accéder pour faire la sauvegarde - cela ne doit pas être "root" (Si le dossier n'existe pas, il suffit de faire mkdir ~/.ssh pour le créer, puis cd ~/.ssh pour se placer dans le dossier).

nano authorized_keys On édite le fichier (créez-le s’il n’existe pas)
Copiez-y sur une nouvelle ligne le contenu du fichier id_rsa.pub du client récupéré sur le PC de sauvegarde.
Sauvegardez le fichier.

vivien · « **Réponse #3 le:** 06 novembre 2021 à 14:02:35 »

3/ Test de l'authentification par clé SSH (Coté PC qui fait la sauvegarde)

Indispensable :
Il faut impérativement tenter une connexion SSH pour valider le key fingerprint.

ssh serveur.fr -p 2222

Remplacer serveur.fr par le nom de domaine du serveur à sauvegarder.
Remplacer 2222 par le port SSH écouté par le serveur à sauvegarder.

Si c'est la première connexion sur le serveur en SSH, ssh va vous demander de valider le "key fingerprint".

Code: [Sélectionner]

ECDSA key fingerprint is 3b:bb:2b:6b:3d:60:97:0a:8a:b8:34:8a:c1:be:c7:26.
Are you sure you want to continue connecting (yes/no)?

Répondre yes
Aucun mot de passe ne doit être demandé. Si un mot de passe est demandé, l'authentification par clé SSH est un échec. Vérifiez que vous n'avez pas inversé PC de sauvegarde et PC sauvegardé, vérifiez le fichier authorized_keys (il est bien dans le dossier .ssh ?),...

A la connexion suivante, le key fingerprint n'est pas demandé. La connexion se fera sans intervention de l'utilisateur, ce qui est nécessaire pour le script de sauvegarde.

vivien · « **Réponse #4 le:** 06 novembre 2021 à 14:03:12 »

4/ Script bash de sauvegarde (Côté PC qui fait la sauvegarde)

sudo apt install tcptraceroute : Dépendance à installer. "tcptraceroute" est utilisé pour vérifier que le port de SSH répond avant de lancer la sauvegarde.
sudo mkdir /home/sav : Les sauvegardes seront dans le dossier /home/sav
sudo chown utilisateur:utilisateur /home/sav : Le script de sauvegarde ne va pas se lancer avec les droits "root". Changer utilisateur par votre login.
cd /home/sav/ : On se place dans le dossier crée
nano sav-serveur.sh : Édition du script, remplacer serveur par le nom du serveur sauvegardé.
Copier-coller le texte ci-dessous dans le fichier :

Code: [Sélectionner]

#!/bin/bash
# Script de sauvegarde incrémentale d'un serveur ou PC Linux via SSH
# Version du 22/09/2024 pour Ubuntu / Debian / Raspbian / Linux Mint
# Dépendance à installer : sudo apt install tcptraceroute
# Pour ne pas demander de mot de passe, il faut une connexion SSH avec une clé au format RSA
# Créé par Olivier Bedouet (Bad Max) et Vivien Guéant
# Ce script est un logiciel libre que vous pouvez redistribuer ou modifier suivant la GNU GPLv3

#### Paramètres à personnaliser ####
SERVEUR=monserveur.fr # nom de SERVEUR du serveur à sauvegarder
NB_INCR=7 # Nombre de sauvegardes incrémentiel à garder
PORT_SSH=2222 # port où le SSH du serveur écoute (22 par défaut)
DEBIT_MAX=9000 # limite de bande passante, en ko par seconde, pour que la sauvegarde ne sature pas le réseau
REP_SAV=/home/sav # dossier où placer la sauvegarde en local
REP_SRC="
${SERVEUR}:/home/MonDossier1
${SERVEUR}:/home/MonDossier2
${SERVEUR}:/home/MonDossier3
" # Liste des dossiers à sauvegarder sur le serveur distant
FILE_ERR=${REP_SAV}/${SERVEUR}/log-${SERVEUR}.err # Emplacement du fichier qui log les éventuelles erreurs

#### Étape N°1: Test de l'ouverture du port TCP utilisé par SSH ####
echo -n "Test de l'ouverture du port ${PORT_SSH} : "
ttr=`tcptraceroute -q 1 ${SERVEUR} ${PORT_SSH} 2>&1`
if echo "${ttr}" | egrep -i "\[open\]" >/dev/null 2>&1
then
   echo "Port ${PORT_SSH} ouvert sur ${SERVEUR}"
else # Port SSH fermé, on quitte pour ne pas avoir une sauvegarde vide
   echo "Port ${PORT_SSH} fermé sur ${SERVEUR} : pas de sauvegarde"
   echo
   echo "!!!! ÉCHEC DE LA SAUVEGARDE !!!!"
   exit
fi

#### Étape N°2: Création du fichier de log des erreurs ####
if [ ! -d ${REP_SAV}/${SERVEUR} ]
then # le dossier pour le fichier de log manque, on le crée
   mkdir ${REP_SAV}/${SERVEUR}
fi
rm -f ${FILE_ERR}

#### Étape N°3: Efface la sauvegarde la plus ancienne ####
if [ -d ${REP_SAV}/${SERVEUR}/sav.${NB_INCR} ]
then
   echo -n "Efface derniere sauvegarde n-${NB_INCR} : "
   rm -fr ${REP_SAV}/${SERVEUR}/sav.${NB_INCR} 2>${FILE_ERR}
   cat ${FILE_ERR}
   echo "terminé"
fi

#### Étape N°4: Décale les autres sauvegardes ####
i=${NB_INCR}
while [ $i -gt 0 ]
do
   j=`expr $i - 1`
   if [ -d ${REP_SAV}/${SERVEUR}/sav.$j ]
   then
      echo -n "Sauvegarde n-$j "
      mv -v ${REP_SAV}/${SERVEUR}/sav.$j ${REP_SAV}/${SERVEUR}/sav.$i 2>>${FILE_ERR}
      cat ${FILE_ERR}
   fi
   i=`expr $i - 1`
done

#### Étape N°5: Contrôle de la présence de sav.1 ####
if [ ! -d ${REP_SAV}/${SERVEUR}/sav.1 ]
then # sav.1 n’existe pas / plus, on le crée
   mkdir ${REP_SAV}/${SERVEUR}/sav.1
fi

#### Étape N°6: Lancement de la sauvegarde avec rsync ####
echo "=================================================================================="
echo "${SERVEUR} -- Lancement de la sauvegarde incrémentale  -- `date`"
/usr/bin/rsync --verbose -a -e "ssh -p ${PORT_SSH}" --delete \
  --link-dest=${REP_SAV}/${SERVEUR}/sav.1 --stats --bwlimit=${DEBIT_MAX} ${REP_SRC} \
  ${REP_SAV}/${SERVEUR}/sav.0 2>>${FILE_ERR}
echo
echo "${SERVEUR} -- Fin de la sauvegarde incrémentale  -- `date`"

#### Étape N°7: Affichage des éventuelles erreurs ####
if [ -s ${FILE_ERR} ] ; then
  echo "=================================================================================="
  echo "Attention, il y a eu des erreurs lors de la sauvegarde :"
  cat ${FILE_ERR}
fi

chmod +x sav-serveur.sh : On rend le script exécutable

Modifier les paramètres suivants :

SERVEUR=monserveur.fr ⇒ nom de domaine du serveur à sauvegarder.
NB_INCR=7 ⇒ Nombre de sauvegardes incrémentiel à garder.
PORT_SSH=2222 ⇒ port où le SSH du serveur écoute.
DEBIT_MAX=9000 ⇒ limite de bande passante, en ko par seconde, pour que la sauvegarde ne sature pas le réseau.
${SERVEUR}:/home/MonDossier1 : Premier dossier à sauvegarder. Il doit être accessible en lecture par l'utilisateur ssh utilisé.
${SERVEUR}:/home/MonDossier2 : Second dossier à sauvegarder. Il doit être accessible en lecture par l'utilisateur ssh utilisé.
${SERVEUR}:/home/MonDossier3 : ...

Attention à ne pas mettre de "/" final pour les dossiers de sauvegardes, les données seraient mélangées dans /home/sav/sav-monserveur.fr/sav.0/
mettre ${SERVEUR}:/home/vivien/Documents/ est un exemple à ne pas suivre. Utiliser plutôt ${SERVEUR}:/home/vivien/Documents sans le / final.

Sauvegarde de Mozilla Thunderbird :
- Thunderbird au format SNAP (Ubuntu 24.04 LTS et + récents) : Les données sont dans /home/[user]/snap/thunderbird/common
- Thunderbird au format DEB (autres cas) : Les données sont dans /home/[user]/.thunderbird

Autre point d'attention : Si vous sauvegardez un disque complet, vous aurez une erreur, car il n'arrivera pas à sauvegarder le dossier "lost+found" qui se trouve à la racine de tous les volumes sous Linux.
3 possibilitées :
1/ Nommer un à un les dossiers du volume à sauvegarder, si ceux-ci sont fixes
2/ Exclure via un --exclude "lost+found" (voir plus loin pour ignorer des dossiers)
3/ Ignorer l'erreur qui s'affiche en fin de sauvegarde.

Utilisateur utilisé pour la sauvegarde :

Par défaut, le nom d'utilisateur distant utilisé est celui utilisé en local pour faire la sauvegarde. Pour préciser un autre nom d'utilisateur distant, il faut le placer devant chaque ligne de dossiers à sauvegarder.

Exemple si le nom d'utilisateur à utiliser est "vivien" :

vivien@${SERVEUR}:/home/MonDossier1 : Premier dossier à sauvegarder. Il doit être accessible en lecture par l'utilisateur ssh utilisé.
vivien@${SERVEUR}:/home/MonDossier2 : Second dossier à sauvegarder. Il doit être accessible en lecture par l'utilisateur ssh utilisé.
vivien@${SERVEUR}:/home/MonDossier3 : ...

Exemple d'utilisation du script pour sauvegarder un PC bureautique :

vivien · « **Réponse #5 le:** 06 novembre 2021 à 14:03:52 »

Exclure des dossiers de la sauvegarde

Une solution possible est de sauvegarder l'intégralité du dossier home et mentionner les dossiers à exclure avec la ligne --exclude

Il faut bien indiquer le dossier parent (si la syntaxe n'est pas bonne le dossier sera sauvegardé).

Un exemple concret est plus parlent : Sur ce PC, je sauvegarde l'intégralité de /home/jjg puis, j'exclus des dossiers systémes qui allourdisent bien la sauvegarde d'autant que c'est modifié réguliérement.
Je rajoute donc :
--exclude "jjg/snap"
--exclude "jjg/.local"
--exclude "jjg/.cache"
--exclude "jjg/.config"
--exclude "jjg/.googleearth"

Code: [Sélectionner]

#!/bin/bash
# Script de sauvegarde incrémentale d'un serveur ou PC Linux via SSH
# Version du 22/09/2024 pour Ubuntu / Debian / Raspbian / Linux Mint
# Dépendance à installer : sudo apt install tcptraceroute
# Pour ne pas demander de mot de passe, il faut une connexion SSH avec une clé au format RSA
# Créé par Olivier Bedouet (Bad Max) et Vivien Guéant
# Ce script est un logiciel libre que vous pouvez redistribuer ou modifier suivant la GNU GPLv3

#### Paramètres à personnaliser ####
SERVEUR=pc-jjg # nom de SERVEUR du serveur à sauvegarder
NB_INCR=5 # Nombre de sauvegardes incrémentiel à garder
PORT_SSH=2222 # port où le SSH du serveur écoute (22 par défaut)
DEBIT_MAX=20000 # limite de bande passante, en ko par seconde, pour que la sauvegarde ne sature pas le réseau
REP_SAV=/home/sav # dossier où placer la sauvegarde en local
REP_SRC="
--exclude "jjg/snap"
--exclude "jjg/.local"
--exclude "jjg/.cache"
--exclude "jjg/.config"
--exclude "jjg/.googleearth"
jjg@${SERVEUR}:/home/jjg
" # Liste des dossiers à sauvegarder sur le serveur distant
FILE_ERR=${REP_SAV}/${SERVEUR}/log-${SERVEUR}.err # Emplacement du fichier qui log les éventuelles erreurs

#### Étape N°1: Test de l'ouverture du port TCP utilisé par SSH ####
echo -n "Test de l'ouverture du port ${PORT_SSH} : "
ttr=`tcptraceroute -q 1 ${SERVEUR} ${PORT_SSH} 2>&1`
if echo "${ttr}" | egrep -i "\[open\]" >/dev/null 2>&1
then
   echo "Port ${PORT_SSH} ouvert sur ${SERVEUR}"
else # Port SSH fermé, on quitte pour ne pas avoir une sauvegarde vide
   echo "Port ${PORT_SSH} fermé sur ${SERVEUR} : pas de sauvegarde"
   echo
   echo "!!!! ÉCHEC DE LA SAUVEGARDE !!!!"
   exit
fi

#### Étape N°2: Création du fichier de log des erreurs ####
if [ ! -d ${REP_SAV}/${SERVEUR} ]
then # le dossier pour le fichier de log manque, on le crée
   mkdir ${REP_SAV}/${SERVEUR}
fi
rm -f ${FILE_ERR}

#### Étape N°3: Efface la sauvegarde la plus ancienne ####
if [ -d ${REP_SAV}/${SERVEUR}/sav.${NB_INCR} ]
then
   echo -n "Efface derniere sauvegarde n-${NB_INCR} : "
   rm -fr ${REP_SAV}/${SERVEUR}/sav.${NB_INCR} 2>${FILE_ERR}
   cat ${FILE_ERR}
   echo "terminé"
fi

#### Étape N°4: Décale les autres sauvegardes ####
i=${NB_INCR}
while [ $i -gt 0 ]
do
   j=`expr $i - 1`
   if [ -d ${REP_SAV}/${SERVEUR}/sav.$j ]
   then
      echo -n "Sauvegarde n-$j "
      mv -v ${REP_SAV}/${SERVEUR}/sav.$j ${REP_SAV}/${SERVEUR}/sav.$i 2>>${FILE_ERR}
      cat ${FILE_ERR}
   fi
   i=`expr $i - 1`
done

#### Étape N°5: Contrôle de la présence de sav.1 ####
if [ ! -d ${REP_SAV}/${SERVEUR}/sav.1 ]
then # sav.1 n’existe pas / plus, on le crée
   mkdir ${REP_SAV}/${SERVEUR}/sav.1
fi

#### Étape N°6: Lancement de la sauvegarde avec rsync ####
echo "=================================================================================="
echo "${SERVEUR} -- Lancement de la sauvegarde incrémentale  -- `date`"
/usr/bin/rsync --verbose -a -e "ssh -p ${PORT_SSH}" --delete \
  --link-dest=${REP_SAV}/${SERVEUR}/sav.1 --stats --bwlimit=${DEBIT_MAX} ${REP_SRC} \
  ${REP_SAV}/${SERVEUR}/sav.0 2>>${FILE_ERR}
echo
echo "${SERVEUR} -- Fin de la sauvegarde incrémentale  -- `date`"

#### Étape N°7: Affichage des éventuelles erreurs ####
if [ -s ${FILE_ERR} ] ; then
  echo "=================================================================================="
  echo "Attention, il y a eu des erreurs lors de la sauvegarde :"
  cat ${FILE_ERR}
fi

Pour inclure des dossiers dans les dossiers exclus, je conseille de les rajouter en dessous.

Exemple concret : exclure de la sauvegarde /snap qui contient des données très fréquemment mises à jour comme le cache de Firefox qu'il est inutile de sauvegarder, mais également les mails de Thunderbird.

La solution est d'exclure snap et de rajouter le dossier des mails :

vivien · « **Réponse #6 le:** 06 novembre 2021 à 14:04:10 »

5/ Lancement de la sauvegarde

Maintenant, il vous suffit de lancer le script /home/sav/sav-serveur.sh pour lancer une sauvegarde.
La première sauvegarde sera longue, car il devra sauvegarder l'intégralité.
Les sauvegardes suivantes seront rapides, parce qu'incrémentielles.

Si la sauvegarde est lancée automatiquement, par exemple chaque nuit, vous pouvez enregistrer le contenu de ce qui normalement affiché à l'écran via une redirection : /home/sav/sav-serveur.sh > /home/sav/log-serveur.log

Sur votre PC de sauvegarde, vous avez les dossiers suivants :

/home/sav/sav-monserveur.fr/sav.0 : dernière sauvegarde en date
/home/sav/sav-monserveur.fr/sav.1 : avant-dernière sauvegarde
/home/sav/sav-monserveur.fr/sav.2 : sauvegarde n-2
/home/sav/sav-monserveur.fr/sav.3 : sauvegarde n-3
/home/sav/sav-monserveur.fr/sav.4 : sauvegarde n-4
/home/sav/sav-monserveur.fr/sav.5 : sauvegarde n-5
/home/sav/sav-monserveur.fr/sav.5 : sauvegarde n-6 : la plus ancienne si vous limitez à 7 sauvegardes

Chaque dossier sav.x contiendra l'intégralité du contenu sauvegardé. Un contenu non modifié est donc présent logiquement une fois dans chaque dossier. Bien que présent 7 fois (si 7 sauvegardes), les données réelles sont uniques sur le disque. Un compteur de références permet de savoir combien de noms pointent sur les mêmes données. Quand la plus ancienne sauvegarde est supprimée, l'effacement n'est suivi d'une récupération de l'espace alloué aux données que si c'est sa dernière utilisation dans une sauvegarde (les sauvegardes plus récentes n'utilisent plus ce fichier).

vivien · « **Réponse #7 le:** 06 novembre 2021 à 14:06:55 »

Optionnel : Côté PC qui fait la sauvegarde : Sauvegarde incrémentale automatique chaque nuit.

crontab -e : Optionnel si le PC de sauvegarde est allumé en permanence, programmer une sauvegarde incrémentale quotidienne dans la crontab :
Copier-coller les lignes ci-dessous en fin de crontab, en prenant soins de remplacer serveur par le nom du serveur sauvegardé.

# Sauvegarde à 3h01 : 01 3 * * * /home/sav/sav-serveur.sh

Optionnel : Déprioriser le trafic de la sauvegarde

OpenSSH définit le champ TOS (type de service) dans l'entête IP afin de prioriser avec une faible latence les sessions interactives et de prioriser le débit les sessions non interactives.
Ces priorisations ne fonctionnent pas sur Internet (neutralité d'internet) et ce trafic atypique (SSH est une des rares applications à prioriser son trafic) peut poser un problème à des équipements réseaux.
Par exemple, la sauvegarde d'une Livebox Orange réalisée depuis le réseau mobile d'Orange (testé avec une Flybox 5G) sera limité à 5 Mb/s (afin que n'importe quel trafic ne soit pas priorisé, des limites de débit sont mis en place sur le trafic priorisé).

Il est donc conseillé de ne pas prioriser le trafic (best effort), ce qui correspond à la valeur CS0.
Pour en savoir plus : page Wikipédia Differentiated services.

1/ Coté machine sauvegardée, pour déprioriser le trafic émis par ce PC (contenu de la sauvegarde) :

On crée un fichier qui va demander d'utiliser CS0 pour les sessions interactives et CS0 pour les sessions non interactives :
sudo nano /etc/sshd/ssh_config.d/ssh_best_effort.conf
Copier-coller le code ci-dessous

Code: [Sélectionner]

# Ne pas prioriser le trafic SSH émis (best effort)
IPQoS cs0 cs0

2/ Coté PC avec le script de sauvegarde, pour déprioriser le trafic émis par ce PC (principalement les acquittements TCP - c'est ce trafic qui pose un problème avec le box 5G Orange)

On crée un fichier qui va demander d'utiliser CS0 pour les sessions interactives et CS0 pour les sessions non interactives :
sudo nano /etc/ssh/ssh_config.d/ssh_best_effort.conf
Copier-coller le code ci-dessous

Code: [Sélectionner]

# Ne pas prioriser le trafic SSH émis (best effort)
IPQoS cs0 cs0

Attention, la ligne de commande est presque identique entre les deux côtés, mais il y a une différence : /etc/sshd/ssh_config.d vs /etc/ssh/ssh_config.d

Script pour supprimer la dernire sauvegarde incrémentielle si elle s'est mal passée

Si la dernière sauvegarde incrémetielle s'est mal passée, il faut la supprimer, sans quoi la sauvegarde suivante ne sera pas incrémentiel, mais csera une sauvegarde totale, bien plus longue et qui va prendre beaucoup de place sur le disque, car il y aura deux fois le même contenu sur le PC de sauvegarde.

Ce script va supprimer sav.0 la dernière sauvegarde et annuler le déclage des sauvegardes plus anciennes réalisé.

Se placer dans le dossier de sauvegarde, par exemple /home/sav/sav-monserveur.fr/

nano suppr_derniere_sav.sh

Code: [Sélectionner]

#!/bin/bash
# Script qui supprime la dernire incrémentale 
# sav.0 est supprimé et est remplacée par sav.1
rm -r sav.0
mv sav.1 sav.0
# sav.2 devient sav.1
mv sav.2 sav.1
# sav.3 devient sav.2
mv sav.3 sav.2
# sav.4 devient sav.3
mv sav.4 sav.3
# et ainssi de suite
mv sav.5 sav.4
mv sav.6 sav.5
mv sav.7 sav.6
mv sav.8 sav.7
mv sav.9 sav.8
mv sav.10 sav.9
mv sav.11 sav.10
mv sav.12 sav.11
mv sav.13 sav.12
mv sav.14 sav.13
mv sav.15 sav.14
mv sav.16 sav.15
mv sav.17 sav.16
mv sav.18 sav.17

chmod +x suppr_derniere_sav.sh

Pour lancer le script de suppression de la dernière sauvegarde :
sudo ./suppr_derniere_sav.sh

Il est normal d'avoir des messages "Aucun fichier ou dossier de ce nom" pour les dossiers qui n'existent pas.

vincent0 · « **Réponse #8 le:** 06 novembre 2021 à 15:32:19 »

Article et script intéressants.

Une autre solution que j'aime beaucoup est restic : https://restic.net/

Utilitaire de backup standalone qui tourne sous Linux, windows et Mac et peut sauvegarder sur beaucoup de stockage cloud et aussi bien du sftp tout en chiffrant les backups.
La doc est aussi très bien faite.

letsar · « **Réponse #9 le:** 06 novembre 2021 à 17:43:52 »

Korben a fait un article sur Restic :

https://korben.info/comment-sauvegardez-vos-fichiers-avec-restic.html

ainsi qu'une vidéo :

Sn@ke · « **Réponse #10 le:** 06 novembre 2021 à 22:44:28 »

Sinon t'as ZFS

kazyor · « **Réponse #11 le:** 08 novembre 2021 à 17:37:03 »

Citation de: vivien le 06 novembre 2021 à 14:03:12

sudo apt install tcptraceroute : Dépendance à installer. "tcptraceroute" est utilisé pour vérifier que le port de SSH répond avant de lancer la sauvegarde.

De mon côté, j'aime bien utiliser ncat avec un post traitement de l'exit (0 ou 1) :

Code: [Sélectionner]

kazyor:~$ ncat -w .1 -z 127.0.0.1 80
kazyor:~$ echo $?
0
kazyor:~$ ncat -w .1 -z 127.0.0.1 81
kazyor:~$ echo $?
1