Utilizo mucho Virtual Box para fines de pruebas de distribución / aplicaciones.

Una de las características que simplemente me encantan son las instantáneas de máquinas virtuales, guarda el estado de una máquina virtual y puede restaurarla a su gloria anterior si algo que hiciste salió mal sin ningún problema y sin consumir todo el espacio en tu disco duro.

En mis sistemas en vivo, sé cómo crear una imagen 1: 1 del sistema de archivos, pero todas las soluciones que he conocido crearán una nueva imagen del sistema de archivos completo.

¿Hay algún programa / sistema de archivos que sea capaz de tomar una instantánea de un sistema de archivos actual, guardarlo en otra ubicación pero en lugar de crear una nueva imagen completa, crea copias de seguridad incrementales?

Para describir fácilmente lo que quiero, debería ser como ddimágenes de un sistema de archivos, pero en lugar de solo una copia de seguridad completa, también crearía incremental.

No estoy buscando clonezilla, etc. Debe ejecutarse dentro del sistema en sí sin intervención (o casi ninguna) del usuario, pero debe contener todos los datos de los sistemas de archivos. Tampoco estoy buscando una duplicitycopia de seguridad de todo su sistema, excepto algunas carpetas script + ddpara guardar su mbr. Puedo hacerlo yo mismo, buscando delicadeza extra.

Estoy buscando algo que pueda hacer antes de hacer cambios masivos en un sistema y luego, si algo está mal o si quemé mi disco duro después de derramar café sobre él, puedo arrancar desde un liveCD y restaurar una instantánea que funcione en un disco duro.

No necesita ser diario, ni siquiera necesita un horario. Simplemente ejecute de vez en cuando y deje que funcione y preferiblemente basado en RAW y no en copia de archivos.

Para explicar la respuesta de cprofitt (ya que su respuesta es incremental, como explicaré) ...

Primero necesitas saber sobre enlaces duros.

Los enlaces duros apuntan a los datos que están realmente en el disco (la ubicación física) y puede acceder a los datos utilizando el enlace duro. Cada archivo y directorio es un enlace rígido a la ubicación de los datos en el disco físico. Por lo tanto, si hay dos archivos (enlaces duros) que apuntan a la misma ubicación, los datos solo se almacenan una vez .

El proceso dado por cprofitt involucra:

1. Gire las copias de seguridad para crear un lugar para una nueva. ("La copia de seguridad de hoy" de ayer se convierte en "Copia de seguridad de ayer", "Copia de seguridad de ayer" de hace dos días se convierte en "Copia de seguridad de hace dos días", etc.)

   • La lista sigue creciendo todo el tiempo que desee, sin embargo, en el script solo tiene 4 instantáneas. (Realiza todo el proceso nuevamente para el siguiente nivel (por ejemplo, una semana - "Copia de seguridad de esta semana") y los rota, de modo que es por eso que solo tiene 4).
   • El movimiento se realiza en reversa para evitar sobrescribir

2. Copie la última instantánea que haya hecho (por ejemplo, "Copia de seguridad de ayer") en el lugar de la nueva (por ejemplo, "Copia de seguridad de hoy"), creando nuevos enlaces duros a los archivos existentes sin copiar el archivo. Por lo tanto, todos los archivos de la nueva instantánea apuntan a la misma ubicación que la anterior .

Un ejemplo ilustrado

En la imagen a continuación, los archivos del mismo color que tienen el mismo nombre de archivo son enlaces duros al mismo archivo en el disco. Aquí solo tratamos con dos instantáneas y algunos archivos, pero el ejemplo se escala. (Excepto por el hecho de que estoy moviendo instantáneas de manera opuesta a los scripts en la respuesta de cproffit)

El proceso es este:

1. Hay una instantánea del sistema.

2. La instantánea es copias (creando enlaces duros a los archivos existentes)

3. Rsync se ejecuta para actualizar la instantánea. Cuando se cambian los archivos, almacena el nuevo archivo como una nueva copia en el disco duro (por lo que la instantánea anterior no se modifica). En este ejemplo, el archivo B ha sido cambiado. Nota: ahora solo tenemos 1 copia del Archivo A y el Archivo C y dos copias del Archivo B almacenadas en el disco duro

4. Gire las instantáneas (en este caso, la instantánea 0 'se cae' y se elimina y cambio el nombre de la instantánea 1 a la instantánea 0)

5. Copie la instantánea de nuevo (repetición del paso 2)

