Używam Virtual Box do testowania dystrybucji / aplikacji.

Jedną z funkcji, które po prostu uwielbiam, są migawki maszyn wirtualnych, która zapisuje stan maszyny wirtualnej i jest w stanie przywrócić ją do dawnej świetności, jeśli coś poszło nie tak bez problemów i bez zajmowania całego miejsca na dysku twardym.

W moich systemach na żywo wiem, jak utworzyć obraz systemu plików 1: 1, ale wszystkie znane mi rozwiązania stworzą nowy obraz całego systemu plików.

Czy są jakieś programy / systemy plików, które są w stanie wykonać migawkę bieżącego systemu plików, zapisać go w innej lokalizacji, ale zamiast tworzyć kompletny nowy obraz, tworzy przyrostowe kopie zapasowe?

Aby łatwo opisać to, czego chcę, powinny to być ddobrazy systemu plików, ale zamiast pełnej kopii zapasowej tworzyłby również przyrostowe.

Nie szukam clonezilli itp. Powinien on działać w samym systemie bez interwencji użytkownika (lub prawie bez interwencji), ale powinien zawierać wszystkie dane z systemów plików. Nie szukam też duplicitykopii zapasowej całego systemu z wyjątkiem skryptu folderów +, ddaby zapisać swój mbr. Mogę to zrobić sam, szukając dodatkowej finezji.

Szukam czegoś, co mogę zrobić przed dokonaniem ogromnych zmian w systemie, a następnie, jeśli coś się nie powiedzie lub spalę dysk twardy po rozlaniu kawy, mogę po prostu uruchomić komputer z płyty CD i przywrócić działającą migawkę na dysk twardy.

To nie musi być codzienne, nie potrzebuje nawet harmonogramu. Po prostu uruchamiaj od czasu do czasu i pozwól mu działać, najlepiej w oparciu o RAW, a nie na podstawie kopii pliku.

Aby wyjaśnić odpowiedź cprofitta (ponieważ jego odpowiedź jest przyrostowa, jak wyjaśnię) ...

Najpierw musisz wiedzieć o twardych linkach.

Dowiązania twarde wskazują dane, które faktycznie znajdują się na dysku (fizyczna lokalizacja), a dostęp do danych można uzyskać za pomocą łącza twardego. Każdy plik i katalog stanowi stałe łącze do lokalizacji danych na dysku fizycznym. Dlatego jeśli dwa pliki (twarde linki) wskazują tę samą lokalizację, dane są przechowywane tylko raz .

Proces podany przez cprofitt obejmuje:

1. Obróć kopie zapasowe, aby utworzyć miejsce na nowe. („Dzisiejsza kopia zapasowa” z wczoraj zmienia się na „Wczorajsza kopia zapasowa”, „Wczorajsza kopia zapasowa” sprzed dwóch dni staje się „Kopia zapasowa dwa dni temu” itd.)

   • Lista rośnie tak długo, jak chcesz, ale w skrypcie ma tylko 4 migawki. (Ponownie wykonuje cały proces na następny poziom (np. Tydzień - „Kopia zapasowa w tym tygodniu”) i obraca je, dlatego ma tylko 4).
   • Przenoszenie odbywa się w odwrotnej kolejności, aby zapobiec zastąpieniu

2. Skopiuj najnowszą migawkę (np. „Wczorajsza kopia zapasowa”) w miejsce nowej (np. „Dzisiejsza kopia zapasowa”), tworząc nowe twarde łącza do istniejących plików bez kopiowania pliku. Tak więc wszystkie pliki w nowej migawce wskazują tę samą lokalizację, co poprzednia .

Ilustrowany przykład

Na poniższym obrazku pliki tego samego koloru, które mają tę samą nazwę, stanowią twarde łącza do tego samego pliku na dysku. Mamy tutaj do czynienia z dwoma migawkami i kilkoma plikami, ale przykład jest skalowany. (Z wyjątkiem tego, że przenoszę migawki w odwrotny sposób niż skrypty w odpowiedzi cproffit)

Proces jest następujący:

1. Jest migawka systemu.

2. Migawka to kopie (tworzenie twardych linków do istniejących plików)

3. Rsync jest uruchamiany w celu aktualizacji migawki. Po zmianie plików nowy plik jest zapisywany jako nowa kopia na dysku twardym (więc starsza migawka nie jest zmieniana). W tym przykładzie plik B został zmieniony. Uwaga: mamy teraz tylko 1 kopię pliku A i pliku C oraz dwie kopie pliku B zapisane na dysku twardym

4. Obróć migawki (w tym przypadku migawka 0 „spada” i jest usuwana, a ja zmieniam nazwę migawki 1 na migawkę 0)

5. Skopiuj migawkę ponownie (powtórz krok 2)

6. Znowu Rsync. (Powtórz krok 3). Teraz mamy 1 kopię pliku A i 2 kopie pliku B i pliku C.

Uproszczona wersja skryptu [pierwszego] (nie do uruchomienia, podobnie jak odskocznia) jest następująca:

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

