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

Взгляните на bup.

https://github.com/apenwarr/bup

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

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

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

Они заставляют make_snapshot.sh запускаться каждые четыре часа в час, а daily_snapshot_rotate.sh - бегать каждый день в 13:00 (то есть в 1: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 и указание каталога источника резервного копирования [1137 ]

Откройте файл /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/ averageinternal.n‹/, как показано на последнем шаге.

   nano /etc/rsnapshot.conf

   backup / 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

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

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

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

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

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

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

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

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

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

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

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

1. Существует снимок системы.

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

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

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

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

6. [ 1154] 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. [1169 ] Установите grub в MBR (да, он должен быть отдельным) - или используйте dd для резервного копирования mbr, как сказал cprofitt внизу своего ответа.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Снимки программ на основе

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

• Duplicity [ 1117]
• Rdiff-backup

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

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

Duplicity

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

Справочная страница объясняет, как это работает.

Rdiff-backup

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

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