6. Rsync nuevamente. (Repita el paso 3). Ahora tenemos 1 copia del archivo A y 2 copias del archivo B y el archivo C

Una versión simplificada de la [primera] secuencia de comandos (que no debe ejecutarse, solo como un trampolín) es 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 ;

Ahora el guión completo tiene la explicación completa aquí (como cprofitt vinculado a) y es más exhaustivo, pero es básicamente como el anterior. El otro script es para agrupar instantáneas y la otra parte de la respuesta de cprofitt habla sobre hacer que el proceso sea automático (usando cron) y verificar que la copia de seguridad se realizó correctamente.

Puede cambiar los nombres, por lo que en lugar de que los directorios se llamen "por hora ..." se denominan de otra manera y el script se ejecuta manualmente.

Para restaurar todo el lote, copie la última instantánea (o una anterior) nuevamente en el directorio del que estaba haciendo las copias de seguridad.

Para restaurar un solo archivo que todavía está en una instantánea, vaya a la instantánea y cópiela nuevamente a donde pertenece.

El medio de respaldo puede ser un disco duro externo (debe ser ext2 / ext3 / ext4). Si usted fue una copia de seguridad /(sobre todo /boot, /home, /etc /rooty /usr), entonces, digamos ...

1. Usted monta la unidad externa, realiza la copia de seguridad y crea la última instantánea.

2. Desmontar el disco.

3. Recuerde que eliminó un archivo (incluso de la papelera) que deseaba.

4. Conecte la unidad externa y recupere el archivo.

5. Haga una copia de seguridad (solo para estar seguro)

6. Desconecte la unidad y vaya a viajar ...

7. Tenga en cuenta que una computadora portátil y la lava no se mezclan.

