Ich benutze die Virtual Box häufig zum Testen von Distributionen und Anwendungen.

Eine der Funktionen, die ich einfach mag, sind Snapshots von virtuellen Maschinen, die den Zustand einer virtuellen Maschine speichern und sie in ihrem früheren Glanz wiederherstellen können, wenn etwas schief gelaufen ist, ohne dass Probleme aufgetreten sind und der gesamte Festplattenspeicher belegt wird.

Auf meinen Live-Systemen kann ich ein 1: 1-Image des Dateisystems erstellen, aber alle mir bekannten Lösungen erstellen ein neues Image des gesamten Dateisystems.

Gibt es Programme / Dateisysteme, die in der Lage sind, einen Schnappschuss eines aktuellen Dateisystems zu erstellen, ihn an einem anderen Ort zu speichern, aber anstatt ein neues Image zu erstellen, werden inkrementelle Sicherungen erstellt?

Um einfach zu beschreiben, was ich will, sollte es sich um ddImages eines Dateisystems handeln, aber statt nur einer vollständigen Sicherung würde es auch eine inkrementelle Sicherung erstellen.

Ich suche nicht nach Clonezilla usw. Es sollte innerhalb des Systems selbst ohne (oder fast ohne) Eingriffe des Benutzers ausgeführt werden, aber alle Daten der Dateisysteme enthalten. Ich bin auch nicht auf der Suche nach einem duplicityBackup Ihres gesamten Systems mit Ausnahme einiger Ordner script + dd, um Ihre mbr zu speichern. Das kann ich selbst machen, auf der Suche nach mehr Finesse.

Ich suche nach etwas, was ich tun kann, bevor ich massive Änderungen an einem System vornehme, und wenn etwas nicht stimmt oder ich meine Festplatte verbrenne, nachdem ich Kaffee darauf verschüttet habe, kann ich einfach von einer Live-CD booten und einen funktionierenden Schnappschuss auf einer Festplatte wiederherstellen.

Es muss nicht täglich sein, es braucht nicht einmal einen Zeitplan. Einfach ab und zu ausführen und es seinem Job überlassen und am besten RAW-basiert, nicht dateikopiebasiert.

Um zu erklären , cprofitt Antwort (wie seine Antwort ist inkrementell, wie ich das erklären werde) ...

Zuerst müssen Sie über harte Links Bescheid wissen.

Feste Verknüpfungen verweisen auf die Daten, die sich tatsächlich auf der Festplatte (dem physischen Speicherort) befinden, und Sie können über die feste Verknüpfung auf die Daten zugreifen. Jede Datei und jedes Verzeichnis ist eine feste Verknüpfung zum Speicherort der Daten auf der physischen Festplatte. Wenn also zwei Dateien (Hardlinks) auf denselben Speicherort verweisen, werden die Daten nur einmal gespeichert .

Der von cprofitt vorgegebene Prozess beinhaltet:

1. Drehen Sie die Backups, um einen Platz für einen neuen zu schaffen. (Aus "Heute sichern" von gestern wird "Gestern sichern", aus "Gestern sichern" von vor zwei Tagen wird "Vor zwei Tagen sichern" usw.)

   • Die Liste wächst so lange, wie Sie möchten, enthält jedoch im Skript nur 4 Schnappschüsse. (Er führt den gesamten Vorgang für die nächste Ebene erneut aus (z. B. eine Woche - "Diese Woche sichern") und dreht diese, weshalb er nur 4 hat.)
   • Das Verschieben erfolgt in umgekehrter Reihenfolge, um ein Überschreiben zu verhindern

2. Kopieren Sie den zuletzt erstellten Schnappschuss (z. B. "Sicherungskopie von gestern") an den Speicherort für den neuen (z. B. "Sicherungskopie von heute"), und erstellen Sie neue feste Links zu den vorhandenen Dateien, ohne die Datei zu kopieren. Daher verweisen alle Dateien im neuen Snapshot auf denselben Speicherort wie im vorherigen .

Ein illustriertes Beispiel

