Я часто использую Virtual Box для тестирования дистрибутивов / приложений.

Одна из функций, которые мне просто нравятся, - это моментальные снимки виртуальных машин, они сохраняют состояние виртуальной машины и способны восстановить ее прежнюю славу, если что-то вы сделали не так, как надо, без проблем и без использования всего пространства на жестком диске.

На моих живых системах я знаю, как создать образ файловой системы в формате 1: 1, но все известные мне решения создадут новый образ всей файловой системы.

Существуют ли какие-либо программы / файловые системы, способные сделать снимок текущей файловой системы, сохранить его в другом месте, но вместо создания нового образа он создает инкрементные резервные копии?

Чтобы легко описать то, что я хочу, оно должно быть в виде ddобразов файловой системы, но вместо полной резервной копии оно также будет создавать инкрементное.

Я не ищу clonezilla и т. Д. Он должен работать внутри самой системы без (или почти без) вмешательства пользователя, но содержать все данные файловых систем. Я также не ищу duplicityрезервную копию всей вашей системы, за исключением некоторых папок + скрипт ddдля сохранения вашего mbr. Я могу сделать это сам, ища дополнительную утонченность.

Я ищу что-то, что я могу сделать, прежде чем вносить значительные изменения в систему, а затем, если что-то не так или я сжег свой жесткий диск после того, как на него налили кофе, я могу просто загрузиться с liveCD и восстановить рабочий снимок на жесткий диск.

Это не должно быть ежедневно, ему даже не нужно расписание. Просто запускайте время от времени и дайте ему свою работу, желательно на основе RAW, а не на основе файлов.

Чтобы объяснить ответ cprofitt (поскольку его ответ является инкрементным, как я объясню) ...

Для начала нужно узнать о жестких ссылках.

Жесткие ссылки указывают на данные, которые фактически находятся на диске (физическое местоположение), и вы можете получить доступ к данным, используя жесткую ссылку. Каждый файл и каталог представляет собой жесткую ссылку на расположение данных на физическом диске. Следовательно, если два файла (жесткие ссылки) указывают на одно и то же местоположение, данные сохраняются только один раз .

Процесс, данный cprofitt, включает в себя:

1. Вращайте резервные копии, чтобы создать место для нового. («Сегодняшняя резервная копия» со вчерашнего дня становится «Вчерашняя резервная копия», «Вчерашняя резервная копия» двухдневной давности становится «Двухдневная резервная копия» и т. Д.)

   • Список продолжает расти столько, сколько вы хотите, однако в скрипте есть только 4 снимка. (Он снова выполняет весь процесс для следующего уровня (например, неделя - «Резервное копирование на этой неделе») и вращает их, поэтому у него только 4).
   • Перемещение выполняется в обратном порядке, чтобы предотвратить перезапись

2. Скопируйте последний сделанный вами снимок (например, «Вчерашняя резервная копия») в место для нового (например, «Сегодняшняя резервная копия»), создавая новые жесткие ссылки на существующие файлы без копирования файла. Таким образом, все файлы в новом снимке указывают на то же место, что и предыдущий .

Иллюстрированный пример

На рисунке ниже файлы одного цвета с одинаковым именем являются жесткими ссылками на один и тот же файл на диске. Здесь мы имеем дело только с двумя снимками и несколькими файлами, но пример масштабируется. (За исключением того факта, что в ответе cproffit я перемещаю снимки противоположным сценариям)

Процесс такой:

1. Есть снимок системы.

2. Снимок копий (создание жестких ссылок на существующие файлы)

3. Rsync запускается для обновления снимка. Когда файлы изменяются, он сохраняет новый файл как новую копию на жестком диске (поэтому старый снимок не изменяется). В этом примере Файл B был изменен. Примечание: теперь у нас есть только одна копия файла A и файла C и две копии файла B, хранящиеся на жестком диске

4. Поверните снимки (в этом случае снимок 0 «отваливается» и удаляется, и я переименовываю снимок 1 в снимок 0)

5. Скопируйте снимок еще раз (повторите шаг 2)

6. Rsync снова. (Повторите шаг 3). Теперь у нас есть 1 копия файла A и 2 копии файлов B и C

Упрощенная версия [первого] ​​скрипта (не для запуска, просто как ступенька):

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

