Como criar e restaurar instantâneos incrementais do disco rígido

Question

Eu uso muito o Virtual Box para fins de teste de distro / aplicações.

Um dos recursos que simplesmente adoro é o snapshot de máquinas virtuais, ele salva um estado de uma máquina virtual e é capaz de restaurá-lo à sua antiga glória, se algo que você fez deu errado sem problemas e sem consumir seu disco rígido espaço em disco.

Nos meus sistemas ao vivo, sei como criar uma imagem 1: 1 do sistema de arquivos, mas todas as soluções que conheço criarão uma nova imagem do sistema de arquivos completo.

Existem programas / sistemas de arquivos capazes de tirar um instantâneo de um sistema de arquivos atual, salvá-lo em outro local, mas, em vez de criar uma nova imagem completa, cria backups incrementais?

Para descrever facilmente o que eu quero, ele deve ser como dd images de um sistema de arquivos, mas em vez de apenas um backup completo, ele também criaria incremental.

Eu não estou procurando por clonezilla, etc. Ele deve ser executado dentro do próprio sistema com nenhuma (ou quase nenhuma) intervenção do usuário, mas contém todos os dados dos sistemas de arquivos. Eu também não estou procurando um duplicity backup seu todo o sistema, excluindo algumas pastas script + dd para salvar seu mbr. Eu mesmo posso fazer isso, procurando por sutileza extra.

Estou procurando algo que eu possa fazer antes de fazer grandes alterações em um sistema e, em seguida, se algo estiver errado ou eu queimei meu disco rígido depois de derramar café nele, posso inicializar a partir de um liveCD e restaurar um instantâneo em funcionamento. disco rígido.

Não precisa ser diário, nem precisa de um cronograma. Basta executar de vez em quando e deixar o seu trabalho e de preferência RAW baseado não baseado em cópia de arquivo.

Answer 1

Para explicar a resposta do cprofitt (como sua resposta é incremental, como vou explicar) ...

Primeiro, você precisa saber sobre hard links.

Os links físicos apontam para os dados que estão realmente no disco (a localização física) e você pode acessar os dados usando o link físico. Cada arquivo e diretório é um link rígido para o local dos dados no disco físico. Portanto, se houver dois arquivos (links físicos) apontando para o mesmo local, os dados serão armazenados apenas uma vez .

O processo dado pelo cprofitt envolve:

1. Gire os backups para criar um local para um novo. ("Backup de hoje" de ontem torna-se "backup de ontem", "Backup de ontem" de dois dias atrás torna-se "backup de dois dias atrás" e assim por diante)

   • A lista continua crescendo o tempo que você quiser, no entanto, no script, ela só tem 4 instantâneos. (Ele faz todo o processo novamente para o próximo nível (por exemplo, uma semana - "Backup desta semana") e os rotaciona, e é por isso que tem apenas 4).
   • A movimentação é feita em sentido inverso para evitar sobrescrever

2. Copie o instantâneo mais recente que você fez (por exemplo, "backup de ontem") para o local do novo (por exemplo, "backup de hoje"), criando novos links físicos para os arquivos existentes sem copiar o arquivo. Assim, todos os arquivos no novo instantâneo estão apontando para o mesmo local que o anterior.

Um exemplo ilustrado

Na figura abaixo, arquivos da mesma cor que possuem o mesmo nome de arquivo são hard links para o mesmo arquivo no disco. Aqui estamos lidando apenas com dois instantâneos e alguns arquivos, mas o exemplo é escalável. (Exceto pelo fato de eu estar movendo os instantâneos da maneira oposta aos scripts na resposta do cproffit)

O processo é este:

1. Existe um instantâneo do sistema.

2. O instantâneo é copiado (criando links físicos para os arquivos existentes)

3. O Rsync é executado para atualizar o instantâneo. Quando os arquivos são alterados, ele armazena o novo arquivo como uma nova cópia no disco rígido (para que o instantâneo mais antigo não seja alterado). Neste exemplo, o arquivo B foi alterado. Observação: agora temos apenas uma cópia do Arquivo A e do Arquivo C e duas cópias do Arquivo B armazenadas no disco rígido

4. Gira os instantâneos (nesse caso, o instantâneo 0 'cai' e é excluído e eu renomeio o instantâneo 1 para o instantâneo 0)

5. Copie o instantâneo agin (repita o passo 2)