In der folgenden Abbildung sind Dateien derselben Farbe mit demselben Dateinamen feste Links zu derselben Datei auf der Festplatte. Hier haben wir es nur mit zwei Schnappschüssen und ein paar Dateien zu tun, aber das Beispiel ist skaliert. (Mit Ausnahme der Tatsache, dass ich Schnappschüsse anders als Skripte in der Antwort von cproffit verschiebe)

Der Prozess ist wie folgt:

1. Es gibt eine Momentaufnahme des Systems.

2. Der Schnappschuss besteht aus Kopien (Erstellen fester Links zu den vorhandenen Dateien).

3. Rsync wird ausgeführt, um den Snapshot zu aktualisieren. Wenn Dateien geändert werden, wird die neue Datei als neue Kopie auf der Festplatte gespeichert (der ältere Schnappschuss wird also nicht geändert). In diesem Beispiel wurde Datei B geändert. Hinweis: Wir haben jetzt nur 1 Kopie von Datei A und Datei C und zwei Kopien von Datei B auf der Festplatte gespeichert

4. Drehen Sie die Schnappschüsse (in diesem Fall fällt der Schnappschuss 0 ab und wird gelöscht, und ich benenne den Schnappschuss 1 in den Schnappschuss 0 um)

5. Kopieren Sie den Schnappschuss erneut (Wiederholung von Schritt 2)

6. Rsync erneut. (Wiederholen Sie Schritt 3). Jetzt haben wir 1 Kopie von Datei A und 2 Kopien von Datei B und Datei C

Eine vereinfachte Version des [ersten] Skripts (nicht auszuführen, nur als Sprungbrett) lautet wie folgt:

#!/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 ;

Jetzt haben die vollständigen Skripte hier die vollständige Erklärung (als cprofitt verknüpft mit) und es ist gründlicher, aber es ist im Grunde wie oben. Das andere Skript dient zum Gruppieren von Snapshots, und der andere Teil der Antwort von cprofitt befasst sich mit der Automatisierung des Prozesses (mithilfe von cron) und der Überprüfung, ob die Sicherung erfolgreich war.

Sie können die Namen ändern, sodass die Verzeichnisse nicht "stündlich ...", sondern etwas anderes heißen und das Skript manuell ausgeführt wird.

Um das gesamte Los wiederherzustellen, kopieren Sie den letzten (oder einen vorherigen) Snapshot zurück in das Verzeichnis, von dem Sie die Backups erstellt haben.

Um eine einzelne Datei wiederherzustellen, die sich noch in einem Schnappschuss befindet, gehen Sie zum Schnappschuss und kopieren Sie ihn dorthin zurück, wo er hingehört.

Das Sicherungsmedium kann eine externe Festplatte sein (muss ext2 / ext3 / ext4 sein). Wenn Sie wurden zu sichern /(vor allem /boot, /home, /etc /rootund /usr) dann sagen ...

1. Sie mounten das externe Laufwerk, führen die Sicherung durch und erstellen den neuesten Snapshot.

2. Hängen Sie das Laufwerk aus.

3. Denken Sie daran, dass Sie eine gewünschte Datei (auch aus dem Papierkorb) gelöscht haben.

4. Schließen Sie das externe Laufwerk an und rufen Sie die Datei ab.

5. Mach ein Backup (nur um sicher zu gehen)

6. Trennen Sie das Laufwerk und fahren Sie ...

7. Beachten Sie, dass sich Laptop und Lava nicht mischen.

