Eu uso muito o Virtual Box para fins de teste de distribuição / aplicativos.

Um dos recursos que eu simplesmente amo é o instantâneo das máquinas virtuais, que salva o estado de uma máquina virtual e é capaz de restaurá-la à sua antiga glória se algo que você deu errado sem problemas e sem consumir todo o espaço em disco rígido.

Nos meus sistemas ativos, sei como criar uma imagem 1: 1 do sistema de arquivos, mas todas as soluções que conheci 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, ele cria backups incrementais?

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

Não estou procurando pelo clonezilla etc. Ele deve ser executado no próprio sistema sem nenhuma (ou quase nenhuma) intervenção do usuário, mas deve conter todos os dados dos sistemas de arquivos. Também não estou procurando um duplicitybackup de todo o seu sistema, excluindo algumas pastas de script + ddpara salvar seu mbr. Eu posso fazer isso sozinho, procurando uma elegância extra.

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

Não precisa ser diário, nem precisa de um horário. Basta executar de vez em quando e deixá-lo funcionar, de preferência com base em RAW e não em cópia de arquivo.

Para explicar a resposta de cprofitt (como sua resposta é incremental, como explicarei) ...

Primeiro você precisa saber sobre links físicos.

Os links físicos apontam para os dados que estão realmente no disco (o local físico) e você pode acessar os dados usando o link físico. Cada arquivo e diretório é um link físico 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. ("O backup de hoje" de ontem se torna "O backup de ontem", "O backup de ontem" de dois dias atrás se torna "O backup de dois dias atrás" e assim por diante)

   • A lista continua crescendo enquanto você deseja, no entanto, no script, ela possui apenas quatro instantâneos. (Ele executa todo o processo novamente para o próximo nível (por exemplo, uma semana - "O backup desta semana") e os gira, e é por isso que possui apenas 4).
   • A movimentação é feita no sentido inverso para evitar a substituição

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. Portanto, 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 e com o mesmo nome são links físicos para o mesmo arquivo no disco. Aqui estamos apenas lidando com dois instantâneos e alguns arquivos, mas o exemplo é escalável. (Exceto pelo fato de eu estar movendo os snapshots da maneira oposta aos scripts na resposta do cproffit)

O processo é este:

1. Há uma captura instantânea do sistema.

2. O instantâneo é cópias (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. Nota: agora temos apenas 1 cópia do arquivo A e do arquivo C e duas cópias do arquivo B armazenadas no disco rígido

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

5. Copie o instantâneo novamente (repita a etapa 2)

6. Rsync novamente. (Repita a etapa 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 deve ser executada, 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 cprofitt vinculado a) e é mais completo, mas é basicamente o descrito acima. O outro script é para agrupar snapshots e a outra parte da resposta do cprofitt fala sobre como automatizar o processo (usando cron) e verificar se o backup foi bem-sucedido.

Você pode alterar os nomes, portanto, em vez de os diretórios serem chamados "de hora em 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 um anterior) de volta para o diretório em que você estava fazendo os backups.

Para restaurar um único arquivo que ainda está em uma captura instantânea, vá para a captura instantânea 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 backup /(principalmente /boot, /home, /etc /roote /usr), em seguida, dizer ...

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

2. Desmonte a unidade.

3. Lembre-se de que você excluiu um arquivo (mesmo do lixo) que queria.

4. Conecte a unidade externa e recupere o arquivo.

5. Faça um backup (apenas 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 o snapshot-0 seja o último snapshot)

9. Instale o grub no MBR (sim, ele deve ser separado) - ou use-o ddpara fazer backup do mbr, como o cprofitt disse na parte inferior de sua resposta.

10. Reinicie.

O script precisa ser refinado (para obter apenas o que você deseja) e o procedimento acima assume que você não possui uma /homepartição. Se você criar (ou criar) um novo no disco e montá-lo no lugar mount /dev/sdxy /media/external/homeantes de copiar.

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 para suas necessidades, adicione-o aos trabalhos cron.

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 make_snapshot.sh seja executado a cada quatro horas na hora e daily_snapshot_rotate.sh seja executado todos os dias às 13:00 (ou seja, 13:00).

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

Se você deseja que ele seja executado a cada hora, adicione um trabalho cron para cada hora.

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

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

2. Configurar o rsnapshot e especificar o diretório de origem do backup

Abra o /etc/rsnapshot.conf e remova o comentário das 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 os diretórios de backup de destino em /etc/rsnapshot.conf, como mostrado abaixo. Neste exemplo,

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

   nano /etc/rsnapshot.conf

   backup / home / localhost /

2. Testar a configuração do rsnapshot

Execute 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. Verifique 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 horários 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. Verifique 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 Crontab para rsnapshot

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

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

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

---- Recuperação bare metal

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

Faça o backup de metadados importantes:

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

Faça 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, tenderia a desligar meu sistema se quisesse criar um arquivo de restauração baremetal.

Existem 2 maneiras de fazer backup incremental baseado em bloco

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

Instantâneos baseados em sistema de arquivos

O ZFS e o BTRFS fornecem instantâneos incrementais baseados em blocos ( BTRFS , ZFS (página 25) ). Você pode ter uma unidade em que você sincronize com ZFS ou BTRFS e captura instantânea.

Também há capturas instantâneas do LVM (mencionadas pelo cprofitt) que fornecem as mesmas capturas instantâneas incrementais baseadas em blocos.

Instantâneos baseados em programa

Existem vários programas de backup , no entanto, alguns se destacam para o efeito:

• Duplicidade
• Rdiff-backup

Eu sei que você mencionou especificamente que não está procurando algo como duplicidade, no entanto, 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 todas as instalações do linux têm o rsync (por exemplo, falta de núcleo pequeno (uma distribuição de 10 MB)) por padrão.

Duplicidade

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

A página do manual explica como funciona.

Rdiff-backup

Um programa cliente-servidor que cria, como duplicidade, diferenças de nível de bloco, mas armazena alterações do último ponto de restauração, para que o instantâneo mais recente seja o mais rápido de restaurar. Voltar no tempo (não o último instantâneo) exige que mais diferenças sejam analisadas e, portanto, é mais lento.

Algumas pessoas comparam o rdiff-backup ao rsnapshot (parece uma maneira mais automática do mentod do rsync). Quase todas as instruções sobre como usar o rdiff na rede, no entanto, encontrei uma que menciona como fazê-lo no host local .

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

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

Nota: Eu não tentei isso sozinho (mas confio no autor). Pode não fazer o que você deseja obter imediatamente , mas ainda existem soluções semelhantes na página (por exemplo, ZFS ); portanto, como ponto de partida, isso pode ser útil.

Eu acho que você pode fazer isso com o LVM, que é apenas teórico, e isso desperdiçará uma grande quantidade de disco rígido. Minha teoria é que você pode fazer com que seu sistema raiz fique com um volume lógico; se você quiser fazer um teste, poderá criar um instantâneo e reiniciar a máquina usando o novo volume.

Os instantâneos LVM precisam do volume original para funcionar. Isso ocorre porque o novo volume manté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 snapshoted e o arquivo definitivo. Certamente você pode dd para outro volume lógico, mas para isso 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.

Supõe-se também que vários sistemas de arquivos modernos funcionem dessa maneira, como o zfs em sistemas solaris ou os btrfs experimentais.

Este é 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 (eu acabei de ler sobre isso - não tentei).

Dê uma olhada no bup.

https://github.com/apenwarr/bup

Pode lhe dar algumas idéias.