web-dev-qa-db-fra.com

Comment créer et restaurer des instantanés incrémentiels d'un disque dur

J'utilise beaucoup Virtual Box pour tester la distribution et les applications.

L’une des fonctionnalités que j’aime tout simplement est celle des instantanés de machines virtuelles. Elle enregistre l’état d’une machine virtuelle et peut la restaurer à son ancienne gloire si quelque chose vous échappait sans aucun problème et sans utiliser tout votre espace disque.

Sur mes systèmes en direct, je sais comment créer une image 1: 1 du système de fichiers, mais toutes les solutions que je connais créeront une nouvelle image du système de fichiers complet.

Existe-t-il des programmes/systèmes de fichiers capables de prendre un instantané d'un système de fichiers actuel, de l'enregistrer dans un autre emplacement, mais au lieu de créer une nouvelle image complète, il crée des sauvegardes incrémentielles?

Pour décrire facilement ce que je veux, il devrait s'agir d'images dd d'un système de fichiers, mais au lieu d'une sauvegarde complète, cela créerait également des données incrémentielles.

Je ne cherche pas Clonezilla, etc. Il devrait fonctionner dans le système lui-même sans aucune intervention (ou presque aucune) de l'utilisateur, mais contenir toutes les données des systèmes de fichiers. Je ne cherche pas non plus une sauvegarde de duplicity de votre système tout en excluant certains dossiers. Script + dd pour enregistrer votre répertoire de travail. Je peux le faire moi-même, à la recherche d'une finesse supplémentaire.

Je cherche quelque chose que je puisse faire avant d'apporter des modifications massives à un système. Si quelque chose ne va pas ou si je brûle mon disque dur après en avoir renversé le café, je peux simplement démarrer à partir d'un liveCD et restaurer un instantané qui fonctionne sur un disque dur.

Il n'a pas besoin d'être quotidien, il n'a même pas besoin d'un horaire. Il suffit d’exécuter de temps en temps et de laisser son travail et, de préférence, le format RAW basé sur la copie de fichier.

filesystembackup
13
Bruno Pereira