8. Wenn Ihr neuer Laptop eine Live-CD ausführt, formatieren Sie das interne Laufwerk, hängen Sie das externe Laufwerk ein und dann cp -a /media/external/snapshot-0/* /media/internal-drive(vorausgesetzt, Snapshot-0 ist der neueste Snapshot).

9. Installieren Sie grub im MBR (ja, es muss ddseparat sein) - oder verwenden Sie es, um das mbr zu sichern, wie cprofitt am Ende seiner Antwort gesagt hat.

10. Starten Sie neu.

Das Skript muss verfeinert werden (um nur das zu erhalten, was Sie möchten), und die oben beschriebene Prozedur geht davon aus, dass Sie keine /homePartition haben. Wenn Sie einen neuen Datenträger erstellt haben (oder hatten) und diesen mount /dev/sdxy /media/external/homevor dem Kopieren mit einbinden.

Sie könnten rsync verwenden.

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;

und der zweite:

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;

Nachdem Sie das Skript nach Ihren Wünschen erstellt haben, fügen Sie es zu Cron-Jobs hinzu.

crontab -e

Fügen Sie Folgendes hinzu:

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

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

Sie bewirken, dass make_snapshot.sh alle vier Stunden und daily_snapshot_rotate.sh jeden Tag um 13:00 Uhr (dh 13:00 Uhr) ausgeführt wird.

Quelle: 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)

Wenn Sie möchten, dass es stündlich ausgeführt wird, fügen Sie für jede Stunde einen Cron-Job hinzu.

Eine andere mögliche Option ist die Verwendung von rsnapshot

1. Installieren Sie rsnapshot (im Software Center verfügbar)

2. Konfigurieren Sie rsnapshot und geben Sie das Sicherungsquellenverzeichnis an

Öffnen Sie die Datei /etc/rsnapshot.conf und kommentieren Sie die folgenden Zeilen aus.

# 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. Definieren Sie Ihre Zielsicherungsverzeichnisse in /etc/rsnapshot.conf wie unten gezeigt. In diesem Beispiel

   / home - Quellverzeichnis, das gesichert werden soll localhost / - Zielverzeichnis, in dem die Sicherung gespeichert wird. Beachten Sie, dass dieses Verzeichnis wie im letzten Schritt gezeigt unter /.snapshots/{internal.n}/ erstellt wird.

   nano /etc/rsnapshot.conf

   backup / home / localhost /

2. Testen Sie die rsnapshot-Konfiguration

Führen Sie einen Konfigurationstest durch, um sicherzustellen, dass rsnapshot ordnungsgemäß eingerichtet und bereit ist, ein Linux-Rsync-Backup durchzuführen.

# rsnapshot configtest
Syntax OK

1. Überprüfen Sie die stündliche Konfiguration der rsnapshot-Sicherung

Sie können Linux-Verzeichnisse oder -Dateien in verschiedenen Intervallen sichern. Standardmäßig sind die stündlichen und täglichen Sicherungen konfiguriert.

Überprüfen Sie die stündliche Sicherungskonfiguration.

# 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. Überprüfen Sie die Konfiguration von rsnapshot Daily Backup

Stellen Sie sicher, dass der tägliche rsnapshot cwrsync-Sicherungsprozess ordnungsgemäß konfiguriert ist.

# rsnapshot -t daily
echo 6493 > /var/run/rsnapshot.pid
mkdir -m 0700 -p /.snapshots/
/.snapshots/hourly.5 not present (yet), nothing to copy

1. Crontab-Eintrag für rsnapshot hinzufügen

Sobald Sie überprüft haben, ob die stündlichen und täglichen rsync-Sicherungskonfigurationen im Dienstprogramm rsnapshot cwrsync ordnungsgemäß eingerichtet wurden, ist es an der Zeit, diesen Welpen in der crontab wie unten gezeigt einzurichten.

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

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

---- Bare-Metal-Recovery

Ich würde dd und teer verwenden, um die Baremetallwiederherstellung durchzuführen.

Sichern Sie wichtige Metadaten:

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

Backup des Betriebssystems:

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


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

Ich persönlich würde dazu neigen, mein System vom Netz zu nehmen, wenn ich eine Baremetal-Wiederherstellungsdatei erstellen wollte.

Es gibt zwei Möglichkeiten, eine blockbasierte Teilsicherung durchzuführen

• Dateisystembasierte Snapshots
• Programmbasierte Schnappschüsse

Dateisystembasierte Snapshots

Sowohl ZFS als auch BTRFS bieten blockbasierte inkrementelle Snapshots ( BTRFS , ZFS (Seite 25) ). Sie könnten ein Laufwerk haben, mit dem Sie rsynchen, entweder ZFS oder BTRFS und Snapshot.

Es gibt auch LVM-Snapshots (von cprofitt erwähnt), die dieselben blockbasierten inkrementellen Snapshots bereitstellen.

Programmbasierte Schnappschüsse

Es gibt mehrere Sicherungsprogramme , jedoch einige, die zu diesem Zweck herausragen:

• Duplizität
• Rdiff-Backup

Ich weiß, dass Sie ausdrücklich erwähnt haben, dass Sie nicht nach Dubletten suchen, aber ich dachte, ich könnte einige Merkmale erwähnen.

Für diese Programme müssen Sie sie jedoch installieren, um sie wiederherstellen zu können. Das Schöne an so etwas wie rsync ist, dass fast jede Linux-Installation standardmäßig rsync hat (z. B. fehlt ein winziger Kern (eine 10-MB-Distribution)).

Duplizität

Es speichert nur das Diff (Block Level) und komprimiert und verschlüsselt sie dann. Dies führt zu noch weniger Speicherplatz als die rsync-Methode, allerdings muss (zumindest so wie ich es sehe) das Dateisystem rekonstruiert werden, was einige Zeit in Anspruch nimmt (wenn Sie inkrementelle Sicherungen damit verwenden, und dies hängt von der Zeit seither ab letzte vollständige Sicherung)

Die Manpage erklärt, wie es funktioniert.

Rdiff-Backup

Ein Client-Server-Programm, das wie die Duplizität Unterschiede auf Blockebene erstellt, jedoch Änderungen vom letzten Wiederherstellungspunkt speichert, sodass der neueste Snapshot am schnellsten wiederhergestellt werden kann. Eine Zeitreise in die Vergangenheit (nicht der letzte Schnappschuss) erfordert mehr zu analysierende Diffs und ist daher langsamer.

Einige Leute vergleichen rdiff-backup mit rsnapshot (scheint ein automatischerer Weg des rsync-Mentods zu sein). Fast alle Anleitungen konzentrieren sich auf die Verwendung von rdiff über das Netzwerk, jedoch habe ich eine gefunden, in der erwähnt wird, wie dies auf localhost gemacht wird .

Sie sollten sich ddar ( homepage ) ansehen .

Dies ist inkrementell, da die identischen Teile des Schnappschusses nicht übertragen werden. Es ist nicht inkrementell in der klassischen Bedeutung des Wortes, da es sich um Schnappschüsse handelt.

Hinweis: Ich habe das nicht selbst ausprobiert (aber ich vertraue dem Autor). Es kann sein, dass es nicht das tut, was Sie sofort erreichen möchten, es gibt jedoch ähnliche Lösungen auf der Seite (z. B. ZFS ), sodass es sich als Ausgangspunkt möglicherweise als nützlich erweisen kann.

Ich denke, Sie können dies mit LVM tun, es ist nur theoretisch, und es wird eine große Menge an Festplatte verschwenden. Nach meiner Theorie können Sie Ihr Root-System auf einem logischen Volume betreiben. Wenn Sie einen Test durchführen möchten, können Sie einen Snapshot erstellen und den Computer mit dem neuen Volume neu starten.

LVM-Snapshots benötigen das Original-Volume, um zu funktionieren. Dies liegt daran, dass das neue Volume den Unterschied zwischen dem Snapshot und dem realen Dateisystem enthält.

Wenn Sie das System in diesem Zustand belassen, werden Sie anfangen, Speicherplatz zu verschwenden, wenn sich das neue Dateisystem ändert. Ich weiß nicht, ob es eine Möglichkeit gibt, das Snapshot- und das endgültige Dateisystem zu konsolidieren. Sicherlich können Sie auf ein anderes logisches Volume zugreifen, aber dafür benötigen Sie den doppelten Speicherplatz Ihres Dateisystems plus den Unterschied zwischen Ihrem "Wiederherstellungspunkt" und dem aktuellen Status.

Und all dies erfordert einen Neustart und ist alles andere als automatisch.

Es wird auch angenommen, dass mehrere moderne Dateisysteme diesen Weg gehen, wie zfs auf Solaris-Systemen oder die experimentellen btrfs.

Diese ist ein bisschen überfordert, aber es hört sich so an, als ob Sie teilweise Sicherungen von Binärdateien (wie Partitionsimagedateien) durchführen möchten. Dafür gibt es ein Paket (ich habe es gerade gelesen - nicht ausprobiert.)

Schauen Sie sich bup an.

https://github.com/apenwarr/bup

Es könnte Ihnen einige Ideen geben.