LINUX:RSYNC-Rassemblement sur une autre machine
But
Dans ce script, nous rassemblons en un seul endroit sur une autre machine ce que nous voulons sauvegarder. Cet ensemble constitue le premier niveau de sauvegarde, le plus actuel de la sauvegarde.
Dans notre approche, nous utilisons une machine distante se trouvant sur le même réseau.
Nous désirons laisser active cette machine distante que durant la sauvegarde. Ces scriptes s'articulent en quatre phases actionnées à partie de la machine dont on veut sauver les fichiers:
- Allumer la machine distante
- Attendre que la machine distance soit active
- Effectuer la sauvegarde vers la machine distante
- Eteindre la machine distante
Allumer la machine distante
Ce script s'articule sur l'envoi d'un "MAGIC PACKET" comme expliqué dans cet article: "Allumage à distance". Le nom de l'interface réseau est facultatif si vous n'en avez qu'un; il faut dans ce cas adapter le script. On exécute deux fois cet envoi par sécurité. Nous avons nommé ce fichier "allumer.bat".
#!/bin/bash # Allumage à distance d'une machine du même LAN MAC=$1 INTERFACE=$2 MANAGER=$3 cd $MANAGER echo "Allumer" /usr/sbin/ether-wake -i $INTERFACE $MAC /usr/bin/sleep 60 /usr/sbin/ether-wake -i $INTERFACE $MAC
Il attend trois paramètres:
- l'adresse MAC de la carte réseau de la machine distante
- le nom de l'interface réseau de la machine émettrice
- le répertoire contenant les scripts
Attendre que la machine distante soit active
Ce script a pour but de laisser la machine distante s'active mais on attend qu'un certain temps à adapter si nécessaire. Nous avons nommé ce fichier "ping.bat".
#!/bin/bash
# Tester via PING qu'une machine distante est allumée; on ne boucle que 100 fois
MACHINE=$1
MANAGER=$2
cd $MANAGER
echo "Test PING"
/usr/bin/echo "100% packet loss" > ${MANAGER}/ping1.log
NBS=0
ACTIVE=-1
while [ $NBS -lt '100' ]
do
/usr/bin/ping -c 2 ${MACHINE} >& ${MANAGER}/ping1.log
/usr/bin/grep "100% packet loss" ${MANAGER}/ping1.log > ${MANAGER}/ping2.log
/usr/bin/grep "unknown host" ${MANAGER}/ping1.log >> ${MANAGER}/ping2.log
/usr/bin/grep "inconnu" ${MANAGER}/ping1.log >> ${MANAGER}/ping2.log
if [ -s ${MANAGER}/ping2.log ]
then
let NBS++
echo $NBS
else
NBS=1000
ACTIVE=1
fi
done
/usr/bin/sleep 10
/usr/bin/rm -f ${MANAGER}/ping1.log
/usr/bin/rm -f ${MANAGER}/ping2.log
if [ $ACTIVE = '1' ]
then
/usr/bin/echo "Machine active: " ${MACHINE}
exit 1
else
/usr/bin/echo "Machine inactive: " ${MACHINE}
exit -1
fi
Il attend deux paramètres:
- le nom de la machine distante ou son adresse IP
- le répertoire contenant les scripts
SSH et RSYNC
Dans les opérations suivantes nous allons utiliser le protocole SSH seul ou en conjonction avec RSYNC. Nous allons donc configurer celui-ci et l'utilisateur concerné par notre projet sur la machine distante.
Sauvegarde sur la machine distante
Ce script effectue la sauvegarde en utilisant le programme "rsync". Ce transfert s'effectue au travers d'un canal crypté "ssh". Il est fort similaire à celui présenté dans l'article: "RSYNC-Rassemblement localement". Reportez-vous y pour plus de détails. Nous avons nommé ce fichier "action.bat".
#!/bin/bash
# Effectuer une action à distance sur la machine
############################################################
# variables à adapter
#
# répertoire de la base des sauvegardes sur la machine distante
BASE=/produc/sauvegarde
############################################################
MACHINE=$1
MANAGER=$2
cd $MANAGER
# répertoire des journaux
DIRLOG=$MANAGER/log
echo "Action"
# options pour rsync
OPTION="-a -z --numeric-ids --stats --delete --timeout=600 "
# TEST: si un autre processus rsync est encore en cours, ne pas démarrer celui-ci
TEST1=`ps ax | grep "rsync --server" | grep -v grep`
if [ "$TEST1" = "" ]
then
date +%Y/%m/%d\ %H:%M:00 >> ${DIRLOG}/log.lis
TEST2=1
if [ "$TEST2" = "1" ]
then
# boucler sur les différents répertoires à sauver, listés dans le fichier repertoire.txt
# format: 2 zones séparées par ":" (un couple par ligne)
# 1. répertoire source à partir de la racine (exemple: /disk1/manager)
# 2. répertoire cible sous le répertoire temporel de sauvegarde (exemple;: manager)
LISTEREPERTOIRE=`/usr/bin/cat ${MANAGER}/repertoire.txt`
for i in $LISTEREPERTOIRE
do
TEST3=`echo $i | /usr/bin/grep "#" `
if [ "$TEST3" = "" ]
then
SOURCE=`echo $i | /usr/bin/awk -F ":" '{printf("%s",$1)}' `
REPERTOIRECIBLE=`echo $i | /usr/bin/awk -F ":" '{printf("%s",$2)}' `
echo Source: $SOURCE
echo Cible: /$REPERTOIRECIBLE
/usr/bin/rsync ${OPTION} --log-file=${DIRLOG}/log.log --exclude=".recycle" -e "/usr/bin/ssh -i ${MANAGER}/key/serveur-distant-rsync-key -p 6333" ${SOURCE}/ sauvegarde@${MACHINE}:${BASE}/courant/${REPERTOIRECIBLE}/
fi
done
fi
else
echo "Occupé"
fi
Il attend deux paramètres:
- le nom de la machine distante ou son adresse IP
- le répertoire contenant les scripts
N'oubliez pas de paramétrer la variable "BASE" qui situe le répertoire de base de la sauvegarde sur la machine distante. Ne pas oublier de le créer sur cette machine avec les privilèges voulus; c'est à dure qu'il doit appartenir à l'utilisateur "sauvegarde". En effet la session SSH sur la machine distante est ouverte au nom de l'utilisateur "sauvegarde".
L'option "-e" et son paramètre définit la manière dont est effectuée l'ouverture de session SSH. Cette ouverture n'est pas faite via une authentification par mot de passe mais par une clé cryptée privée/publique analogue à ce qui est utilisé dans un protocole tel que HTTPS à part que dans ce dernier cas, elle est certifiée par une autorité. Remarquez que l'on précise un port de transfert autre que le port 22 utilisé par défaut par le protocole "ssh", ceci pour écarter les attaques du pirate du dimanche. Ici nous utilisons le port 6333 mais peu importe lequel pour autant qu'il ne soit pas déjà utilisé sur la machine distante.
Faisons remarquer que si votre firewalkl filtre ce qui sort de la machine, il faut ouvrir ce port.
Il faut créer deux sous-répertoires sous celui défini par la variable "MANAGER":
- log : où vont se loger des journaux de "rsync"
- key où est rangée la clé privée servant à l'ouverture de la session SSH
Le script boucle sur le fichier "repertoire.txt" se trouvant dans le répertoire désigné dans la variable "MANAGER". Il traite successivement chaque ligne. Chaque ligne comprend deux zones séparées par le sigle ":".
- La première zone correspond au contenu du répertoire à sauver. (exemple: "/disk1/utilisateur")
- La seconde zone correspond au nom du sous-répertoire, sous le répertoire repris dans la variable "BASE" suivie de "/courant", dans lequel le contenu à sauver sera copié sur la machine distante. (exemple: "/produc/sauvegarde/courant/utilisateur")
/disk1/utilisateur:utilisateur /disk1/mysql.dump:mysql.dump /manager:manager
Eteindre la machine distante
Ce script a pour but d'éteindre la machine distante. Nous avons nommé ce fichier "eteindre.bat".
#!/bin/bash
# Eteindre à distance une machine
MACHINE=$1
manager=$2
cd $MANAGER
echo "Eteindre"
/usr/bin/ssh -p 6333 -i ${MANAGER}/key/serveur-distant-rsync-key sauvegarde@${MACHINE} "sudo init 0"
Il attend deux paramètres:
- le nom de la machine distante ou son adresse IP
- le répertoire contenant les scripts
Comme pour le transfert "rsync", on utilise le protocole "ssh" via une authentification par clé par le port 6333 via l'utilisateur "sauvegarde".
Traitement global
En final, il faut concevoir un script chainant les différents scripts présentés ci-dessus. Nous avons nommé ce fichier "traitement.bat".
#!/bin/bash
# Chaine de traitement à distance
############################################################
# variables à adapter
#
# nom du répertoire où se retrouvent les scripts
MANAGER=/manager/sauvegarde
# nom de la machine distante ou son adresse IP
MACHINE=serverbackup
# adresse MAC de la machine distante
MAC=00:1c:c0:af:f1:33
# nom de l'interface réseau local
INTERFACE=enp0s25
############################################################
cd $MANAGER
date
# allumer la machine distante
${MANAGER}/allumer.bat ${MAC} ${INTERFACE} ${MANAGER}
# attendre que la machine distante soit active
${MANAGER}/ping.bat ${MACHINE} ${MANAGER}
# abandonner si la machine distante ne peut s'allumer
RETOUR=$?
#echo $RETOUR
if [ $RETOUR = '1' ]
then
# sauvegarder
${MANAGER}/action.bat ${MACHINE} ${MANAGER}
echo "Action effectuée"
else
echo "Action non affectuée"
fi
sleep 10
# éteindre la machine distante
${MANAGER}/eteindre.bat ${MACHINE} ${MANAGER}
date
Pour fonctionner, on doit définir les quatre variables dont on a besoin:
- le répertoire contenant les scripts
- le nom de la machine distante ou son adresse IP
- l'adresse MAC de la carte réseau de la machine distante
- le nom de l'interface réseau de la machine émettrice
CRON
L'exécution de ce script peut s'automatiser via le service "cron".
On peut ajouter une ligne dans le fichier "/etc/crontab":
10 23 * * * root /manager/sauvegarde/traitement.bat > /manager/sauvegarde/traitement.log
Dans cet exemple, il s'exécute tous les jours à 23h10 sous une cession de l'utilisateur "root".
Machine distante à travers Internet
Une sauvegarde est une sécurité en cas de désastre. En première approche, on pense au fait qu'on aie effacé un fichier par erreur mais d'autres situation existent de plus en plus graves: une cryptage par une cyberattaque, une surtension ou un coup de foudre qui détruit les machines. Il situation extrême peut arriver tel un incendie. Suivant cette approche, il faut prévoir des sauvegarde dans un autre bâtiment et même sur un site dans une autre ville d'au réseau indépendant.
Dans ce cas, on individualise la partie sauvegarde au travers d'un tunnel SSH et on effectue une sauvegarde sur une machine se trouvant sur un tout autre site à travers Internet. Il faut dans ce cas adapter les firewalls se trouvant sur le chemin (PAT). Sur la machine distante, on peut limiter l'accès à l'adresse IP de l'émetteur si cette adresse est fixe soit limiter l'accès au pays qui l'héberge en implantant une règle adaptée dans le firewall. (voir XTABLES-ADDONS)