Teraz pełny skrypt (y) ma tutaj pełne wyjaśnienie (jako związane z cprofitt) i jest bardziej dokładny, ale jest zasadniczo jak wyżej. Drugi skrypt służy do grupowania migawek, a druga część odpowiedzi cprofitt mówi o automatycznym procesie (przy użyciu crona) i sprawdzeniu, czy tworzenie kopii zapasowej się powiodło.

Możesz zmienić nazwy, więc zamiast katalogów nazywanych „godzinnymi ...” są one nazywane czymś innym, a skrypt jest uruchamiany ręcznie.

Aby przywrócić całą partię, skopiuj najnowszą migawkę (lub poprzednią) z powrotem do katalogu, w którym robiłeś kopie zapasowe.

Aby przywrócić pojedynczy plik, który nadal znajduje się w migawce, przejdź do migawki i skopiuj go z powrotem do miejsca, do którego należy.

Nośnikiem kopii zapasowej może być zewnętrzny dysk twardy (musi to być ext2 / ext3 / ext4). Gdybyś tworzenia kopii zapasowych /(głównie /boot, /home, /etc /rooti /usr), a następnie, powiedzmy ...

1. Montujesz dysk zewnętrzny, wykonujesz kopię zapasową i tworzysz najnowszą migawkę.

2. Odmontuj dysk.

3. Pamiętaj, że usunąłeś plik (nawet z kosza), który chciałeś.

4. Podłącz dysk zewnętrzny i pobierz plik.

5. Wykonaj kopię zapasową (dla pewności)

6. Odłącz dysk i podróżuj ...

7. Uświadom sobie, że laptop i lawa nie mieszają się.

