Forum général.cherche-logiciel [Résolu] Backup (oui, c'est une vielle problématique)

Posté par Xinfe (site web personnel) le 09 mars 2014 à 10:33. Licence CC By‑SA.

Étiquettes :

mar.

2014

Salut à tous !

Je sais que le sujet est déjà passé moult fois, mais je n'arrive pas à trouver une solution de sauvegarde. Au commencement, j'utilisais cp. (En fait non, j'étais sous Windows, mais l'idée est la même).

Donc sur mon HDD externe de backup, je me retrouvais avec la structure suivante :

Big'n'dirty backup (2012.10.07)
Big'n'dirty backup (2012.11.22)
Big'n'dirty backup (2012.11.28)
…

C'est cool, intuitif, portable, compatible et méchamment simple. C'est aussi terriblement peu efficace, surtout quand je backup un home de 140Gio sur un disque de 320. (Et un autre de 160 juste au cas où).

J'ai donc investigué d'autres solutions telles que rsync, rdiff-backup ou d'autres trucs plus obscurs les uns que les autres, mais aucun ne m'a séduit. J'avoue envier le fonctionnement de Time Machine sur OS X. En gros, je cherche les points suivants :

Sauvegarde sous forme d'arborescence. Non, je ne veux pas de .tar.diff ou d'autres trucs exotiques. Brancher mon disque dur sur une autre machine doit me permettre de lire la/les sauvegarde(s) sans nécessiter de logiciel spécifique
Sauvegarde incrémentale. Parce que la déduplication à coup de liens durs, je pense que c'est lebien.
Structure logique du genre backup/yyyy.mm.dd/, où la sauvegarde les sauvegardes plus anciennes sont facilement navigables, avec éventuellement un backup/current/ qui est un lien vers la sauvegarde la plus récente.
Gestion des liens durs/symboliques/magiques/whatever. rdiff-backup me balance plein d'erreurs concernant les liens durs. Un rapport de bug est ouvert depuis des années pour ça, avec un patch que j'ai essayé d'appliquer localement, mais sans succès.

Peut être que rsync propose de faire ça, mais je n'ai rien trouvé de bien clair. Je suis majoritairement avec mon portable en train de me balader partout et sans mon HDD de backup connecté en permanence donc pas besoin de système super-sophistiqué à coup de crons pour faire des minute-diff. Un petit utilitaire/script à lancer manuellement quand j'y pense est suffisant.

Quelle solution fiable et futur-proof avez vous à conseiller ?

Edit: J'ai choisi la solution d'Axone, avec en plus l'option --no-perms car mon disque cible en NTFS ne gère pas les permissions ce qui empêchait la déduplication.

# backuppc

Posté par Xavier le 09 mars 2014 à 10:45. Évalué à 2.

Tout est dans le titre.

Have Fun!
# rsync avec --link-dest

Posté par Axone le 09 mars 2014 à 12:37. Évalué à 8. Dernière modification le 09 mars 2014 à 12:42.
Depuis 2 ans environ, j'utilise un script bash pour rsync, trouvé sur internet et modifié un peu par mes soins:
```
#!/bin/sh
date=`date "+%Y%m%d-T%H%M%S"`

# Attention au /
SOURCE_DIR=/home/denis/
TARGET_HOST=192.168.0.4
TARGET_USER=rsync
TARGET_DIR=/volume1/persosave/rsync/denis



time rsync --archive --one-file-system --hard-links \
  --human-readable --inplace  \
  --partial --progress \
  --delete-excluded \
  --exclude-from=$SOURCE_DIR/script/rsync-exclude \
  --link-dest=$TARGET_DIR/current \
  $SOURCE_DIR $TARGET_USER@$TARGET_HOST:$TARGET_DIR/incomplete_back-$date 

 if [ $? -eq 0 ]; then
    ssh $TARGET_USER@$TARGET_HOST "mv $TARGET_DIR/incomplete_back-$date $TARGET_DIR/back-$date \
    && rm -f $TARGET_DIR/current \
    && ln -s back-$date $TARGET_DIR/current";
fi
```
Il remplit toutes tes demandes, je le trouve fiable. Le script ci-dessus sert pour une connexion à distance sur un autre ordi à travers ssh, il faut donc juste un peu le simplifier pour du local.
J'ai le même script un peu plus étoffé, pour gérér plusieurs sources avec sauvegarde sur un NAS syno et envoi d'un rapport par mail.

PS : un lien pour expliquer l'option --link-dest
PS2 : le script est basique, je pense qu'il faudra "l'amorcer" au début, c'est à dire avoir les répertoires de créés, avoir une première sauvegarde dans le répertoire de destination, ainsi qu'un lien symbolique "current" sur la première sauvegarde.
- [^] # Re: rsync avec --link-dest
  
  Posté par Xinfe (site web personnel) le 09 mars 2014 à 18:11. Évalué à 2.
  
  J'ai regardé backupPC proposé avant, mais je dois reconnaître que ça me semble overkill pour mes besoins. Et puis découvrir après 40 minutes de tentative de configuration que pour choisir la destination, il faut créer un lien vers la "vraie" destination, je trouve ça moyen.
  
  Donc le petit script rsync de quelques lignes, j'apprécie l'approche, d'autant plus qu'il est clair. Je vois voir pour "l'amorçage", mais je ne pense pas que ça soit compliqué :)
  
  J'attends de voir si d'autres réponses tombent, mais celle-ci a ma préférence pour l'instant.
  - [^] # Re: rsync avec --link-dest
    
    Posté par Zylabon le 09 mars 2014 à 23:19. Évalué à 3.
    Pour l’amorçage, il n'y rien de particulier à faire, si le paramètre --link-dest n'est pas valide il va juste l'ignorer.
    
    C'est ce que j'utilise aussi.
    
    Sinon pour les "exclude" j'ai préféré cette solution, du coup j'ai tout dans un seul fichier :