6. Rsync novamente. (Repetir do passo 3). Agora temos 1 cópia do Arquivo A e 2 cópias do Arquivo B e do Arquivo C

Uma versão simplificada do [primeiro] script (não para ser executado, apenas como um trampolim) é esta:

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

Agora, o (s) script (s) completo (s) tem a explicação completa aqui (como o cprofitt está vinculado) e é mais completo, mas é basicamente como acima. O outro script é para agrupar os instantâneos e a outra parte da resposta do cprofitt fala sobre tornar o processo automático (usando o cron) e verificar se o backup foi bem-sucedido.

Você pode alterar os nomes, então, em vez de os diretórios serem chamados de "por hora ...", eles são chamados de outra coisa e o script é executado manualmente.

Para restaurar o lote inteiro, copie o instantâneo mais recente (ou anterior) de volta para o diretório do qual você estava fazendo os backups.

Para restaurar um único arquivo que ainda está em um instantâneo, vá para o instantâneo e copie-o de volta para onde ele pertence.

A mídia de backup pode ser um disco rígido externo (deve ser ext2 / ext3 / ext4). Se você estava fazendo o backup de / (principalmente /boot , /home , /etc /root e /usr ), digamos ...

1. Você monta a unidade externa, executa o backup e cria o instantâneo mais recente.

2. Desmonte a unidade.

3. Lembre-se de que você excluiu um arquivo (mesmo da lixeira) desejado.

4. Conecte a unidade externa e recupere o arquivo.

5. Faça um backup (só para ter certeza)

6. Desconecte a unidade e vá viajar ...

7. Perceba que um laptop e lava não se misturam.

