Tutoriel : archivage et compression avec dar

From CC Doc
Jump to: navigation, search
This page is a translated version of the page Dar and the translation is 100% complete.

Other languages:
English • ‎français

Page enfant de: Stockage et gestion de fichiers

L’utilitaire open source dar (pour Disk ARchive) a été conçu pour remplacer l’outil Unix tar et peut être compilé par tout système de type Unix. Il est activement maintenu depuis son lancement en 2002.

Comme tar, il permet les types de sauvegarde complète, différentielle et incrémentale. Cependant, l’accès aux fichiers et la restauration des données se font plus rapidement qu’avec tar puisque chacune des archives contient un index des fichiers; ceci est un grand avantage pour les archives volumineuses. L’utilitaire dar compresse chacun des fichiers séparément, ce qui offre plus de résilience dans les cas de corruption de données; il est en outre possible d’éviter la compression de fichiers fortement compressés comme les mp4 ou gz. Parmi ses nombreuses fonctionnalités utiles, on trouve le chiffrement robuste; le découpage d’une archive en tranches pouvant aller jusqu’à un octet; la gestion d’attributs étendus, de fichiers épars, de liens physiques et symboliques; la détection de corruption de données dans les deux fichiers d’en-tête et leur récupération avec un minimum de perte. Pour plus d’information, consultez la page web et la comparaison avec tar.

Où trouver l’utilitaire

Puisque dar peut être compilé en ligne de commande, vous pouvez facilement l’installer sur Linux et MacOS. Une version se trouve dans /cvmfs :

[user_name@localhost]$ which dar
/cvmfs/soft.computecanada.ca/nix/var/nix/profiles/16.09/bin/dar
[user_name@localhost]$ dar --version
dar version 2.5.3, Copyright (C) 2002-2052 Denis Corbin
...

Une version plus récente doit être compilée à partir du code source (remplacez 2.6.3 par le numéro de la plus récente version) :

[user_name@localhost]$ wget https://sourceforge.net/projects/dar/files/dar/2.6.3/dar-2.6.3.tar.gz
[user_name@localhost]$ tar xvfz dar-*.gz && /bin/rm -f dar-*.gz
[user_name@localhost]$ cd dar-*
[user_name@localhost]$ ./configure --prefix=$HOME/dar --disable-shared
[user_name@localhost]$ make
[user_name@localhost]$ make install-strip
[user_name@localhost]$ $HOME/dar/bin/dar --version

Utilisation manuelle

Archivage de base et extraction

Supposons le sous-répertoire test dans le répertoire courant. Pour en faire une archive, vous pouvez entrer la commande suivante dans le répertoire courant.

[user_name@localhost]$ dar -w -c all -g test

Le fichier archive all.1.dar est créé, où all est le nom de base et 1 est le numéro de la tranche. Une archive peut être divisée en plusieurs tranches. Plusieurs répertoires et fichiers peuvent être inclus dans une archive, par exemple

[user_name@localhost]$ dar -w -c all -g testDir1 -g testDir2 -g file1 -g file2

Notez que tous les chemins doivent être reliés au répertoire courant.

Pour lister le contenu d’une archive, utilisez uniquement le nom de base.

[user_name@localhost]$ dar -l all

Pour extraire un fichier dans un sous-répertoire restore, utilisez le nom de base et le chemin du fichier.

[user_name@localhost]$ dar -R restore/ -O -w -x all -v -g test/filename

L’indicateur -O permet de faire abstraction de la propriété des fichiers. Si vous restaurez les fichiers d’une autre personne sans être administrateur (root), une mauvaise attribution de propriété pourrait causer un problème. Si vous restaurez vos propres fichiers, un message sera émis si vous n’êtes pas administrateur et vous demandera de confirmer l’opération. Pour ne pas recevoir ce message, utilisez l’indicateur -O. Si restore/test existe, l’indicateur -w désactive l’avertissement.

Pour extraire un répertoire entier, utilisez

[user_name@localhost]$ dar -R restore/ -O -w -x all -v -g test

De la même manière qu’une archive est créée, vous pouvez passer plusieurs répertoires et fichiers avec plusieurs indicateurs -g. Remarquez que dar n’accepte pas les masques inverses (wildcard masks) Unix après -g.

Sauvegarde incrémentale

Pour créer une sauvegarde différentielle et incrémentale, joignez à -A le nom de base de l’archive référencée. Prenons l’exemple d’une sauvegarde complète nommée Monday que vous créez le lundi.

[user_name@localhost]$ dar -w -c monday -g test

Le mardi, certains des fichiers sont modifiés et seuls ceux-ci sont inclus dans une nouvelle sauvegarde incrémentale nommée tuesday, avec monday comme archive de référence.

[user_name@localhost]$ dar -w -A monday -c tuesday -g test

Le mercredi, d’autres fichiers sont modifiés et une nouvelle sauvegarde est créée nommée wednesday, avec tuesday comme archive de référence.

[user_name@localhost]$ dar -w -A tuesday -c wednesday -g test

Il y a maintenant trois fichiers :