```
RSYNC_EXCLUDE=$(echo --exclude={.local,.cache,Vidéos,.mozilla/firefox/*/Cache,.thumbnails})
```
    Please do not feed the trolls
- [^] # Re: rsync avec --link-dest
  
  Posté par Xinfe (site web personnel) le 10 mars 2014 à 10:26. Évalué à 2.
  Bon, il semble que les hard-links avec le backup précédent ne fonctionne pas.
  Voici ma procédure de test pour vérifier que les liens durs sont bien supportés tant sur la source que la destination :
```
$ cd test
$ echo 'file A' > A
$ cp -al A B
$ echo 'file B' > B
$ cat A B
file B
file B
# On a donc bien le support des liens durs à la source
$ ../backup.sh
$ stat /media/backup/back-20140310-T101428/A /media/backup/back-20140310-T101428/B
# Même résultat d'inœud (inode), "Liens : 2". Les liens durs sont aussi supportés pendant le backup et sur la cible
$ ../backup.sh
$ stat /media/backup/back-20140310-T101601/A /media/backup/back-20140310-T101601/B
# Même résultat d'inœud (inode), "Liens : 2". Cette fois-ci, on devrait avoir 4 au lieu de 2
```
  Voici le script (que j'ai très peu modifié) :
```
#!/bin/sh
date=`date "+%Y%m%d-T%H%M%S"`

# Attention au /
SOURCE_DIR=/home/xinfe/test/
TARGET_DIR=/media/X-WD/backup



time rsync --archive --one-file-system --hard-links \
  --human-readable --inplace  \
  --partial --progress \
  --delete-excluded \
  --link-dest=$TARGET_DIR/current \
  $SOURCE_DIR $TARGET_DIR/incomplete_back-$date

 if [ $? -eq 0 ]; then
    mv $TARGET_DIR/incomplete_back-$date $TARGET_DIR/back-$date \
    && rm -f $TARGET_DIR/current \
    && ln -s back-$date $TARGET_DIR/current;
fi
```
  - [^] # Re: rsync avec --link-dest
    
    Posté par Axone le 10 mars 2014 à 12:13. Évalué à 2.
    
    Pourtant les liens durs fonctionnent entre les sauvegardes, c'est sur.
    - [^] # Re: rsync avec --link-dest
      
      Posté par Xinfe (site web personnel) le 10 mars 2014 à 13:15. Évalué à 1.
      
      Pour l'instant, je fais un backup, je vérifierai cette histoire de hard-links plus tard.
      
      Merci pour le script, je crois que c'est la solution que je vais adopter, avec la liste d'exclusion inline. :)
      - [^] # Re: rsync avec --link-dest
        
        Posté par Axone le 10 mars 2014 à 16:44. Évalué à 2.
        
        Je viens de faire ton test, aucun problème : j'ai bien "Liens : 4" après la seconde sauvegarde.
        
        [^] # Re: rsync avec --link-dest
        
        Posté par Xinfe (site web personnel) le 11 mars 2014 à 09:03. Évalué à 2.
        
        Il se peut que j'ai trouvé le problème :
        http://superuser.com/questions/165714/using-rsync-with-link-dest-from-hfs-to-ntfs
        
        En gros, l'option --archive est trop spécifique car les fichiers doivent être strictement identiques (contenu et meta-données). Et ça coincerai au niveau des droits. Je réessaierai dès que possible (=ce soir) en prenant ça en compte.
        
        J'ai aussi vu qu'il peut y avoir des problèmes avec les timestamps qui peuvent être impécis à une seconde près, auquel cas il faut ajouter l'option --modify-window=1
        
        [^] # Re: rsync avec --link-dest
        
        Posté par Xinfe (site web personnel) le 15 mars 2014 à 23:09. Évalué à 1.
        
        Alors, j'ai enfin pris le temps de faire mes tests, et le problème concerne les permissions :
        
        Original: Accès : (0664/-rw-rw-r--) UID : ( 1000/ xinfe) GID : ( 1000/ xinfe) Backup: Accès : (0600/-rw-------) UID : ( 1000/ xinfe) GID : ( 1000/ xinfe)
        
        J'ai donc ajouté l'option --no-perms et tout est hard-linké comme attendu.
        
        Merci en tous cas pour ce petit script, c'est exactement le genre de chose que je cherchais !