Теперь полный сценарий (ы) имеет полное объяснение здесь (как cprofitt, связанный с), и он более тщательный, но в основном такой же, как указано выше. Другой сценарий предназначен для группировки снимков, а другая часть ответа cprofitt рассказывает о том, как сделать процесс автоматическим (с помощью cron) и убедиться, что резервное копирование прошло успешно.

Вы можете изменить имена, поэтому вместо того, чтобы каталоги назывались «ежечасно», они называются как-то иначе, а скрипт запускается вручную.

Чтобы восстановить весь участок, скопируйте последний снимок (или предыдущий) обратно в каталог, из которого вы делали резервные копии.

Чтобы восстановить один файл, который все еще находится в моментальном снимке, перейдите к моментальному снимку и скопируйте его туда, где он находится.

Носителем резервной копии может быть внешний жесткий диск (должен быть ext2 / ext3 / ext4). Если вы резервное копирование /( в основном /boot, /home, /etc /rootи /usr) , то сказать ...

1. Вы монтируете внешний диск, выполняете резервное копирование и создаете последний снимок.

2. Размонтируйте диск.

3. Помните, что вы удалили файл (даже из корзины), который вы хотели.

4. Подключите внешний диск и получите файл.

5. Сделайте резервную копию (просто чтобы быть уверенным)

6. Отключите диск и отправляйтесь в путешествие ...

7. Поймите, что ноутбук и лава не смешиваются.