8. Con su nueva computadora portátil ejecutando un CD en vivo, formatee la unidad interna, monte su unidad externa y luego cp -a /media/external/snapshot-0/* /media/internal-drive(suponiendo que la instantánea 0 es la última instantánea)

9. Instale grub en el MBR (sí, tiene que estar separado), o ddúselo para respaldar el mbr, como ha dicho cprofitt al final de su respuesta.

10. Reiniciar.

El script debe ser refinado (para obtener solo lo que desea) y el procedimiento a continuación supone que no tiene una /homepartición. Si lo hace (o lo hizo), cree uno nuevo en el disco y móntelo en su lugar mount /dev/sdxy /media/external/homeantes de copiarlo.

Puedes usar 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;

y el 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;

Después de crear el script según sus necesidades, agréguelo a los trabajos cron.

crontab -e

agregue lo siguiente:

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

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

Causan que make_snapshot.sh se ejecute cada cuatro horas por hora y daily_snapshot_rotate.sh se ejecute todos los días a las 13:00 (es decir, 1:00 PM).

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

Si desea que se ejecute cada hora, agregará un trabajo cron por cada hora.

Otra opción posible es usar rsnapshot

1. Instale rsnapshot (disponible en el centro de software)

2. Configurar rsnapshot y especificar directorio de origen de respaldo

Abra /etc/rsnapshot.conf y descomente las siguientes líneas.

# 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 sus directorios de copia de seguridad de destino en /etc/rsnapshot.conf como se muestra a continuación. En este ejemplo,

   / home - directorio de origen que debe ser respaldado localhost / - directorio de destino donde se almacenará la copia de respaldo. Tenga en cuenta que este directorio se creará en el directorio /.snapshots/{internal.n}/ como se muestra en el último paso.

   nano /etc/rsnapshot.conf

   copia de seguridad / inicio / localhost /

2. Probar la configuración de rsnapshot

Realice la prueba de configuración para asegurarse de que rsnapshot esté configurado correctamente y listo para realizar la copia de seguridad de rsync de Linux.

# rsnapshot configtest
Syntax OK

1. Verifique la configuración de copia de seguridad por hora de rsnapshot

Puede realizar copias de seguridad de directorios o archivos de Linux a varios intervalos. De manera predeterminada, se configuran las copias de seguridad por hora y por día.

Verifique la configuración de copia de seguridad 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 la configuración de copia de seguridad diaria de rsnapshot

Verifique que el proceso diario de copia de seguridad rsnapshot cwrsync esté configurado correctamente

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

1. Agregar entrada Crontab para rsnapshot

Una vez que haya verificado que las configuraciones de copia de seguridad rsync por hora y diaria están configuradas correctamente en la utilidad rsnapshot cwrsync, es hora de configurar este cachorro en el crontab como se muestra a continuación.

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

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

---- Recuperación de metal desnudo

Usaría dd y tar para hacer la recuperación de metal desnudo.

Copia de seguridad de metadatos importantes:

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

Copia de seguridad del sistema operativo:

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


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

Yo personalmente tendería a desconectar mi sistema si quisiera hacer un archivo de restauración de metal desnudo.

Hay 2 formas de hacer copias de seguridad incrementales basadas en bloques

• Instantáneas basadas en el sistema de archivos
• Instantáneas basadas en programas

Instantáneas basadas en el sistema de archivos

Tanto ZFS como BTRFS proporcionan instantáneas incrementales basadas en bloques ( BTRFS , ZFS (página 25) ). Podría tener una unidad que sincronice con ZFS o BTRFS e instantánea.

También hay instantáneas LVM (mencionadas por cprofitt) que proporcionan las mismas instantáneas incrementales basadas en bloques.

Instantáneas basadas en programas

Hay varios programas de respaldo , sin embargo, algunos sobresalen para este propósito:

• Duplicidad
• Rdiff-backup

Sé que mencionaste específicamente que no estás buscando algo como la duplicidad, sin embargo, pensé que podría mencionar algunas características.

Sin embargo, estos programas requieren que los instales para restaurar. La belleza de algo como rsync es que casi todas las instalaciones de Linux tienen rsync (por ejemplo, falta un núcleo pequeño (una distribución de 10 MB)) de forma predeterminada.

Duplicidad

Simplemente almacena el diff (nivel de bloque) y luego los comprime y los cifra. Esto conduce a un almacenamiento aún menor que el método rsync, sin embargo (al menos en la forma en que lo veo) el sistema de archivos necesitará ser reconstruido, lo que llevará tiempo (si está utilizando copias de seguridad incrementales con él, y depende del tiempo desde última copia de seguridad completa)

La página del manual explica cómo funciona.

Rdiff-backup

Un programa cliente-servidor que crea, como duplicidad, diferencias de nivel de bloque, sin embargo almacena los cambios desde el último punto de restauración, por lo que la última instantánea es la más rápida de restaurar. Retroceder en el tiempo (no la última instantánea) requiere que se analicen más diferencias y, por lo tanto, es más lento.

Algunas personas comparan rdiff-backup con rsnapshot (parece una forma más automática del método rsync). Casi todos los procedimientos se centran en usar rdiff en la red, sin embargo, encontré uno que menciona cómo hacerlo en localhost .

Deberías echar un vistazo a ddar ( página de inicio ).

Es incremental en el sentido de no transferir las partes idénticas de la instantánea. No es incremental en el significado clásico de la palabra, ya que se trata de instantáneas.

Nota: No lo he intentado yo mismo (pero confío en el autor). Es posible que no haga lo que le gustaría lograr de forma inmediata, pero aún existen soluciones más similares en la página (por ejemplo, ZFS ), por lo que, como punto de partida, podría resultar útil.

Creo que puede hacer esto con LVM, que es solo teórico, y desperdiciará una gran cantidad de disco duro. Mi teoría es que puede hacer que su sistema raíz viva en un volumen lógico, luego, si desea hacer una prueba, puede crear una instantánea y reiniciar la máquina usando el nuevo volumen.

Las instantáneas LVM necesitan el volumen original para funcionar. Esto se debe a que el nuevo volumen mantiene la diferencia entre la instantánea y el sistema de archivos real.

Si deja el sistema en este estado, comenzará a desperdiciar espacio en disco a medida que cambie el nuevo sistema de archivos. No sé si hay una manera de consolidar el sistema de archivos instantáneo y definitivo. Seguramente puede acceder a otro volumen lógico, pero para esto necesitará el doble del espacio de su sistema de archivos más la diferencia entre su "punto de recuperación" y el estado actual.

Y todo esto requiere reinicios y está lejos de ser automático.

También se supone que varios sistemas de archivos modernos van de esta manera, como zfs en sistemas solaris o los btrfs experimentales.

Esto está un poco sobre mi cabeza, pero parece que parte de lo que quieres hacer es hacer copias de seguridad parciales de archivos binarios (como archivos de imagen de partición). Hay un paquete diseñado para hacer eso (acabo de leerlo, no lo he probado).

Echa un vistazo a bup.

https://github.com/apenwarr/bup

Puede darte algunas ideas.