# Dirvish

Posté par Clement33 le 09 mars 2014 à 14:08. Évalué à 1.

Dirvish ?

# Rsync toujours...

Posté par labiloute le 09 mars 2014 à 14:26. Évalué à 1. Dernière modification le 10 mars 2014 à 21:34.

Salut à tous,

Dans le même esprit qu'Axone, j'ai écrit un script rsync dont le principe est le suivant :

Un ou plusieurs répertoires sources, et du coup, un ou plusieurs répertoires de destination possibles.
La sauvegarde est incrémentale, chaque fichier modifié depuis la dernière sauvegarde est suffixé par la date de la sauvegarde (monfichier.txt et monfichier.txt_201404_03_09 sont dans le même répertoire)
Possibilité de faire un "rsync --delete" ponctuel du répertoire de destination, par exemple tous les lundis après externalisation, ou pas.
Possibilité d'avoir une source et/ou une destination SSH, l'échange des clés doit être fait au préalable bien sur.
Écriture dans un fichier de log et rotation du fichier de log
Utilisation du fichier de filtre rsync

La contrainte est d'avoir un répertoire de destination non vide la première backup. j'ai du faire cette vérification pour éviter qu'un éventuel répertoire CIFS mal monté déclenche une sauvegarde en local, ce qui pourrait rapidement saturé un disque local s'il n'est pas prévu pour. Créer un fichier bidon lors de la première sauvegarde suffit.

En le relisant je vois pas mal d'améliorations possible, mais jusqu'à présent ça m'a déjà pas mal rendu service.