Pour expliquer la réponse de cprofitt (car sa réponse est incrémentale, comme je l'expliquerai) ...

Vous devez d’abord connaître les liens physiques.

Les liens physiques pointent vers les données qui se trouvent réellement sur le disque (emplacement physique) et vous pouvez accéder aux données à l'aide du lien physique. Chaque fichier et répertoire est un lien physique vers l'emplacement des données sur le disque physique. Par conséquent, s'il existe deux fichiers (liens physiques) pointant vers le même emplacement, les données ne sont stockées qu'une seule fois .

Le processus donné par cprofitt implique:

  1. Faites pivoter les sauvegardes pour créer un emplacement pour un nouveau. ("La sauvegarde d'aujourd'hui" d'hier devient "La sauvegarde d'hier", "La sauvegarde d'hier" d'il y a deux jours devient "La sauvegarde d'il y a deux jours" et ainsi de suite)

    • La liste ne cesse de s'allonger aussi longtemps que vous le souhaitez, mais dans le script, elle ne contient que 4 instantanés. (Il refait tout le processus pour le niveau suivant (par exemple, une semaine - "Sauvegarde de cette semaine") et les fait pivoter, c'est pourquoi il n'en a que 4).
    • Le déplacement se fait en sens inverse pour éviter tout écrasement

  2. Copiez le dernier instantané que vous avez effectué (par exemple, "Sauvegarde d'hier") à l'emplacement du nouvel instantané (par exemple, "Sauvegarde d'aujourd'hui"), en créant de nouveaux liens fixes vers les fichiers existants sans copier le fichier. Ainsi, tous les fichiers du nouvel instantané sont pointant vers le même emplacement que le précédent .

Un exemple illustré

Dans l'image ci-dessous, les fichiers de la même couleur portant le même nom sont des liens physiques vers le même fichier sur le disque. Nous ne traitons ici que de deux instantanés et de quelques fichiers, mais l’exemple est à l’échelle. (Sauf que je déplace les instantanés dans le sens contraire des scripts dans la réponse de cproffit)

enter image description here

Le processus est le suivant:

  1. Il y a un instantané du système.

  2. La capture instantanée est une copie (création de liens physiques vers les fichiers existants)

  3. Rsync est exécuté pour mettre à jour l'instantané. Lorsque les fichiers sont modifiés, le nouveau fichier est stocké en tant que nouvelle copie sur le disque dur (l’instantané le plus ancien n’est donc pas modifié). Dans cet exemple, le fichier B a été modifié. Remarque: nous n'avons plus qu'une copie du fichier A et du fichier C et deux copies du fichier B stockées sur le disque dur.

  4. Faire pivoter les instantanés (dans ce cas, l'instantané 0 'tombe et est supprimé et je renomme l'instantané 1 en instantané 0)

  5. Copiez le cliché instantané (répétez l’étape 2)

  6. Rsync encore. (Répétez l'étape 3). Maintenant nous avons 1 copie du fichier A et 2 copies du fichier B et du fichier C

Une version simplifiée du [premier] script (à ne pas exécuter, comme un tremplin) est la suivante:

#!/bin/bash

# Delete the snapshot we don't want (has 'fallen off')
rm -rf /root/snapshot/home/hourly.3 ;

# Rotate the snapshots by shuffling them back
mv /root/snapshot/home/hourly.2 /root/snapshot/home/hourly.3 ;
mv /root/snapshot/home/hourly.1 /root/snapshot/home/hourly.2 ;

# Copy the snapshot (creating hard links to the existing files)
cp -al /root/snapshot/home/hourly.0 /root/snapshot/home/hourly.1 ;

# Do the rsync ...
# step 4: rsync from the system into the latest snapshot (notice that
# rsync behaves like cp --remove-destination by default, so the destination
# is unlinked first.  If it were not so, this would copy over the other
# snapshot(s) too!
rsync -va --delete /home/ /root/snapshot/home/hourly.0 ;

Maintenant le script complet (s) a l'explication complète ici (comme cprofitt lié à) et il est plus complet mais c'est fondamentalement comme ci-dessus. L'autre script permet de regrouper des instantanés et l'autre partie de la réponse de cprofitt explique comment rendre le processus automatique (à l'aide de cron) et vérifier que la sauvegarde a réussi.

Vous pouvez modifier les noms. Ainsi, au lieu que les répertoires soient appelés "toutes les heures ...", ils sont appelés autre chose et le script est exécuté manuellement.

Pour restaurer l'intégralité du lot, copiez le dernier instantané (ou un précédent) dans le répertoire dans lequel vous effectuiez les sauvegardes.

Pour restaurer un seul fichier qui est toujours dans un instantané, allez-y et copiez-le à l'endroit où il se trouve.

Le support de sauvegarde peut être un disque dur externe (doit être ext2/ext3/ext4). Si vous sauvegardiez / (principalement /boot, /home, /etc/root et /usr), alors, dites ...

  1. Vous montez le lecteur externe, effectuez la sauvegarde et créez le dernier instantané.

  2. Démontez le lecteur.

  3. Rappelez-vous que vous avez supprimé un fichier (même de la corbeille) que vous vouliez.

  4. Connectez le lecteur externe et récupérez le fichier.

  5. Faites une sauvegarde (juste pour être sûr)

  6. Déconnectez le lecteur et partez en voyage ...

  7. Sachez qu'un ordinateur portable et de la lave ne se mélangent pas.

  8. Avec votre nouvel ordinateur portable exécutant un cd en direct, formatez le lecteur interne, montez votre lecteur externe, puis cp -a /media/external/snapshot-0/* /media/internal-drive (en supposant que snapshot-0 est le dernier instantané).

  9. Installez grub sur le MBR (oui, il faut que ce soit séparé) - ou utilisez dd pour sauvegarder le membre, comme cprofitt l’a dit au bas de sa réponse.

  10. Redémarrer.

Le script doit être affiné (pour n’obtenir que ce que vous voulez) et la procédure ci-dessus suppose que vous n’avez pas de partition /home. Si vous en avez (ou en avez) créé un nouveau sur le disque et montez-le à la place avec mount /dev/sdxy /media/external/home avant de le copier.

14
Portablejim

Vous pouvez utiliser rsync.

Listing one: make_snapshot.sh

#!/bin/bash
# ----------------------------------------------------------------------
# mikes handy rotating-filesystem-snapshot utility
# ----------------------------------------------------------------------
# this needs to be a lot more general, but the basic idea is it makes
# rotating backup-snapshots of /home whenever called
# ----------------------------------------------------------------------

unset PATH  # suggestion from H. Milz: avoid accidental use of $PATH

# ------------- system commands used by this script --------------------
ID=/usr/bin/id;
ECHO=/bin/echo;

MOUNT=/bin/mount;
RM=/bin/rm;
MV=/bin/mv;
CP=/bin/cp;
TOUCH=/bin/touch;

RSYNC=/usr/bin/rsync;


# ------------- file locations -----------------------------------------

MOUNT_DEVICE=/dev/hdb1;
SNAPSHOT_RW=/root/snapshot;
EXCLUDES=/usr/local/etc/backup_exclude;


# ------------- the script itself --------------------------------------

# make sure we're running as root
if (( `$ID -u` != 0 )); then { $ECHO "Sorry, must be root.  Exiting..."; exit; } fi

# attempt to remount the RW mount point as RW; else abort
$MOUNT -o remount,rw $MOUNT_DEVICE $SNAPSHOT_RW ;
if (( $? )); then
{
    $ECHO "snapshot: could not remount $SNAPSHOT_RW readwrite";
    exit;
}
fi;


# rotating snapshots of /home (fixme: this should be more general)

# step 1: delete the oldest snapshot, if it exists:
if [ -d $SNAPSHOT_RW/home/hourly.3 ] ; then         \
$RM -rf $SNAPSHOT_RW/home/hourly.3 ;                \
fi ;

# step 2: shift the middle snapshots(s) back by one, if they exist
if [ -d $SNAPSHOT_RW/home/hourly.2 ] ; then         \
$MV $SNAPSHOT_RW/home/hourly.2 $SNAPSHOT_RW/home/hourly.3 ; \
fi;
if [ -d $SNAPSHOT_RW/home/hourly.1 ] ; then         \
$MV $SNAPSHOT_RW/home/hourly.1 $SNAPSHOT_RW/home/hourly.2 ; \
fi;

# step 3: make a hard-link-only (except for dirs) copy of the latest snapshot,
# if that exists
if [ -d $SNAPSHOT_RW/home/hourly.0 ] ; then         \
$CP -al $SNAPSHOT_RW/home/hourly.0 $SNAPSHOT_RW/home/hourly.1 ; \
fi;

# step 4: rsync from the system into the latest snapshot (notice that
# rsync behaves like cp --remove-destination by default, so the destination
# is unlinked first.  If it were not so, this would copy over the other
# snapshot(s) too!
$RSYNC                              \
    -va --delete --delete-excluded              \
    --exclude-from="$EXCLUDES"              \
    /home/ $SNAPSHOT_RW/home/hourly.0 ;

# step 5: update the mtime of hourly.0 to reflect the snapshot time
$TOUCH $SNAPSHOT_RW/home/hourly.0 ;

# and thats it for home.

# now remount the RW snapshot mountpoint as readonly

$MOUNT -o remount,ro $MOUNT_DEVICE $SNAPSHOT_RW ;
if (( $? )); then
{
    $ECHO "snapshot: could not remount $SNAPSHOT_RW readonly";
    exit;
} fi;

et le deuxième:

Listing two: daily_snapshot_rotate.sh

#!/bin/bash
# ----------------------------------------------------------------------
# mikes handy rotating-filesystem-snapshot utility: daily snapshots
# ----------------------------------------------------------------------
# intended to be run daily as a cron job when hourly.3 contains the
# midnight (or whenever you want) snapshot; say, 13:00 for 4-hour snapshots.
# ----------------------------------------------------------------------

unset PATH

# ------------- system commands used by this script --------------------
ID=/usr/bin/id;
ECHO=/bin/echo;

MOUNT=/bin/mount;
RM=/bin/rm;
MV=/bin/mv;
CP=/bin/cp;

# ------------- file locations -----------------------------------------

MOUNT_DEVICE=/dev/hdb1;
SNAPSHOT_RW=/root/snapshot;

# ------------- the script itself --------------------------------------

# make sure we're running as root
if (( `$ID -u` != 0 )); then { $ECHO "Sorry, must be root.  Exiting..."; exit; } fi

# attempt to remount the RW mount point as RW; else abort
$MOUNT -o remount,rw $MOUNT_DEVICE $SNAPSHOT_RW ;
if (( $? )); then
{
    $ECHO "snapshot: could not remount $SNAPSHOT_RW readwrite";
    exit;
}
fi;


# step 1: delete the oldest snapshot, if it exists:
if [ -d $SNAPSHOT_RW/home/daily.2 ] ; then          \
$RM -rf $SNAPSHOT_RW/home/daily.2 ;             \
fi ;

# step 2: shift the middle snapshots(s) back by one, if they exist
if [ -d $SNAPSHOT_RW/home/daily.1 ] ; then          \
$MV $SNAPSHOT_RW/home/daily.1 $SNAPSHOT_RW/home/daily.2 ;   \
fi;
if [ -d $SNAPSHOT_RW/home/daily.0 ] ; then          \
$MV $SNAPSHOT_RW/home/daily.0 $SNAPSHOT_RW/home/daily.1;    \
fi;

# step 3: make a hard-link-only (except for dirs) copy of
# hourly.3, assuming that exists, into daily.0
if [ -d $SNAPSHOT_RW/home/hourly.3 ] ; then         \
$CP -al $SNAPSHOT_RW/home/hourly.3 $SNAPSHOT_RW/home/daily.0 ;  \
fi;

# note: do *not* update the mtime of daily.0; it will reflect
# when hourly.3 was made, which should be correct.

# now remount the RW snapshot mountpoint as readonly

$MOUNT -o remount,ro $MOUNT_DEVICE $SNAPSHOT_RW ;
if (( $? )); then
{
    $ECHO "snapshot: could not remount $SNAPSHOT_RW readonly";
    exit;
} fi;

Après avoir créé le script selon vos besoins, ajoutez-le aux tâches cron.

crontab -e

ajoutez ce qui suit:

0 */4 * * * /usr/local/bin/make_snapshot.sh

0 13 * * * /usr/local/bin/daily_snapshot_rotate.sh

Make_snapshot.sh est exécuté toutes les quatre heures et daily_snapshot_rotate.sh tous les jours à 13h00 (c'est-à-dire à 13h00).

source: http://www.mikerubel.org/computers/rsync_snapshots/

* * * * * command to be executed
- - - - -
| | | | |
| | | | ----- Day of week (0 - 7) (Sunday=0 or 7)
| | | ------- Month (1 - 12)
| | --------- Day of month (1 - 31)
| ----------- Hour (0 - 23)
------------- Minute (0 - 59)

Si vous voulez qu'il fonctionne toutes les heures, vous devez ajouter un travail cron pour chaque heure.

Une autre option possible consiste à utiliser rsnapshot

  1. Installez rsnapshot (disponible dans le centre logiciel)

  2. Configurer rsnapshot et spécifier le répertoire source de sauvegarde

Ouvrez le fichier /etc/rsnapshot.conf et décommentez les lignes suivantes.

# nano /etc/rsnapshot.conf

cmd_cp          /bin/cp
cmd_ssh /usr/bin/ssh
cmd_du          /usr/bin/du
cmd_rsnapshot_diff      /usr/local/bin/rsnapshot-diff
logfile /var/log/rsnapshot

  1. Définissez vos répertoires de sauvegarde de destination dans /etc/rsnapshot.conf comme indiqué ci-dessous. Dans cet exemple,

    / home - répertoire source à sauvegarder localhost/- répertoire de destination où la sauvegarde sera stockée. Veuillez noter que ce répertoire sera créé dans le répertoire /.snapshots/{internal.n}/, comme indiqué à la dernière étape.

    nano /etc/rsnapshot.conf

    sauvegarde/home/localhost /

  2. Testez la configuration de rsnapshot

Effectuez un test de configuration pour vous assurer que rsnapshot est correctement configuré et prêt à effectuer une sauvegarde linux rsync.

# rsnapshot configtest
Syntax OK
  1. Vérifier la configuration de sauvegarde horaire de rsnapshot

Vous pouvez sauvegarder des répertoires ou des fichiers linux à différents intervalles. Par défaut, les sauvegardes horaires et quotidiennes sont configurées.

Vérifiez la configuration de sauvegarde horaire.

# rsnapshot -t hourly
echo 6490 > /var/run/rsnapshot.pid
mkdir -m 0700 -p /.snapshots/
mkdir -m 0755 -p /.snapshots/hourly.0/
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded /home \
/.snapshots/hourly.0/localhost/
mkdir -m 0755 -p /.snapshots/hourly.0/
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded /etc \
/.snapshots/hourly.0/localhost/
mkdir -m 0755 -p /.snapshots/hourly.0/
/usr/bin/rsync -a --delete --numeric-ids --relative --delete-excluded \
/usr/local /.snapshots/hourly.0/localhost/
touch /.snapshots/hourly.0/
  1. Vérifier la configuration de la sauvegarde quotidienne de rsnapshot

Vérifiez que le processus de sauvegarde quotidien de rsnapshot cwrsync est configuré correctement.

# rsnapshot -t daily
echo 6493 > /var/run/rsnapshot.pid
mkdir -m 0700 -p /.snapshots/
/.snapshots/hourly.5 not present (yet), nothing to copy
  1. Ajouter une entrée Crontab pour rsnapshot

Une fois que vous avez vérifié que les configurations de sauvegarde horaire et quotidienne de rsync sont correctement configurées dans l'utilitaire rsnapshot cwrsync, il est temps de configurer ce chiot dans la crontab, comme indiqué ci-dessous.

# crontab -e
0 */4 * * * /usr/local/bin/rsnapshot hourly
30 23 * * * /usr/local/bin/rsnapshot daily

source: http://www.thegeekstuff.com/2009/08/tutorial-backup-linux-using-rsnapshot-rsync-utility/

---- Récupération de métal nu

Je voudrais utiliser dd et tar pour faire la récupération de baremetal.

Sauvegardez les métadonnées importantes:

# dd if-/dev/hda of=/backups/mbr bs=512 count=1

Sauvegardez le système d'exploitation:

# mkdir /backups
# mount nfsserver:/backups/<servername> /backups


# cd /
# tar cfz /backups/system.tar.gz --exclude /mnt --exclude /proc --exclude /backups

Personnellement, j’aurais tendance à mettre mon système hors ligne si je souhaitais créer un fichier de restauration Baremetal.

7
cprofitt

Vous devriez jeter un oeil à ddar ( homepage ).

Il est incrémental en ce sens qu'il ne transfère pas les parties identiques de l'instantané. Ce n'est pas incrémental dans le sens classique du mot, car il s'agit d'instantanés.

Remarque: Je n'ai pas essayé cela moi-même (mais je fais confiance à l'auteur). Il se peut que vous ne réalisiez pas ce que vous souhaitez réaliser directement, mais que des solutions similaires existent sur la page (par exemple. ZFS), donc comme point de départ, cela pourrait éventuellement s'avérer utile.

3
lgarzo

Il y a 2 façons de faire une sauvegarde incrémentielle par bloc

  • Instantanés basés sur le système de fichiers
  • Instantanés basés sur le programme

Instantanés basés sur le système de fichiers

ZFS et BTRFS fournissent des instantanés incrémentiels basés sur des blocs ( BTRFS , ZFS (page 25) =). Vous pouvez avoir un lecteur sur lequel vous rsync soit ZFS ou BTRFS et un instantané.

Il existe également instantanés LVM (mentionné par cprofitt) qui fournit les mêmes instantanés incrémentiels basés sur des blocs.

Instantanés basés sur le programme

Il existe un plusieurs programmes de sauvegarde , mais quelques-uns se distinguent à cette fin:

Je sais que vous avez spécifiquement mentionné que vous ne cherchiez pas quelque chose comme la duplicité, mais j’ai pensé pouvoir mentionner certaines caractéristiques.

Cependant, ces programmes nécessitent que vous les installiez pour les restaurer. La beauté de quelque chose comme rsync réside dans le fait que presque toutes les installations de Linux ont rsync (par exemple, un cœur minuscule (une distribution de 10 Mo) le manque) par défaut.

Duplicité

Il stocke simplement le diff (niveau du bloc), puis le compresse et le chiffre. Cela conduit à encore moins de stockage que la méthode rsync, cependant (du moins tel que je le vois) le système de fichiers devra être reconstruit, ce qui prendra du temps (si vous utilisez des sauvegardes incrémentielles, et cela dépend du temps écoulé depuis. dernière sauvegarde complète)

Le page de manuel explique comment cela fonctionne.

Rdiff-sauvegarde

Un programme client-serveur qui crée, comme la duplicité, des différences de niveau de bloc, mais stocke les modifications depuis le dernier point de restauration, de sorte que le dernier instantané est le plus rapide à restaurer. Pour remonter dans le temps (pas le dernier instantané), il faut analyser plus de différences, ce qui est plus lent.

Certaines personnes comparez rdiff-backup à rsnapshot (cela semble être une méthode plus automatique du mode rsync). Presque tous les comment-faire se concentrent sur l’utilisation de rdiff sur le réseau, mais j’en ai trouvé un qui mentionne comment le faire sur localhost .

3
Portablejim

Celui-ci me dépasse un peu, mais il semble qu'une partie de ce que vous souhaitiez faire consiste à effectuer des sauvegardes partielles de fichiers binaires (comme des fichiers image de partition). Il y a un paquet conçu pour faire ça (je viens de lire à ce sujet - je ne l'ai pas essayé.)

Regardez bup.

https://github.com/apenwarr/bup

Cela pourrait vous donner quelques idées.

1
Joe

Je pense que vous pouvez faire cela avec LVM, son seul théorique, et cela gaspillera une quantité considérable de disque dur. Ma théorie est que vous pouvez installer votre système racine sur un volume logique, puis, si vous souhaitez effectuer un test, vous pouvez créer un instantané et redémarrer la machine en utilisant le nouveau volume.

Les instantanés LVM ont besoin du volume d'origine pour fonctionner. En effet, le nouveau volume contient la différence entre le cliché instantané et le système de fichiers réel.

Si vous laissez le système dans cet état, vous allez commencer à perdre de l'espace disque à mesure que le nouveau système de fichiers change. Je ne sais pas s'il existe un moyen de consolider le système de fichiers instantané et définitif. Vous pouvez sûrement dd sur un autre volume logique, mais pour cela, vous aurez besoin de deux fois plus d’espace que votre système de fichiers, plus la différence entre votre "point de récupération" et l’état actuel.

Et tout cela nécessite des redémarrages et est loin d’être automatique.

Il est également supposé que plusieurs systèmes de fichiers modernes vont dans ce sens, comme zfs sur les systèmes solaris ou les btrfs expérimentaux.

1
theist