La Fibre
Télécom => Logiciels et systèmes d'exploitation => 
Tutoriels pour Ubuntu server => Discussion démarrée par: 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.
(https://lafibre.info/testdebit/ubuntu/202111_sauvegarde_linux_1.jpg)
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.
(https://lafibre.info/testdebit/ubuntu/202111_sauvegarde_linux_2.jpg)
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.
(https://lafibre.info/testdebit/ubuntu/202111_sauvegarde_linux_3.jpg)
-
Tutoriel testé avec Ubuntu version 20.04 LTS, Ubuntu 22.04 LTS et Ubuntu 23.10
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 : 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
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 ces lignes, 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.
sudo nano /etc/sysctl.d/90-optimisation.conf
Copier-coller le code ci-dessous
# 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.
-
2/ Côté serveur sauvegardé : installer le serveur ssh et rajouter la clé publique du serveur de sauvegarde
sudo apt install ssh : installation du serveur SSH
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 23.10 / 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)
(https://lafibre.info/testdebit/ubuntu/202401_tuto_ubuntu_changer_port_ssh.webp)
Application des paramètres : sudo systemctl daemon-reload puis sudo systemctl restart ssh, mais vous pouvez simplement redémarrer le PC.
- 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.
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.
-
3/ 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".
(https://lafibre.info/testdebit/ubuntu/202111_ubuntu_etc_hosts.png)
-
4/ Coté PC qui fait la sauvegarde : Test de l'authentification par clé SSH
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".
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.
-
5/ Côté PC qui fait la sauvegarde : Script bash de 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 :
#!/bin/bash
# Script de sauvegarde incrémentale d'un serveur ou PC Linux via SSH
# Version du 21/10/2021 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}
fiModifier 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.
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. Je conseille de nommer un à un les dossiers du volume à sauvegarder ou d'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 : ...
chmod +x sav-serveur.sh : On rend le script exécutable
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"
#!/bin/bash
# Script de sauvegarde incrémentale d'un serveur ou PC Linux via SSH
# Version du 21/10/2021 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
-
6/ 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).
Exemple d'utilisation du script pour sauvegarder un PC bureautique :
(https://lafibre.info/testdebit/ubuntu/202110_script_sauvegarde_ubuntu.png)
7/ 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
-
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.
-
Korben a fait un article sur Restic :
https://korben.info/comment-sauvegardez-vos-fichiers-avec-restic.html (https://korben.info/comment-sauvegardez-vos-fichiers-avec-restic.html)
ainsi qu'une vidéo :
https://www.youtube.com/watch?v=hSvVRZvcI4E
-
Sinon t'as ZFS ;)
-
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) :
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
-
Merci, je pense que ncat cela sera mieux que tcptraceroute. Ce dernier est assez lent pour voir si un port est ouvert.
Mon pré-requis était qu'il tourne sans avoir besoin des droits root, ce qui semble bien le cas de ncat.
Quand j'ai un peu de temps, je modifie le script.
-
Bonjour,
Sinon, il y'a le très bon Veeam Agent for Linux qui est gratuit: https://www.veeam.com/fr/linux-backup-free.html
-
Pour les backups j'ai tendance a préférer les object storage ou autre (ca coute moins cher au final et rien a gérer), j'utilisais pendant pas mal de temps rclone avec du bucket backblaze et du lifecycle policy (pour garder les X anciennes version pendant plusieurs jours), puis je suis passé récemment sur https://kopia.io/ qui gère ca lui même et j'ai mis ca sur de l'object storage chez nous (Scaleway) a Amsterdam.
Ça juste marche et c'est relativement simple a configurer (avec chiffrage et compression)
-
Personnellement je recommande borg-backup. C'est super, et gère la dé-duplication et le chiffrement.
En interne, ça se passe un peu comme git: il y a des dépots distants et locaux, et des rolling hash pour la déduplication.
Je n'ai pas testé voir comment il se comportait avec les fichiers sparse ("troués" là où ils n'ont pas été écrits), les reflinks (copy on write) et les hard links (fichiers partageant l'inode). Mais pour le reste, nickel!
J'ai récemment mis en place borgmatic: https://torsion.org/borgmatic/
Pour ce qui est du serveur, rsync.net propose de l'espace de stockage à un prix raisonable. Assez facile de donner de l'espace à des amis via SSH sécurisé (accès uniquement à la commande `borg`).
-
Question bête, qqn a déjà regardé comment backup des fichiers CSV ?
Avec un tri du fichier, et un git / diff, on peut éviter la duplication d'une ligne si elle est identique.
En revanche, dans le cas où nous avons qu'une colonne qui change, la ligne étant complètement différente, on duplique tous les champs.
En bref, vous connaissez un outil à la diff qui sait gérer les CSV ?
-
Question bête, qqn a déjà regardé comment backup des fichiers CSV ?
Avec un tri du fichier, et un git / diff, on peut éviter la duplication d'une ligne si elle est identique.
En revanche, dans le cas où nous avons qu'une colonne qui change, la ligne étant complètement différente, on duplique tous les champs.
En bref, vous connaissez un outil à la diff qui sait gérer les CSV ?
Quand tu commence à avoir des besoins comme ca c'est peut être temps de passer a autre chose que du CSV :)
Ce genre de diff est en général géré sans soucis via les binlogs des bases de données.
-
Ce n'est pas moi qui choisi le format d'échange :)
En l’occurrence, export quotidien de données peu volatiles.
Si je pouvais ne pas archiver bêtement, ça serait top ...
-
puis je suis passé récemment sur https://kopia.io/ qui gère ca lui même et j'ai mis ca sur de l'object storage chez nous (Scaleway) a Amsterdam.
Je ne connaissais pas Kopia ! Comment le comparerais-tu à Restic ?
-
Je ne connaissais pas Kopia ! Comment le comparerais-tu à Restic ?
Je connais pas du tout Restic donc je pourrais pas comparer,
Mais Kopia est vraiment simple a config en tout cas, et ca gère la compression et le chiffrage automatiquement (avec des algos configurable pour les deux selon le besoin)
-
Question bête, qqn a déjà regardé comment backup des fichiers CSV ?
Avec un tri du fichier, et un git / diff, on peut éviter la duplication d'une ligne si elle est identique.
En revanche, dans le cas où nous avons qu'une colonne qui change, la ligne étant complètement différente, on duplique tous les champs.
En bref, vous connaissez un outil à la diff qui sait gérer les CSV ?
De la simple compression devrait gérer cela très efficacement. Pour stocker de multiples copies sauvegardées ? Des snapshots de système de fichier, ou quelque chose avec des rolling hashes, peut-être ostree, ou la plupart des outils avec dé-duplication (borg inclus).
-
Le disque dur externe : la meilleure solution de stockage ? 🤔 Pas sûr… @Micode nous montre ses limites et nous parle des solutions qui s'offrent à vous !
https://www.youtube.com/watch?v=UsoOr50Uhdk
-
Avec mon script, si la dernière sauvegarde incrémentielle est vide, incomplète, cela pose un problème, car la sauvegarde suivante ne sera plus une sauvegarde incrémentielle, mais complète, ce qui prend du temps et peu saturer votre espace disque (vous aurez deux sauvegardes complètes).
Pour résoudre ce problème, il faut donc supprimer la sauvegarde vide, mais également décaler les précédentes sauvegardes.
Voici un script, à exécuter dans le dossier dans lequel sav.0 sav.1 sav.2 ... apparaissent.
Il va supprimer la dernière sauvegarde ratée (sav.0) et décaler les sauvegardes précédentes, de façon à ce que la prochaine sauvegarde soit incrémentielle : sav.1 est renommé sav.0, sav.2 est renommé sav.1 et ainsi de suite.
#!/bin/bash
if [ -d sav.0 ]
then
echo -n "Efface sav.0"
rm -r sav.0
fi
if [ -d sav.1 ]
then
echo -n "Déplace sav.1"
mv sav.1 sav.0
fi
if [ -d sav.2 ]
then
echo -n "Déplace sav.2"
mv sav.2 sav.1
fi
if [ -d sav.3 ]
then
echo -n "Déplace sav.3"
mv sav.3 sav.2
fi
if [ -d sav.4 ]
then
echo -n "Déplace sav.4"
mv sav.4 sav.3
fi
if [ -d sav.5 ]
then
echo -n "Déplace sav.5"
mv sav.5 sav.4
fi
if [ -d sav.6 ]
then
echo -n "Déplace sav.6"
mv sav.6 sav.5
fi
if [ -d sav.7 ]
then
echo -n "Déplace sav.7"
mv sav.7 sav.6
fi
if [ -d sav.8 ]
then
echo -n "Déplace sav.8"
mv sav.8 sav.7
fi
if [ -d sav.9 ]
then
echo -n "Déplace sav.9"
mv sav.9 sav.8
fi
if [ -d sav.10 ]
then
echo -n "Déplace sav.10"
mv sav.10 sav.9
fi
if [ -d sav.11 ]
then
echo -n "Déplace sav.11"
mv sav.11 sav.10
fi
if [ -d sav.12 ]
then
echo -n "Déplace sav.12"
mv sav.12 sav.11
fi
if [ -d sav.13 ]
then
echo -n "Déplace sav.13"
mv sav.13 sav.12
fi
if [ -d sav.14 ]
then
echo -n "Déplace sav.14"
mv sav.14 sav.13
fi
if [ -d sav.15 ]
then
echo -n "Déplace sav.15"
mv sav.15 sav.14
fi
if [ -d sav.16 ]
then
echo -n "Déplace sav.16"
mv sav.16 sav.15
fi