Enjoy !

    #!/bin/bash
    #jour de la semaine ou est remise a zero la sauvegarde (1-7 - 0 pour ne jamais executer de rsync --delete)
    day_to_delete=0
    # Nombre de jours avant nettoyage par le find
    day_to_conserve=60
    #le chemin de source et de destination doivent exister et etre non vide - (sauf si ssh)
    srcpath=( "/first/source/path" "/second/source/path" )
    destpath=( "/first/dest/path" "/second/dest/path" )
    #Fichier de filtre (unique pour X synchros)
    filter_file="/rsync/filter/file/path.txt"

    #SSH SOURCE PARAM
    sshsourcebackup=0
    sshsourcelogin=user
    sshsourcehost=host
    #SSH DEST PARAM
    sshdestbackup=0
    sshdestlogin=user
    sshdesthost=host
    #Log file
    log_file="/path/to/log/file.txt"
    maxlines=1000
    #
    # Script
    #
    todayinweek=`date +%u`
    today=`date +%F`
    ######
    #FONCTION ecriture dans fichier de log et rotation des logs (update du 26/10/2011)
    function writelogandrotate
    {
            #refresh date of log writing
            date_log=$( date +%d-%m-%Y )' '$( date +%H:%M:%S )
            #write log in the log file (given in parameter)
            echo $date_log' '$1 >> $log_file
            #show whats written to the stdout
            echo $date_log' '$1
            #purge log file
            nblines=`cat $log_file | wc -l`
            #while the logline var is  less than the number of line in the log file
            while [ "$maxlines" -lt "$nblines" ]
            do
                    sed -i '1d' $log_file
                    nblines=`cat $log_file | wc -l`
            done
    }
    ####################SCRIPT
    if [ "$sshsourcebackup" = "1" ] ; then
        sshcmd="-e ssh"
        sshsourcecred="${sshsourcelogin}@${sshsourcehost}:"
    fi
    if [ "$sshdestbackup" = "1" ] ; then
            sshcmd="-e ssh"
            sshdestcred="${sshdestlogin}@${sshdesthost}:"
    fi

    #test de l existance des repertoires sources et destination (sauf si ssh activé)
    for (( i = 0 ; i < ${#srcpath[@]} ; i++ ))
        do
        if [ ! "$(ls -1A ${srcpath[$i]})" ] && [ "$sshsourcebackup" = "0" ] ; then
            ( writelogandrotate "Source ${srcpath[$i]} vide et ssh non activé. Abort." )
            exit 1
        fi
        if [ ! "$(ls -1A ${destpath[$i]})" ] && [ "$sshdestbackup" = "0" ] ; then
            ( writelogandrotate "Destination ${destpath[$i]} vide et ssh non activé. Abort." )
            exit 1
        fi
    done
    #
    if [ $day_to_delete -eq $todayinweek ] ; then
        ( writelogandrotate "Nous sommes le jour $day_to_delete de la semaine, execution de rsync --delete : " )
        for (( i = 0 ; i < ${#srcpath[@]} ; i++ ))
            do
            ( writelogandrotate "Démarrage du script de sauvegarde incrémentielle de ${srcpath[$i]} vers ${destpath[$i]}" )
            rsyncexec=`rsync $sshcmd -a --stats --filter="merge $filter_file"  --delete-after --force "$sshsourcecred""${srcpath[$i]}" "${sshdestcred[$i]}""${destpath[$i]}"`
          nbfiles_synced=`echo $rsyncexec | grep transferred | cut -d " " -f9`
            total_files_synced=$(( nbfiles_synced + total_files_synced ))
            done
       ( writelogandrotate $total_files_synced" fichiers transférés" )
        msg=$total_files_synced
    else
        ( writelogandrotate "Execution de la sauvegarde incrementielle" )
        for (( i = 0 ; i < ${#srcpath[@]} ; i++ ))
            do
            ( writelogandrotate "Démarrage du script de sauvegarde incrémentielle de ${srcpath[$i]} vers ${destpath[$i]}" )
            rsyncexec=`rsync $sshcmd -a --stats --filter="merge $filter_file" --backup --suffix=_"$today" "$sshsourcecred""${srcpath[$i]}" "$sshdestcred""${destpath[$i]}"`
            nbfiles_synced=`echo $rsyncexec | grep transferred | cut -d " " -f9`
            total_files_synced=$(( nbfiles_synced + total_files_synced ))
            done
        ( writelogandrotate $total_files_synced" fichiers transférés" )
        msg=$total_files_synced
        #clean day_to_conserve+1 days backup - if backup destination is not SSH
       if [ "$sshdestbackup" = "0" ] ; then
          ( writelogandrotate "Nettoyage des fichiers datés de  $day_to_conserve +1 jours - Uniquement si destination non SSH !" )
          find $destpath -name *_`date --date=$day_to_conserve' days ago' +%F` -exec rm -rf {} \;
       fi
    fi

    ( writelogandrotate "Fin du script" )
    #end

# Sans le HDD connecté en permanence

Posté par JGO le 09 mars 2014 à 18:44. Évalué à 4. Dernière modification le 09 mars 2014 à 18:47.

sans mon HDD de backup connecté en permanence

Heureusement ! Ne le connecte que pour faire une sauvegarde (ou pour la récupérer) et garde-le entre temps en lieu sûr et loin du disque principal (p.ex. au travail ou dans un appartement différent). Un accident ou un vol ne doivent pas pouvoir affecter simultanément ton disque principal et sa sauvegarde (en dehors du moment de la réalisation de la sauvegarde).
- [^] # Re: Sans le HDD connecté en permanence
  
  Posté par Xinfe (site web personnel) le 10 mars 2014 à 10:59. Évalué à 1.
  
  C'est effectivement un bon conseil. En écrivant ça, je voulais dire qu'il n'est pas accessible en permanence comme peut l'être un disque réseau (ou un serveur plus classique).
# Éventuellement backintime

Posté par lolop (site web personnel) le 10 mars 2014 à 12:48. Évalué à 3.

Une surcouche graphique aux outils standards, qui te rapprocheras du Time Machine.

http://backintime.le-web.org/

Perso j'utilisais, en ligne de commande, snapy (de William Dodé) qui est une surcouche à rsync - mais le lien tombe en 404 pour le moment: http://www.flibuste.net/libre/snapy

Python 3 - Apprendre à programmer dans l'écosystème Python → https://www.dunod.com/EAN/9782100809141

Suivre le flux des commentaires

Note : les commentaires appartiennent à celles et ceux qui les ont postés. Nous n’en sommes pas responsables.