[user_name@localhost]$ ls *.dar
monday.1.dar     tuesday.1.dar    wednesday.1.dar

Le fichier wednesday.1.dar contient uniquement les fichiers modifiés le mercredi, mais pas les fichiers de lundi ou mardi. La commande

[user_name@localhost]$ dar -R restore -O -x wednesday

ne restaurera que les fichiers modifiés le mercredi. Pour restaurer tous les fichiers, vous devrez passer par toutes les sauvegardes en ordre chronologique.

[user_name@localhost]$ dar -R restore -O -w -x monday      # restore the full backup
[user_name@localhost]$ dar -R restore -O -w -x tuesday     # restore the first incremental backup
[user_name@localhost]$ dar -R restore -O -w -x wednesday   # restore the second incremental backup

Limiter la taille des tranches

Pour fixer la taille maximale en octets de chaque tranche, utilisez l’indicateur -s suivi d’un nombre et d’une unité de mesure (k, M, G ou T). Par exemple, pour une archive de 1340Mo, la commande

[user_name@localhost]$ dar -s 100M -w -c monday -g test

crée 14 tranches nommées monday.{1..14}.dar. Pour extraire de toutes ces tranches, utilisez le nom de base.

[user_name@localhost]$ dar -O -x monday

Utilisation à l’aide de fonctions

Il serait beaucoup plus facile d’utiliser dar s’il n’était pas nécessaire de mémoriser et de spécifier tous les indicateurs et d’avoir une bonne syntaxe en ligne de commande. Nous discutons ici de plusieurs fonctions Bash qui facilitent les opérations de sauvegarde, en supposant que votre quota n’est pas atteint. Vous devez vous assurer que vous possédez les permissions de lecture et d’écriture et que dar archive et restaure correctement vos fichiers avant de supprimer les originaux. N’oubliez pas d’effectuer les tests de mise avant d’utiliser ces fonctions.

Limiter la quantité de fichiers dans les tranches avec multidar

Collez la fonction multidar dans votre interpréteur ou sauvegardez cette définition dans votre fichier $HOME/.bashrc, puis activez-la avec source ~/.bashrc.