8. Na nowym laptopie z uruchomioną płytą CD sformatuj dysk wewnętrzny, zamontuj dysk zewnętrzny, a następnie cp -a /media/external/snapshot-0/* /media/internal-drive(zakładając, że migawka-0 jest najnowszą migawką)

9. Zainstaluj gruba w MBR (tak, musi być osobno) - lub użyj go dddo wykonania kopii zapasowej MBR, jak powiedział cprofitt na dole swojej odpowiedzi.

10. Restart.

Skrypt musi zostać dopracowany (aby uzyskać tylko to, czego potrzebujesz), a procedura zakłada, że ​​nie masz /homepartycji. Jeśli utworzysz (lub miałeś) utworzyć nowy na dysku i zamontujesz go mount /dev/sdxy /media/external/homeprzed kopiowaniem.

Możesz użyć 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;

i drugi:

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;

Po utworzeniu skryptu do swoich potrzeb dodaj go do zadań crona.

crontab -e

dodaj następujące:

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

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

Powodują, że make_snapshot.sh jest uruchamiany co cztery godziny w ciągu godziny i daily_snapshot_rotate.sh jest uruchamiany codziennie o 13:00 (czyli 13:00).

źródło: 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)

Jeśli chcesz, aby działał co godzinę, dodawałeś zadanie cron dla każdej godziny.

Inną możliwą opcją jest użycie rsnapshot

1. Zainstaluj rsnapshot (dostępny w centrum oprogramowania)

2. Skonfiguruj rsnapshot i Określ kopię zapasową katalogu źródłowego

Otwórz plik /etc/rsnapshot.conf i usuń komentarz z następujących wierszy.

# 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. Zdefiniuj docelowe katalogi kopii zapasowych w /etc/rsnapshot.conf, jak pokazano poniżej. W tym przykładzie

   / home - katalog źródłowy, dla którego należy utworzyć kopię zapasową localhost / - katalog docelowy, w którym będzie przechowywana kopia zapasowa. Pamiętaj, że ten katalog zostanie utworzony w katalogu /.snapshots/{internal.n}/, jak pokazano w ostatnim kroku.

   nano /etc/rsnapshot.conf

   backup / home / localhost /

2. Przetestuj konfigurację rsnapshot

Wykonaj test konfiguracji, aby upewnić się, że rsnapshot jest poprawnie skonfigurowany i gotowy do wykonania kopii zapasowej rsync linuksa.

# rsnapshot configtest
Syntax OK

1. Sprawdź konfigurację rsnapshot Hourly Backup

Możesz tworzyć kopie zapasowe katalogów lub plików systemu Linux w różnych odstępach czasu. Domyślnie konfigurowane są godzinowe i dzienne kopie zapasowe.

Sprawdź konfigurację kopii zapasowej co godzinę.

# 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. Sprawdź konfigurację rsnapshot Daily Backup

Sprawdź, czy codzienny proces tworzenia kopii zapasowej rsnapshot cwrsync jest poprawnie skonfigurowany.

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

1. Dodaj pozycję Crontab dla rsnapshot

Po sprawdzeniu, że konfiguracje godzinowej i dziennej kopii zapasowej rsync są poprawnie skonfigurowane w narzędziu rsnapshot cwrsync, nadszedł czas, aby ustawić tego szczeniaka w crontab, jak pokazano poniżej.

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

źródło: http://www.thegeekstuff.com/2009/08/tutorial-backup-linux-using-rsnapshot-rsync-utility/

---- Odzyskiwanie nagiego metalu

Używałbym dd i tar do odzyskiwania systemu od zera.

Utwórz kopię zapasową ważnych metadanych:

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

Wykonaj kopię zapasową systemu operacyjnego:

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


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

Osobiście wolałbym wyłączać mój system z sieci, gdybym chciał utworzyć plik przywracania systemu od zera.

Istnieją 2 sposoby tworzenia przyrostowej kopii zapasowej na podstawie bloków

• Migawki oparte na systemie plików
• Migawki programowe

Migawki oparte na systemie plików

Zarówno ZFS, jak i BTRFS zapewniają przyrostowe migawki oparte na blokach ( BTRFS , ZFS (strona 25) ). Możesz mieć dysk, do którego synchronizujesz rsync, czyli ZFS lub BTRFS i migawka.

Istnieją również migawki LVM (wspomniane przez cprofitt), które zapewniają te same przyrostowe migawki oparte na blokach.

Migawki programowe

Istnieje kilka programów do tworzenia kopii zapasowych , jednak kilka wystaje w tym celu:

• Dwulicowość
• Rdiff-backup

Wiem, że specjalnie wspomniałeś, że nie szukasz czegoś takiego jak dwulicowość, ale pomyślałem, że mógłbym wspomnieć o niektórych funkcjach.

Jednak programy te wymagają instalacji w celu przywrócenia. Piękno czegoś takiego jak rsync polega na tym, że prawie każda instalacja linuxowa ma rsync (np. Brakuje go w małym rdzeniu (dystrybucja 10 MB)).

Dwulicowość

Po prostu przechowuje różnicę (poziom bloku), a następnie kompresuje je i szyfruje. Prowadzi to do jeszcze mniejszej ilości pamięci niż metoda rsync, jednak (przynajmniej tak to widzę) system plików będzie musiał zostać zrekonstruowany, co zajmie trochę czasu (jeśli korzystasz z przyrostowych kopii zapasowych i zależy to od czasu ostatnia pełna kopia zapasowa)

Strona podręcznika wyjaśnia jak to działa.

Rdiff-backup

Program klient-serwer, który tworzy, podobnie jak duplikat, różnice na poziomie bloku, jednak przechowuje zmiany od ostatniego punktu przywracania, więc najnowsza migawka jest najszybsza do przywrócenia. Cofanie się w czasie (nie ostatnia migawka) wymaga analizy większej liczby różnic, więc jest wolniejsze.

Niektórzy porównują rdiff-backup do rsnapshot (wydaje się to bardziej automatycznym sposobem mentod rsync). Prawie wszystkie instrukcje koncentrują się na korzystaniu z rdiff przez sieć, jednak znalazłem taki, który wspomina, jak to zrobić na localhost .

Powinieneś spojrzeć na ddar ( strona główna ).

Jest to przyrostowe w tym sensie, że nie przenosi identycznych części migawki. Nie jest on przyrostowy w klasycznym znaczeniu tego słowa, ponieważ dotyczy migawek.

Uwaga: sam tego nie próbowałem (ale ufam autorowi). Może nie zrobić tego, co chciałbyś osiągnąć od razu po wyjęciu z pudełka, ale na stronie jest więcej podobnych rozwiązań (np. ZFS ), więc na początek może się okazać przydatny.

Myślę, że możesz to zrobić z LVM, która jest jedyną teorią, i zmarnuje dużą ilość dysku twardego. Moja teoria jest taka, że ​​możesz uzyskać system root żyjący na logicznym woluminie, a jeśli chcesz wykonać test, możesz utworzyć migawkę i ponownie uruchomić komputer przy użyciu nowego woluminu.

Migawki LVM wymagają oryginalnego woluminu do działania. Wynika to z faktu, że nowy wolumin zawiera różnicę między migawką a rzeczywistym systemem plików.

Jeśli pozostawisz system w tym stanie, zaczniesz marnować miejsce na dysku, gdy zmieni się nowy system plików. Nie wiem, czy istnieje sposób na konsolidację obrazu stanu i ostatecznego pliku. Z pewnością możesz przenieść dd na inny wolumin logiczny, ale do tego potrzebujesz dwa razy więcej miejsca w systemie plików oraz różnicy między „punktem odzyskiwania” a bieżącym stanem.

A wszystko to wymaga ponownego uruchomienia i daleki jest od automatyzacji.

Przypuszcza się również, że działa w ten sposób kilka nowoczesnych systemów plików, takich jak ZFS w systemach solaris lub eksperymentalne btrfs.

Ten jest trochę nad moją głową, ale wydaje się, że częścią tego, co chcesz zrobić, jest częściowe tworzenie kopii zapasowych plików binarnych (takich jak pliki obrazów partycji). Zaprojektowano do tego pakiet (właśnie o tym przeczytałem - nie wypróbowałem).

Spójrz na BUP.

https://github.com/apenwarr/bup

Może dać ci kilka pomysłów.