8. Когда ваш новый ноутбук работает под управлением live cd, отформатируйте внутренний диск, подключите внешний диск и затем cp -a /media/external/snapshot-0/* /media/internal-drive(при условии, что snapshot-0 - последний снимок)

9. Установите grub на MBR (да, он должен быть отдельным) или используйте его ddдля резервного копирования mbr, как сказал cprofitt внизу своего ответа.

10. Перезагрузка.

Сценарий должен быть доработан (чтобы получить только то, что вы хотите), и процедура aove предполагает, что у вас нет /homeраздела. Если вы делаете (или имели) создание нового на диске и монтируете его на месте mount /dev/sdxy /media/external/homeперед копированием.

Вы можете использовать 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;

а второй:

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;

После создания скрипта под ваши нужды добавьте его в задания cron.

crontab -e

добавить следующее:

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

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

Они приводят к тому, что make_snapshot.sh запускается каждые четыре часа в час, а daily_snapshot_rotate.sh - каждый день в 13:00 (то есть в 13:00).

источник: 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)

Если вы хотите, чтобы он работал ежечасно, вы добавляете задание cron на каждый час.

Другой возможный вариант - использование rsnapshot

1. Установите rsnapshot (доступно в программном центре)

2. Настройте rsnapshot и укажите каталог источника резервного копирования

Откройте /etc/rsnapshot.conf и раскомментируйте следующие строки.

# 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. Определите каталоги резервных копий назначения в /etc/rsnapshot.conf, как показано ниже. В этом примере

   / home - исходный каталог, в который следует создать резервную копию localhost / - целевой каталог, в котором будет храниться резервная копия. Обратите внимание, что этот каталог будет создан в каталоге /.snapshots/advaninternal.n‹/, как показано на последнем шаге.

   nano /etc/rsnapshot.conf

   резервное копирование / home / localhost /

2. Тестирование конфигурации rsnapshot

Выполните тест конфигурации, чтобы убедиться, что rsnapshot настроен правильно и готов к выполнению резервного копирования linux rsync.

# rsnapshot configtest
Syntax OK

1. Проверка конфигурации почасового резервного копирования rsnapshot

Вы можете создавать резервные копии каталогов или файлов Linux через различные промежутки времени. По умолчанию настраивается ежечасное и ежедневное резервное копирование.

Проверьте почасовую конфигурацию резервного копирования.

# 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. Проверьте конфигурацию ежедневного резервного копирования rsnapshot

Убедитесь, что процесс ежедневного резервного копирования rsnapshot cwrsync настроен правильно.

# 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 для rsnapshot

После того, как вы проверили правильность настройки ежечасного и ежедневного резервного копирования rsync в утилите rsnapshot cwrsync, пришло время настроить этого щенка в crontab, как показано ниже.

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

источник: http://www.thegeekstuff.com/2009/08/tutorial-backup-linux-using-rsnapshot-rsync-utility/

---- Bare Metal Recovery

Я бы использовал dd и tar для восстановления без изменений.

Резервное копирование важных метаданных:

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

Сделайте резервную копию операционной системы:

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


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

Лично я бы предпочел отключить мою систему, если бы я захотел сделать восстановление файла в формате без использования металла.

Есть 2 способа сделать инкрементное резервное копирование на основе блоков

• Снимки на основе файловой системы
• Программные снимки

Снимки на основе файловой системы

И ZFS, и BTRFS предоставляют основанные на блоках моментальные снимки ( BTRFS , ZFS (стр. 25) ). У вас может быть диск, который вы rsync, или ZFS или BTRFS и снимок.

Есть также снимки LVM (упомянутые cprofitt), которые предоставляют те же самые инкрементальные снимки на основе блоков.

Программные снимки

Есть несколько программ резервного копирования , однако некоторые из них выделяются для этой цели:

• двуличность
• RDIFF резервного копирования

Я знаю, что вы специально упомянули, что вы не ищете что-то вроде двуличия, однако я подумал, что мог бы упомянуть некоторые особенности.

Однако эти программы требуют, чтобы вы установили их для восстановления. Прелесть чего-то вроде rsync заключается в том, что почти в каждой установке linux есть rsync (например, в крошечном ядре (дистрибутив 10 МБ) его по умолчанию).

двуличность

Он просто сохраняет diff (уровень блока), а затем сжимает и шифрует их. Это приводит к еще меньшему объему памяти, чем метод rsync, однако (по крайней мере, так, как я это понимаю) необходимо будет восстановить файловую систему, что потребует времени (если вы используете инкрементные резервные копии с ним, и это зависит от времени с последнее полное резервное копирование)

Страница людей объясняет , как это работает.

RDIFF резервного копирования

Клиент-серверная программа, которая, как и двуличие, создает различия на уровне блоков, однако в ней хранятся изменения с самой последней точки восстановления, поэтому самый последний моментальный снимок восстанавливается быстрее всего. Возвращение во времени (не самый последний снимок) требует больше различий для анализа и поэтому медленнее.

Некоторые люди сравнивают rdiff-backup с rsnapshot (кажется, более автоматический способ менструации rsync). Почти все инструкции посвящены использованию rdiff по сети, однако я нашел один, в котором упоминается, как это сделать на локальном хосте .

Вы должны взглянуть на ddar ( домашняя страница ).

Он является инкрементным в том смысле, что не передает идентичные части снимка. Он не является инкрементным в классическом значении слова, поскольку имеет дело со снимками.

Примечание: я сам не пробовал (но доверяю автору). Он может не выполнять то, что вы хотели бы достичь «из коробки», но все же на странице есть более похожие решения (например, ZFS ), поэтому в качестве отправной точки это может оказаться полезным.

Я думаю, что вы можете сделать это с LVM, это только теоретически, и это будет тратить огромное количество жесткого диска. Моя теория заключается в том, что вы можете получить корневую систему на логическом томе, а затем, если вы хотите сделать тест, вы можете создать моментальный снимок и перезагрузить компьютер, используя новый том.

Для работы снимков LVM нужен оригинальный том. Это связано с тем, что новый том содержит разницу между моментальным снимком и реальной файловой системой.

Если вы оставите систему в этом состоянии, вы начнете тратить место на диске при изменении новой файловой системы. Я не знаю, есть ли способ объединить снимок и окончательный файловый элемент. Конечно, вы можете перейти на другой логический том, но для этого вам понадобится вдвое больше места в вашей файловой системе плюс разница между вашей «точкой восстановления» и текущим состоянием.

И все это требует перезагрузок и далеко не является автоматическим.

Также предполагается, что несколько современных файловых систем идут по этому пути, например, zfs в системах Solaris или экспериментальные btrfs.

Это немного над моей головой, но звучит как часть того, что вы хотите сделать, это сделать частичное резервное копирование двоичных файлов (например, файлов образов разделов). Есть пакет, предназначенный для этого (я только что прочитал об этом - не пробовал.)

Посмотрите на Bup.

https://github.com/apenwarr/bup

Это может дать вам некоторые идеи.