J'utilise beaucoup Virtual Box à des fins de test de distribution / applications.

L'une des fonctionnalités que j'aime tout simplement, ce sont les instantanés de machines virtuelles, cela enregistre l'état d'une machine virtuelle et est capable de lui redonner son ancienne gloire si quelque chose s'est mal passé sans aucun problème et sans consommer tout votre espace disque dur.

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 sur 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, ce devrait être comme des ddimages d'un système de fichiers, mais au lieu d'une sauvegarde complète, cela créerait également des incréments.

Je ne cherche pas clonezilla, etc. Il devrait fonctionner dans le système lui-même sans intervention (ou presque aucune) de l'utilisateur, mais contenir toutes les données des systèmes de fichiers. Je ne suis pas non plus à la recherche d'une duplicitysauvegarde de votre tout système à l'exception de certains dossiers script + ddpour enregistrer votre mbr. Je peux le faire moi-même, à la recherche d'une finesse supplémentaire.

Je cherche quelque chose que je peux faire avant d'apporter des modifications massives à un système, puis si quelque chose ne va pas ou que j'ai brûlé mon disque dur après avoir renversé du café dessus, je peux simplement démarrer à partir d'un liveCD et restaurer un instantané de travail sur un disque dur.

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

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

Vous devez d'abord connaître les liens durs.

Les liens matériels pointent vers les données qui se trouvent réellement sur le disque (l'emplacement physique) et vous pouvez accéder aux données à l'aide du lien matériel. Chaque fichier et répertoire est un lien dur vers l'emplacement des données sur le disque physique. Par conséquent, s'il existe deux fichiers (liens durs) 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 continue de s'allonger aussi longtemps que vous le souhaitez, mais dans le script, elle n'a 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 l'écrasement

2. Copiez le dernier instantané que vous avez fait (par exemple "sauvegarde d'hier") à l'endroit du nouveau (par exemple "sauvegarde d'aujourd'hui"), en créant de nouveaux liens physiques vers les fichiers existants sans copier le fichier. Ainsi, tous les fichiers du nouvel instantané pointent 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 qui ont le même nom de fichier sont des liens durs vers le même fichier sur le disque. Ici, nous ne traitons que de deux instantanés et de quelques fichiers, mais l'exemple est à l'échelle. (Sauf pour le fait que je déplace les instantanés dans le sens inverse des scripts dans la réponse de cproffit)

Le processus est le suivant:

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

2. L'instantané est des copies (création de liens durs vers les fichiers existants)

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

4. Faites 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 snapshot agin (répétez l'étape 2)

6. Rsync à nouveau. (Répétez l'étape 3). Nous avons maintenant 1 copie du fichier A et 2 copies des fichiers B et C

Une version simplifiée du [premier] script (à ne pas exécuter, tout 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 (s) script (s) complet (s) a l'explication complète ici (comme cprofitt lié à) et il est plus complet mais il est fondamentalement comme ci-dessus. L'autre script sert à regrouper les instantanés et l'autre partie de la réponse de cprofitt parle de rendre le processus automatique (à l'aide de cron) et de vérifier que la sauvegarde a réussi.

Vous pouvez changer les noms, donc 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 la totalité 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 se trouve toujours dans un instantané, accédez à l'instantané et copiez-le à l'endroit où il appartient.

Le support de sauvegarde peut être un disque dur externe (doit être ext2 / ext3 / ext4). Si vous sauvegardez /(principalement /boot, /home, /etc /rootet /usr) puis, dire ...

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

2. Démontez le lecteur.

3. N'oubliez pas 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 l'instantané-0 est le dernier instantané)

9. Installez grub sur le MBR (oui, il doit être séparé) - ou utilisez-le ddpour sauvegarder le mbr, comme l'a dit cprofitt au bas de sa réponse.

10. Redémarrez.

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

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

Ils provoquent l'exécution de make_snapshot.sh toutes les quatre heures à l'heure et l'exécution de 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 souhaitez qu'il s'exécute toutes les heures, vous devez ajouter un travail cron pour chaque heure.

Une autre option possible consiste à utiliser rsnapshot

1. Installer 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 qui doit être sauvegardé 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é dans la dernière étape.

   nano /etc/rsnapshot.conf

   sauvegarde / home / localhost /

2. Tester 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érifiez la configuration de sauvegarde horaire 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 toutes les heures.

# 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 sauvegarde quotidienne rsnapshot

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

# 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 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 des métaux nus

J'utiliserais dd et tar pour faire une récupération baremetal.

Sauvegarde des 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 voulais créer un fichier de restauration baremetal.

Il existe 2 façons d'effectuer une sauvegarde incrémentielle basée sur des blocs

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

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

Les deux ZFS et BTRFS fournissent des instantanés incrémentiels à base de blocs ( BTRFS , ZFS (page 25) ). Vous pourriez avoir un lecteur sur lequel vous rsync soit ZFS ou BTRFS et un instantané.

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

Instantanés basés sur le programme

Il existe plusieurs programmes de sauvegarde , mais quelques-uns se distinguent à cet effet:

• Duplicité
• Rdiff-backup

Je sais que vous avez mentionné spécifiquement que vous ne recherchez pas quelque chose comme la duplicité, mais j'ai pensé que je pourrais mentionner certaines fonctionnalités.

Cependant, ces programmes nécessitent que vous les installiez pour les restaurer. La beauté de quelque chose comme rsync est que presque toutes les installations Linux ont rsync (par exemple, un petit noyau (une distribution de 10 Mo) manque) par défaut.

Duplicité

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

La page de manuel explique comment cela fonctionne.

Rdiff-backup

Un programme client-serveur qui crée, comme la duplicité, des différences de niveau de bloc, mais il stocke les modifications à partir du dernier point de restauration, de sorte que le dernier instantané est le plus rapide à restaurer. Remonter dans le temps (pas le dernier instantané) nécessite plus de différences à analyser et donc c'est plus lent.

Certaines personnes comparent rdiff-backup à rsnapshot (cela semble être un moyen plus automatique du mentod rsync). Presque tous les comment-tos se concentrer sur l' utilisation rdiff sur le réseau, mais j'ai trouvé un qui mentionne comment le faire sur localhost .

Vous devriez jeter un oeil à ddar ( page d'accueil ).

Il est incrémentiel dans le sens de ne pas transférer les parties identiques de l'instantané. Il n'est pas incrémentiel 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 pourrait ne pas faire ce que vous aimeriez réaliser immédiatement, mais il existe toujours des solutions plus similaires sur la page (par exemple, ZFS ), donc comme point de départ, cela pourrait s'avérer utile.

Je pense que vous pouvez le faire avec LVM, sa seule théorie, et cela gaspillera une grande quantité de disque dur. Ma théorie est que vous pouvez faire vivre votre système racine sur un volume logique, puis si vous voulez faire 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 l'instantané et le véritable système de fichiers.

Si vous laissez le système dans cet état, vous commencerez à gaspiller 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 accéder à un autre volume logique, mais pour cela, vous aurez besoin de deux fois l'espace de 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.

Celui-ci est un peu au-dessus de ma tête, mais cela ressemble à une partie de ce que vous voulez faire est de faire des sauvegardes partielles de fichiers binaires (comme les fichiers d'image de partition). Il existe un package conçu pour cela (je viens de lire à ce sujet - je ne l'ai pas essayé.)

Jetez un oeil à bup.

https://github.com/apenwarr/bup

Cela pourrait vous donner quelques idées.