====== Faire une sauvegarde de vos données ======

===== Méthode 1 : le classique tar.gz via SSH =====

Cette méthode donne une solution de sauvegarde pouvant être appelée à la demande ou de façon régulière. Elle consiste très simplement à exécuter un script de sauvegarde depuis le compte root de votre serveur, script qui va tout simplement envoyer les données en les compressant en tar.gz

<note>Nous parlerons de **client** pour désigner la machine qui reçoit la sauvegarde et de **serveur** pour celle que nous sauvegardons. Le **serveur** est votre machine Gandi.</note>

==== Créer une clé SSH pour la sauvegarde ====

Sur le **client**, nous allons créer une clée SSH :

<code>
$ if [ ! -d ~/.ssh ]; then mkdir .ssh && chmod 700 .ssh; fi
$ ssh-keygen -f ~/.ssh/id_rsa_backup -N '' -t rsa -b 2048
</code>

Le contenu de notre clé publique se trouve dans le fichier ~/.ssh/id_rsa_backup.pub. 

Nous allons copier ce fichier sur le **serveur** :

<code>
$ scp ~/.ssh/id_rsa_backup.pub <vm-user>@<vm-host>:/home/<mon-compte>/
</code>

Maintenant, nous allons ajouter la clé dans le fichier /root/.ssh/authorized_keys du **serveur**. Après connection sur celui-ci :

<code>
$ sudo su
# if [ ! -d /root/.ssh ]; then mkdir /root/.ssh && chmod 700 .ssh; fi
# if [ ! -f /root/.ssh/authorized_keys ]; then touch /root/.ssh/authorized_keys && chmod 600 /root/.ssh/authorized_keys; fi
# echo "command=\"/root/bin/backup_wrapper.sh\" `cat id_rsa_backup.pub`" >> /root/.ssh/authorized_keys
# exit
$ rm ~/id_rsa_backup.pub
</code>

Nous venons d'ajouter la clé et de restreindre son usage à la seule commande %%/root/bin/backup_wrapper.sh%%

Depuis le **client** nous pouvons essayer de nous connecter et constater qu'il va essayer de lancer la commande %%/root/bin/backup_wrapper.sh%% qui n'existe pas encore (remplacez <vm-host> par le nom de votre serveur).

<code>
$ ssh -i ~/.ssh/id_rsa_backup root@<vm-host>
</code>

==== Le script de sauvegarde ====

Retournons sur le **serveur** pour créer le script %%/root/bin/backup_wrapper.sh%%

<code>
$ sudo su
# if [ ! -d /root/bin ]; then mkdir /root/bin; fi
# touch /root/bin/backup_wrapper.sh
# chmod 700 /root/bin/backup_wrapper.sh
# touch /root/bin/backup.sh
# chmod 700 /root/bin/backup.sh
# exit
</code>

Nous avons également créé un script %%/root/bin/backup.sh%%. Le fonctionnement est assez simple. Nous allons appeler le script %%/root/bin/backup_wrapper.sh%% à chaque connexion SSH avec la clé. Ce script va vérifier que la commande demandée à la connexion SSH est bien %%/root/bin/backup.sh%% et, le cas échéant, lancer le script.

Voici le code de %%/root/bin/backup_wrapper.sh%%

<file>
#!/bin/sh
if [ "$SSH_ORIGINAL_COMMAND" = "/root/bin/backup.sh" ]; then 
  $SSH_ORIGINAL_COMMAND
else
  echo "Rejected"
fi
</file>

Et enfin, voici le fichier %%/root/bin/backup.sh%%

<file>
#!/bin/sh

/bin/tar cvfz - /etc /root /home /var/backups /var/lib /srv/<mon-disque>
</file>

Pensez bien à remplace **/srv/<mon-disque>** par le chemin de votre disque de données. Ajoutez tous les chemins à sauvegarder qui vous semblent nécessaires.

Ce script est très rudimentaire, il pourrait être complété par une sauvegarde de la base de données MySQL si vous en avez une. Par exemple, avant la commande tar, nous pourrions ajouter :

<code>
/usr/bin/mysqldump --defaults-file=/etc/mysql/debian.cnf -A -Q --opt | /bin/gzip > /var/backups/mysql-dump.sql.gz
</code>

Attention ceci n'est valable que pour debian ou ubuntu

==== Exécution du script depuis le client ====

Depuis le **client**, vous allez pouvoir lancer tout simplement la commande suivante :

<code>
$ ssh -i ~/.ssh/id_rsa_backup root@<vm-host> "/root/bin/backup.sh" > sauvegarde.tar.gz
</code>

==== Effectuer le backup de façon régulière ====

Pour exécuter régulièrement la commande de backup donnée ci-dessus depuis le **client**, on pourra utiliser l'ordonnanceur cron.

Editer votre crontab sur la machine **client** :

<code>
$ crontab -e
</code>

La commande ''crontab -e'' ouvre votre fichier crontab en édition.

Pour exécuter la commande de backup tous les soirs à 23h00, insérer la commande sous cette forme :

<file>
MAILTO=<votre-adresse-mail>
0 23 * * * ssh -i ~/.ssh/id_rsa_backup root@<vm-host> "/root/bin/backup.sh" > sauvegarde.tar.gz
</file>

Sauvegarder le fichier, et quitter l'éditeur pour prendre en compte votre nouvelle crontab.

Le fichier sauvegarde.tar.gz sera créé dans votre home directory, et vous recevrez un mail, à l'adresse indiqué dans MAILTO, avec la sortie de la commande de backup qui vous permettra de vérifier que le backup s'est correctement exécuté. 




===== Méthode 2 : Rsync =====
Cette méthode permet de copier toute une arborescence présente sur le serveur (Linux) sur un PC local (Linux, ou en utilisant Cygwin). 

rsync est une commande GNU qui permet de synchroniser des machines distantes. Vous pouvez accéder à l'aide en ligne de la commande **info rsync** (il existe aussi d'excellents articles sur fr-ubuntu.org). 

L'avantage de cette méthode est qu'elle met à jour une copie conforme de toute l'arborescence. (Le nouveaux fichiers et les fichiers modifiés sont recopiés en local, les fichiers supprimés sur le serveur depuis la dernière synchronisation sont **supprimés de la copie locale**).

==== 1. Installer rsync ====

Exécuter la commande suivante sur votre serveur pour y installer rsync:

<code>
sudo apt-get install rsync
</code>


==== 2. Lancer rsync depuis le client (machine recevant la copie du serveur) ====


Nous supposons que vous pouvez vous logger avec ssh.
<code>
#!/bin/bash
#Recupère tous les fichiers du serveur gdm
rsync -r -t -v -z --progress --rsh=ssh mon_serveur.com:/srv/d_mon_disk/ /home/backup 
read -n 1 -p "Press a key to continue..."
</code>

Note : le / à la fin du nom du répertoire source n'est pas optionnel.

Sous Linux, il existe une interface graphique appelée GSync (grsync sous Ubuntu).


FIXME À développer