function multidar() {
    if ! [ $# = 2 ]; then
	echo Usage: multidar sourceDirectory maxNumberOfFilesPerArchive
    else
	sourceDirectory=$1
	maxNumberOfFilesPerArchive=$2
	if which dar 2>/dev/null; then
	    echo great, I found dar at $(which dar)
	    find $sourceDirectory -type f > .fullList
	    sed -i -e '/DS_Store/d' .fullList
	    sed -i -e 's/\/\//\//' .fullList
	    split -a 3 -l $maxNumberOfFilesPerArchive .fullList .partial
	    for i in .partial*; do
		echo archiving from $i to ${sourceDirectory%?}-${i:8:3}
		dar -w -c ${sourceDirectory%?}-${i:8:3} --include-from-file $i
 		/bin/rm -rf $i
 	    done
 	    /bin/rm -rf .fullList*
	    ls -lh ${sourceDirectory%?}*.dar
	else
	    echo please install dar
	fi
    fi
}

En exécutant la commande sans arguments, vous pourrez voir la syntaxe.

[user_name@localhost]$ multidar
Usage: multidar sourceDirectory maxNumberOfFilesPerArchive

Supposons que test contient 1000 fichiers; en exécutant la commande

[user_name@localhost]$ multidar test 300

quatre archives seront produites avec chacune leur nom de base et contenant chacune un maximum de 300 fichiers. Pour restaurer le contenu de ces archives, utilisez une boucle Bash.

[user_name@localhost]$ for f in test-aa{a..d}
                       do
                         dar -R restore/ -O -w -x $f
                       done

Sauvegarde

Supposons la fonction

function backup() {
    BREF='/home/username/tmp'
    BSRC='-g test'   # cannot use an absolute path
    BDEST=/home/username/tmp/backups
    BTAG=all
    FLAGS=(-s 5G -zbzip2 -asecu -w -X "*~" -X "*.o")   # bash array with some flags
    #FLAGS+=(-K aes:)   # add encryption
    if [ $# == 0 ]; then
	echo missing argument ... need to be one of: show 0 1 2 3 .. 98 99
    elif [ $1 == 'show' ]; then
	ls -lhtr $BDEST/"$BTAG"*
    elif [ $1 == '0' ]; then
	echo backing up $BSRC to $BDEST
	dar "${FLAGS[@]}" -c $BDEST/"$BTAG"0 -R $BREF $BSRC
	/bin/rm -rf $BDEST/"$BTAG"{1..100}.*.dar; ls -lhtr $BDEST/"$BTAG"*
    else
	level=$1
	if [ -n "$level" ] && [ "$level" -eq "$level" ] 2>/dev/null; then   # check if it is a number
	    echo backing up $BSRC to $BDEST
  	    dar "${FLAGS[@]}" -A $BDEST/"$BTAG"$((level-1)) -c $BDEST/"$BTAG"$level -R $BREF $BSRC
	    for i in $(seq $((level+1)) 100); do
		/bin/rm -rf $BDEST/"$BTAG"$i.*.dar
	    done
 	    ls -lhtr $BDEST/"$BTAG"*
	else
	    echo $level is not a number ...; return 1
	fi
    fi
}

Vous devez définir les quatre variables au début, soit

  • BREF pour stocker le chemin absolu du répertoire parent où se trouvent tous les sous-répertoires et fichiers à archiver;
  • BSRC pour stocker dans BREF une liste relative de tous les sous-répertoires et fichiers à archiver (BSRC ne peut pas être un chemin absolu);
  • BDEST pour identifier la destination;
  • BTAG pour obtenir la racine du nom de base.

Pour créer la sauvegarde complète de all0.*.dar, entrez

[user_name@localhost]$ backup 0

Pour créer la première sauvegarde incrémentale all1.*.dar, entrez

[user_name@localhost]$ backup 1

Pour créer la deuxième sauvegarde incrémentale all2.*.dar, entrez

[user_name@localhost]$ backup 2

et ainsi de suite. Pour voir toutes les sauvegardes, entrez

[user_name@localhost]$ backup show

Si le contenu excède 5Go, plus d’une tranche sera créée.

Si les sauvegardes incrémentales sont trop nombreuses, vous pouvez créer une sauvegarde avec moins d’incréments. Par exemple, la commande

[user_name@localhost]$ backup 1

écrasera la première sauvegarde incrémentale et supprimera celles portant un numéro plus élevé.

Restauration d’une sauvegarde

Supposons la fonction

function restore() {
    BSRC=/home/username/tmp/backups
    BTAG=all
    BDEST=/home/username/tmp/restore
    if [ $# == 0 ]; then
	echo Examples:
	echo '   'restore -l anyPattern
	echo '   'restore -x Pictures/1995
	echo '   'restore -x Documents/notes
	echo '   'restore -x Documents/notes/quantum.txt
	echo '   'restore -n 0 Documents/misc/someFile.txt
	echo 'Notes: (1)' restore -x/-n does not understand Unix wildmasks, so need to specify full directory or file name
	echo '       (2)' always specify one name per command
	echo '       (3)' restore will put the restored files into \$BDEST
    elif [ $1 == '-l' ]; then
	echo Listing all versions
	for file in $BSRC/"$BTAG"{0..99}; do
	    if [ -f $file.1.dar ]; then
       		echo --- in $file:
		dar -l $file | grep $2
	    fi
	done
    elif [ $1 == '-x' ]; then
	echo Restoring from the earliest version:
	echo '  'important to go through all previous backups if restoring a directory or a sparsebundle
	echo '  'or if the most recent version of the file is stored in an earlier backup
	for file in $BSRC/"$BTAG"{0..99}; do
	    if [ -f $file.1.dar ]; then
       		echo --- from $file:
		dar -R $BDEST -O -w -x $file -v -g $2
	    fi
	done
    elif [ $1 == '-n' ]; then
	echo Be careful with restoring from a single layer: might not work as naively expected
	echo Restoring from version $2
	dar -R $BDEST -O -w -x $BSRC/"$BTAG"$2 -v -g $3
    else
	echo unrecognized option ...
    fi
}

Comme précédemment, il faut définir les variables du début :

  • BSRC pour le répertoire de sauvegarde;
  • BTAG pour la racine du nom de base;
  • BDEST pour le répertoire à utiliser pour la restauration.

Pour trouver le fichier test999, utilisez

[user_name@localhost]$ restore -l test999

La recherche se fait sur la sauvegarde complète et sur toutes les sauvegardes incrémentales. Pour extraire ce fichier, indiquez son numéro de sauvegarde et le chemin complet tel qu’inscrit dans l’archive, par exemple

[user_name@localhost]$ restore -n 2 test/test999

Cependant, il est possible que le fichier ne soit pas restauré puisque la commande ne restaure que si le fichier a été modifié entre les sauvegardes 1 et 2 pour paraître dans la sauvegarde 2. Deux options assurent une restauration certaine; la première est de restaurer à partir de la sauvegarde complète et ensuite à partir des sauvegardes incrémentales, en ordre chronologique comme suit :

[user_name@localhost]$ restore -n 0 test/test999
[user_name@localhost]$ restore -n 1 test/test999
[user_name@localhost]$ restore -n 2 test/test999
...

La seconde option est d’utiliser l’indicateur -x ainsi

[user_name@localhost]$ restore -x test/test999

Cette commande parcourt automatiquement toutes les sauvegardes dans le bon ordre. Pour restaurer le répertoire complet, entrez

[user_name@localhost]$ restore -x test

Remarquez que restore n’accepte pas les masques inverses (wildcard masks).

Chiffrement symétrique

Pour chiffrer la sauvegarde, dans la fonction de sauvegarde backup() , supprimez la marque de commentaire pour la ligne

#FLAGS+=(-K aes:)   # add encryption

Vous devrez fournir et confirmer le mot de passe pour chacune des sauvegardes et le mot de passe pour la sauvegarde de référence. Pour restaurer les sauvegardes, vous devez fournir le mot de passe pour chacune.