8. Com seu novo laptop executando um CD ao vivo, formate a unidade interna, monte sua unidade externa e, em seguida, cp -a /media/external/snapshot-0/* /media/internal-drive (supondo que a captura instantânea-0 seja a última imagem instantânea)

9. Instale o grub no MBR (sim, ele tem que ser separado) - ou use dd para fazer o backup do mbr, como cprofitt disse no final de sua resposta.

10. Reinicie.

O script precisa ser refinado (para obter apenas o material desejado) e o procedimento aove pressupõe que você não possui uma partição /home . Se você criar (ou tiver) um novo no disco e montá-lo no lugar com mount /dev/sdxy /media/external/home antes de copiar.

    

Answer 2

Você pode usar o 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;

e o segundo:

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;

Depois de criar o script de acordo com as suas necessidades, adicione-o a tarefas agendadas.

  

crontab -e

adicione o seguinte:

  

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

     

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

Eles fazem com que o make_snapshot.sh seja executado a cada quatro horas na hora e o daily_snapshot_rotate.sh seja executado todos os dias às 13:00 (ou seja, 1:00 PM).

fonte: link

* * * * * 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)

Se você deseja que ele seja executado por hora, você adicionaria uma tarefa cron para cada hora.

Outra opção possível é usar o rsnapshot

1. Instale o rsnapshot (disponível no centro de software)

2. Configure o rsnapshot e especifique o diretório de origem de backup

Abra o arquivo /etc/rsnapshot.conf e descomente as seguintes linhas.

# 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. Defina seus diretórios de backup de destino em /etc/rsnapshot.conf conforme mostrado abaixo. Neste exemplo,

   / home - diretório de origem que deve ser armazenado em backup localhost / - diretório de destino onde o backup será armazenado. Por favor, note que este diretório será criado no diretório /.snapshots/{internal.n}/ como mostrado na última etapa.

   nano /etc/rsnapshot.conf

   backup / home / localhost /

2. Teste a configuração do rsnapshot

Realize o teste de configuração para garantir que o rsnapshot esteja configurado corretamente e pronto para executar o backup do linux rsync.

# rsnapshot configtest
Syntax OK

1. Verificar a configuração de backup por hora do rsnapshot

Você pode fazer backup de diretórios ou arquivos do Linux em vários intervalos. Por padrão, os backups por hora e diários são configurados.

Verifique a configuração de backup por hora.

# 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. Verificar a configuração de backup diário do rsnapshot

Verifique se o processo diário de backup do rsnapshot cwrsync está configurado corretamente.

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

1. Adicionar entrada do Crontab para rsnapshot

Depois de verificar se as configurações de backup por hora e diárias do rsync estão configuradas corretamente no utilitário rsnapshot cwrsync, é hora de configurar esse filhote no crontab, conforme mostrado abaixo.

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

fonte: link

---- Recuperação bare metal

Eu usaria o dd e o tar para fazer a recuperação baremetal.

Backup de metadados importantes:

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

Backup do sistema operacional:

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


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

Eu, pessoalmente, tendia a deixar o meu sistema off-line se eu quisesse fazer um arquivo de restauração baremetal.

    

Answer 3

Você deve dar uma olhada em ddar ( página inicial ).

É incremental no sentido de não transferir partes idênticas do instantâneo. Não é incremental no significado clássico da palavra, uma vez que está lidando com instantâneos.

Nota: eu não tentei isso sozinho (mas confio no autor). Pode não fazer o que você gostaria de obter, mas ainda existem soluções similares na página (por exemplo, ZFS ), então como ponto de partida, possivelmente seja útil.

    

Answer 4

Existem 2 maneiras de fazer backup incremental baseado em bloco

• Instantâneos baseados no sistema de arquivos
• Instantâneos baseados no programa

Instantâneos baseados no sistema de arquivos

Ambos ZFS e BTRFS fornecem instantâneos incrementais baseados em blocos ( BTRFS , ZFS (página 25) ). Você poderia ter uma unidade que você rsync para que seja ou ZFS ou BTRFS e instantâneo.

Há também instantâneos do LVM (mencionados por cprofitt) que fornecem o mesmos instantâneos incrementais baseados em blocos.

Instantâneos baseados em programas

Existe um vários programas de backup , no entanto alguns se destacam para o propósito:

• Duplicidade
• Rdiff-backup

Eu sei que você mencionou especificamente que você não está procurando por algo parecido com a duplicidade, mas eu pensei em mencionar alguns recursos.

No entanto, esses programas exigem que você os instale para restaurar. A beleza de algo como o rsync é que quase toda instalação do Linux tem o rsync (por exemplo, tiny core (uma distribuição de 10MB) está faltando) por padrão.

Duplicidade

Ele apenas armazena o diff (nível de bloco) e depois os compacta e criptografa. Isso leva a um armazenamento ainda menor do que o método rsync, no entanto (pelo menos do jeito que eu vejo) o sistema de arquivos precisará ser reconstruído, o que levará tempo (se você estiver usando backups incrementais com ele, e isso dependerá do tempo desde último backup completo)

A página de manual explica como funciona.

Rdiff-backup

Um programa cliente-servidor que cria, como duplicidade, diferenças de nível de bloco, no entanto, armazena as alterações do ponto de restauração mais recente, de modo que o instantâneo mais recente é o mais rápido a ser restaurado. Retroceder no tempo (não o instantâneo mais recente) requer que mais diffs sejam analisados e, portanto, é mais lento.

Algumas pessoas comparam rdiff-backup ao rsnapshot (parece uma forma mais automática do mentod rsync). Quase todos os how-tos se concentram no uso do rdiff na rede, no entanto, encontrei um que menciona < href="http://arctic.org/~dean/rdiff-backup/unattended.html"> como fazer isso em localhost .

    

Answer 5

Eu acho que você pode fazer isso com o LVM, é apenas teórico, e vai desperdiçar uma grande quantidade de disco rígido. Minha teoria é que você pode ter seu sistema root vivendo em um volume lógico, então se você quiser fazer um teste você pode criar um snapshot e reiniciar a máquina usando o novo volume.

Os instantâneos do LVM precisam que o volume original funcione. Isso ocorre porque o novo volume contém a diferença entre o instantâneo e o sistema de arquivos real.

Se você deixar o sistema nesse estado, começará a desperdiçar espaço em disco à medida que o novo sistema de arquivos for alterado. Não sei se existe uma maneira de consolidar o arquivo de imagem instantâneo e definitivo. Certamente você pode dd para outro volume lógico, mas para isso você precisará do dobro do espaço do seu sistema de arquivos mais a diferença entre o seu "ponto de recuperação" e o estado atual.

E tudo isso requer reinicializações e está longe de ser automático.

Também se supõe que vários sistemas de arquivos modernos sejam assim, como o zfs em sistemas solaris ou o btrfs experimental.

    

Answer 6

Esse é um pouco demais, mas parece que parte do que você quer fazer é fazer backups parciais de arquivos binários (como arquivos de imagem de partição). Há um pacote projetado para fazer isso (Acabei de ler sobre isso - não tentei.)

Dê uma olhada no bup.

link

Isso pode lhe dar algumas ideias.