Verificar y restaurar respaldos

1. Un respaldo que nadie probó

Un script de respaldo que termina sin errores prueba muy poco. Estas son algunas de las formas en que un respaldo falla sin que nadie se entere:

Ninguna de estas fallas produce un error en el script de respaldo. Todas se descubren, eso sí, al intentar restaurar. La conclusión es la de todo este tema: la única prueba de que un respaldo sirve es restaurarlo, y como hacerlo a mano con regularidad es exactamente el tipo de tarea que nadie hace, hay que automatizarlo.

2. Qué significa verificar

«Verificar un respaldo» puede querer decir cosas muy distintas, de lo más barato a lo más costoso:

Los dos primeros niveles cuestan casi nada y deberían comprobarse siempre. Los siguientes leen los datos, y en respaldos grandes llevan tiempo, de modo que se hacen con menos frecuencia, o sobre una muestra. El script de este tema combina los niveles 1, 2, 3 y 5.

3. Las sumas de verificación

Una suma de verificación o hash es un valor corto calculado a partir de todo el contenido de un archivo, con una propiedad clave: cualquier cambio en el contenido, aunque sea de un solo bit, produce un valor completamente distinto. Guardar la suma de un archivo permite comprobar más tarde, sin tener otra copia para comparar, si sigue intacto.

El algoritmo recomendado hoy es SHA-256, que produce 256 bits, escritos como 64 caracteres hexadecimales. En Linux lo calcula sha256sum:

$ sha256sum hola.txt
133ee989293f92736301280c6f14c89d521200c17dcdcecca30cd20705332d44  hola.txt
$ printf 'hola!\n' | sha256sum                # un carácter más
f0f783f2573e107ca66229778c392429cb60969e81a28c2629677917df56cc82  -
$ printf 'Hola\n' | sha256sum                 # una mayúscula
5aeabdff63d243ede0cf64001a9ae5396e12f02eeb78a6e5da2ff54ceb9d7a6b  -

Cada línea tiene la suma, dos espacios y el nombre del archivo, o un guion si se leyó la entrada estándar. Ese mismo formato es el que lee la opción -c, que recalcula las sumas de una lista guardada y las compara:

$ sha256sum informe.odt fotos.tar > SHA256SUMS
# … tiempo después:
$ sha256sum -c SHA256SUMS
informe.odt: OK
fotos.tar: FAILED
sha256sum: WARNING: 1 computed checksum did NOT match
$ echo $?
1

Existen otros algoritmos, con el mismo uso: md5sum y sha1sum son más rápidos, y siguen sirviendo para detectar daños accidentales, pero ya no resisten a alguien que quiera falsificar un archivo a propósito, de modo que no conviene usarlos para nada que tenga que ver con la seguridad; b2sum, de la familia BLAKE2, es seguro y más rápido que SHA-256. Ante la duda, SHA-256.

4. Verificar un archivo recibido

El uso más cotidiano de las sumas es comprobar que un archivo llegó intacto. El paquete del tema 36 se distribuía con su archivo .sha256, y quien lo recibe lo verifica en el mismo directorio:

$ sha256sum -c mayus-1.4.0.tar.gz.sha256
mayus-1.4.0.tar.gz: OK
# Si la suma publicada está en una página web y no en un archivo:
$ echo "9d1c…e47a  ubuntu-24.04.iso" | sha256sum -c -
ubuntu-24.04.iso: OK

Para que la comprobación proteja de verdad contra un archivo alterado, y no solo contra uno dañado, la suma tiene que obtenerse por un camino distinto del archivo: si alguien pudo modificar el paquete en el servidor, también pudo modificar el .sha256 que está junto a él. Por eso los proyectos serios firman además sus sumas con gpg. Para respaldos, la amenaza principal es el daño accidental, y guardar las sumas aparte alcanza.

Las sumas sirven también para transferencias: después de copiar un respaldo a otra máquina, calcular la suma en los dos lados y compararla confirma que la copia es idéntica, byte a byte.

5. Un manifiesto por respaldo

Para un respaldo con miles de archivos, como las instantáneas del tema 37, se guarda un manifiesto: la lista de las sumas de todos sus archivos, calculada justo después de hacer la copia. Se genera combinando find y xargs como en el tema 32, desde dentro de la instantánea, para que las rutas sean relativas:

cd /mnt/copias/2026-10-15
find . -type f -print0 | sort -z | xargs -0 -r sha256sum -- > /mnt/copias/.manifiestos/2026-10-15.sha256

# Más adelante, para comprobarla:
cd /mnt/copias/2026-10-15
sha256sum --quiet -c /mnt/copias/.manifiestos/2026-10-15.sha256

• Las rutas son relativas (./home/ana/…), de modo que el manifiesto sirve también para comprobar una restauración hecha en otro directorio: basta con entrar en él y ejecutar el mismo sha256sum -c.
• Los nombres viajan separados por nulos y sha256sum escribe con un formato especial, que empieza con una barra invertida, los que contienen saltos de línea, de modo que ningún nombre rompe la lista.
• sort -z ordena la lista, para que dos manifiestos de instantáneas distintas se puedan comparar con diff, y ver exactamente qué cambió entre una y otra.
• El manifiesto se guarda fuera de la instantánea. Dentro, formaría parte de los datos que describe, y con instantáneas de enlaces duros, modificar un archivo dentro de una de ellas podría afectar a las otras que lo comparten.

$ cd /mnt/copias/2026-10-15 && sha256sum --quiet -c ../.manifiestos/2026-10-15.sha256
./home/ana/documentos/tesis.odt: FAILED
sha256sum: ./home/ana/fotos/2019/playa.jpg: No such file or directory
./home/ana/fotos/2019/playa.jpg: FAILED open or read
sha256sum: WARNING: 1 listed file could not be read
sha256sum: WARNING: 1 computed checksum did NOT match

Dos problemas distintos: un archivo cuyo contenido cambió desde que se hizo el respaldo, y otro que desapareció. En un respaldo, que no debería cambiar nunca, cualquiera de los dos es una alarma. Calcular las sumas de un respaldo grande lleva tiempo, porque hay que leer todos sus datos; con xargs -P, como vimos en el tema 32, se reparte entre varios procesadores, aunque casi siempre el límite es la velocidad del disco.

6. Comprobar un archivo tar

Un respaldo en un solo archivo comprimido tiene sus propias comprobaciones, cada una más profunda que la anterior:

# 1. ¿Está sana la compresión? Lee todo el archivo y verifica sus sumas internas
gzip -t casa-2026-10-15.tar.gz                    # o zstd -t, o xz -t

# 2. ¿Se puede leer el tar entero? Lo recorre sin extraer nada
tar -tzf casa-2026-10-15.tar.gz > /dev/null

# 3. ¿Coincide con los archivos actuales? Compara contenido, tamaños, fechas y permisos
tar --compare -zf casa-2026-10-15.tar.gz --directory=/home

Las dos primeras detectan un archivo dañado o truncado: gzip guarda una suma de su contenido, y tar falla si encuentra un encabezado ilegible o un final prematuro. La tercera, --compare (-d), compara cada archivo del respaldo con el que está en el disco, y es útil justo después de hacer la copia; días después, mostrará también todo lo que cambió legítimamente desde entonces. Y como un .tar.gz es un único archivo, la forma más simple de detectar más tarde cualquier daño es guardar su suma al crearlo, como hacía build.sh con su paquete.

7. Comparar con el origen

Las sumas comprueban que el respaldo no cambió desde que se hizo. Para comprobar que se hizo bien, es decir, que es igual al original, hay que comparar con él. rsync lo hace sin copiar nada:

$ rsync -an --checksum --itemize-changes /home/ana/ /mnt/copias/2026-10-15/home/ana/
>fc........ documentos/notas.txt
$ diff -rq /home/ana/documentos /mnt/copias/2026-10-15/home/ana/documentos
Files /home/ana/documentos/notas.txt and /mnt/copias/2026-10-15/home/ana/documentos/notas.txt differ

Con --checksum (-c), rsync no se fía del tamaño y la fecha, sino que compara las sumas de cada archivo; la c en la tercera posición indica una diferencia de contenido. diff -rq hace lo mismo con dos árboles de directorios, sin mostrar los detalles. Los dos leen todos los datos de ambos lados, y sobre un origen en uso siempre encontrarán los archivos que cambiaron desde la copia, que no son errores. Por eso esta comparación es más útil justo después del respaldo, o sobre datos que no cambian, como un archivo de fotos de años anteriores.

8. La corrupción silenciosa

Los discos, las memorias USB y las cintas no guardan los datos para siempre. Con los años, y a veces mucho antes, algunos bits cambian sin que nada lo advierta: el disco devuelve datos distintos de los que se escribieron, sin informar ningún error. Es la corrupción silenciosa, y es especialmente traicionera en los respaldos, porque se los lee poco: un daño puede pasar años inadvertido, mientras la rotación borra una tras otra las copias sanas.

La defensa es leer y comprobar los respaldos periódicamente, no solo al crearlos. Con instantáneas de --link-dest hay una ventaja: los archivos que no cambian son los mismos datos en todas las instantáneas, de modo que comprobar la más reciente comprueba también lo que comparte con las anteriores. Los sistemas de archivos con sumas propias, como Btrfs y ZFS, hacen esto por sí mismos: guardan una suma de cada bloque, la comprueban en cada lectura, y con la operación llamada scrub recorren el disco entero buscando daños; si tienen una segunda copia del bloque, incluso lo reparan.

9. Restaurar sin agravar el problema

Una restauración casi siempre ocurre en un mal momento: con prisa, con nervios y con alguien esperando. Es cuando más fácil es empeorar las cosas, por ejemplo, restaurando encima de los datos que todavía se podían salvar o copiando en el sentido equivocado. Un procedimiento simple, escrito de antemano, evita la mayoría de los errores:

1. Detener los daños. Si un programa sigue borrando o cifrando archivos, o un disco está fallando, primero se detiene eso. Y no se toca el respaldo más que para leerlo: conviene montarlo en modo de solo lectura. detener
2. Elegir la copia. La más reciente no siempre es la buena: si el daño ocurrió hace tres días, hay que ir a la de hace cuatro. Comparar los manifiestos de dos instantáneas con diff ayuda a saber cuándo cambió algo. elegir
3. Restaurar a un directorio aparte, nunca directamente sobre el original. Allí se revisa que los archivos estén y que abran, y se comprueban con el manifiesto. aparte
4. Reemplazar, recién entonces, y guardando lo que había, por si contenía algo más nuevo que el respaldo. reemplazar

# Un solo archivo, desde la instantánea de hace cuatro días
cp -a /mnt/copias/2026-10-11/home/ana/documentos/tesis.odt /tmp/rescate/

# Un directorio entero, a un lugar aparte; se revisa, y luego se reemplaza el original
sudo rsync -aHAX --numeric-ids /mnt/copias/2026-10-11/home/ana/documentos/ /tmp/rescate/documentos/
cd /tmp/rescate && …                                # revisar
mv /home/ana/documentos /home/ana/documentos.danado
sudo rsync -aHAX --numeric-ids /tmp/rescate/documentos/ /home/ana/documentos/

Para conservar dueños y permisos, la restauración la hace root, con las mismas opciones con que se hizo la copia. Con respaldos de tar incrementales, se extrae la cadena en orden, como vimos en el tema 37. Y lo más importante de todo: ese procedimiento, junto con dónde están los respaldos, cómo se accede a ellos y dónde está la clave si están cifrados, tiene que estar escrito en algún lugar que no sea el equipo que se puede perder.

10. Una prueba de restauración automática

Restaurar todo un respaldo para probarlo es costoso, pero restaurar una parte, elegida al azar, es barato y muy revelador. Una prueba automática, programada cada semana, puede comprobar:

• Que la última copia es reciente: si tiene más de un día, algo dejó de funcionar.
• Que están los archivos testigo: una lista corta de archivos que no pueden faltar, como la contabilidad, la base de datos volcada o la carpeta de un proyecto. Detecta exclusiones y orígenes equivocados.
• Que todas las sumas coinciden con el manifiesto, lo que detecta daños en cualquier archivo.
• Que se puede restaurar: copia una muestra al azar a un directorio temporal, como lo haría una restauración real, y comprueba lo restaurado con el manifiesto. Como la muestra cambia en cada ejecución, con el tiempo recorre todo el respaldo.

La muestra al azar la elige shuf, que mezcla las líneas de su entrada; con -n 20, devuelve 20 líneas al azar del manifiesto. Y como la prueba solo produce un error cuando encuentra un problema, combinada con ejecutar-tarea del tema 34 o con un temporizador con OnFailure= del tema 35, solo molesta cuando hay que actuar.

11. Cuánto se puede perder y cuánto se tarda

Dos medidas resumen lo que un sistema de respaldos promete, y sirven para decidir cada qué tiempo copiar y qué probar:

La comprobación de antigüedad de la prueba automática vigila el RPO: si la última copia tiene dos días, el RPO prometido de un día ya no se cumple. El RTO solo se conoce midiendo: la prueba informa cuánto tardó en restaurar su muestra, y de vez en cuando conviene restaurar un respaldo entero en una máquina de prueba, cronometrarlo y anotar lo que hubo que hacer. Si restaurar 2 TB desde un servicio remoto lleva cuatro días, es mejor saberlo antes.

12. Un script completo

Este script trabaja sobre las instantáneas de respaldar, del tema 37. Tiene dos acciones: manifiesto, que se ejecuta después de cada respaldo, y comprobar, que hace la prueba de la sección 10.

#!/usr/bin/env bash
#
# verificar-respaldo — comprueba las instantáneas que crea respaldar (tema 37).
#
# Uso: verificar-respaldo manifiesto DESTINO [FECHA]
#      verificar-respaldo comprobar [-d DÍAS] [-n MUESTRA] [-t TESTIGOS] DESTINO
#
#   manifiesto  guarda las sumas SHA-256 de una instantánea (por omisión, la última)
#   comprobar   verifica la última: antigüedad, testigos, sumas y una restauración de prueba
#     -d  antigüedad máxima, en días (1)
#     -n  cantidad de archivos de la restauración de prueba (20)
#     -t  archivo con rutas que deben existir y no estar vacías, una por línea
#
set -euo pipefail
export LC_ALL=C

prog="${0##*/}"
problemas=0

uso() {
  echo "Uso: $prog manifiesto DESTINO [FECHA]" >&2
  echo "     $prog comprobar [-d DÍAS] [-n MUESTRA] [-t TESTIGOS] DESTINO" >&2
  exit 2
}
error() { echo "$prog: $*" >&2; exit 1; }
bien() { echo "ok    $*"; }
mal() { echo "MAL   $*"; problemas=$(( problemas + 1 )); }

ultima() {                             # la fecha de la instantánea más reciente
  find "$destino" -mindepth 1 -maxdepth 1 -type d \
       -name '[0-9][0-9][0-9][0-9]-[0-9][0-9]-[0-9][0-9]' -printf '%f\n' | sort | tail -n 1
}

manifiesto() {                         # las sumas de todos los archivos de la instantánea $1
  local inst="$destino/$1" salida="$destino/.manifiestos/$1.sha256"
  [[ -d "$inst" ]] || error "no existe la instantánea $1"
  mkdir -p "$destino/.manifiestos"
  (cd "$inst" && find . -type f -print0 | sort -z | xargs -0 -r sha256sum --) > "$salida.tmp"
  mv -- "$salida.tmp" "$salida"
  echo "$(wc -l < "$salida") archivos en $salida"
}

comprobar() {
  local fecha inst manif edad ruta salida linea
  fecha=$(ultima)
  [[ -n "$fecha" ]] || error "no hay instantáneas en $destino"
  inst="$destino/$fecha"
  manif="$destino/.manifiestos/$fecha.sha256"
  echo "Instantánea $fecha"

  # 1. ¿Es reciente?
  edad=$(( ( $(date +%s) - $(date -d "$fecha" +%s) ) / 86400 ))
  if (( edad <= max_dias )); then
    bien "tiene $edad días"
  else
    mal "tiene $edad días; el máximo es $max_dias"
  fi

  # 2. ¿Están los archivos que no pueden faltar?
  if [[ -n "$testigos" ]]; then
    while IFS= read -r ruta; do
      [[ -z "$ruta" || "$ruta" == \#* ]] && continue
      if [[ -s "$inst/$ruta" ]]; then
        bien "está $ruta"
      else
        mal "falta o está vacío: $ruta"
      fi
    done < "$testigos"
  fi

  # 3. ¿Coinciden todas las sumas?
  if [[ ! -f "$manif" ]]; then
    mal "no hay manifiesto; se crea con: $prog manifiesto $destino $fecha"
    return
  fi
  if salida=$(cd "$inst" && sha256sum --quiet -c -- "$manif" 2>&1); then
    bien "coinciden las $(wc -l < "$manif") sumas del manifiesto"
  else
    mal "hay archivos que no coinciden con el manifiesto:"
    printf '%s\n' "$salida" | head -n 20 | sed 's/^/        /'
  fi

  # 4. ¿Se puede restaurar? Una muestra al azar, a un directorio temporal
  local lineas=() rutas=() inicio
  while IFS= read -r linea; do
    [[ "$linea" == \\* ]] && continue  # nombres con caracteres especiales: se saltean
    lineas+=("$linea")
    rutas+=("${linea:66}")             # la suma ocupa 64 caracteres, y la siguen dos espacios
  done < <(shuf -n "$muestra" -- "$manif")
  (( ${#rutas[@]} )) || { mal "el manifiesto está vacío"; return; }

  prueba=$(mktemp -d)
  trap 'rm -rf -- "$prueba"' EXIT
  inicio=$SECONDS
  if ! salida=$(cd "$inst" && cp -a --parents -- "${rutas[@]}" "$prueba/" 2>&1); then
    mal "no se pudieron restaurar los archivos de prueba:"
    printf '%s\n' "$salida" | sed 's/^/        /'
  elif salida=$(printf '%s\n' "${lineas[@]}" | (cd "$prueba" && sha256sum --quiet -c - 2>&1)); then
    bien "restaurados y comprobados ${#rutas[@]} archivos al azar en $(( SECONDS - inicio )) s"
  else
    mal "archivos restaurados que no coinciden:"
    printf '%s\n' "$salida" | sed 's/^/        /'
  fi
}

(( $# >= 1 )) || uso
accion="$1"; shift
max_dias=1 muestra=20 testigos=""

case "$accion" in
  manifiesto)
    (( $# == 1 || $# == 2 )) || uso
    destino="${1%/}"
    [[ -d "$destino" ]] || error "no existe el destino: $destino"
    fecha="${2:-$(ultima)}"
    [[ -n "$fecha" ]] || error "no hay instantáneas en $destino"
    manifiesto "$fecha"
    ;;
  comprobar)
    while getopts ":d:n:t:" opcion; do
      case "$opcion" in
        d) max_dias="$OPTARG" ;;
        n) muestra="$OPTARG" ;;
        t) testigos="$OPTARG" ;;
        *) uso ;;
      esac
    done
    shift $(( OPTIND - 1 ))
    (( $# == 1 )) || uso
    [[ "$max_dias" =~ ^[0-9]+$ && "$muestra" =~ ^[1-9][0-9]*$ ]] || uso
    [[ -z "$testigos" || -r "$testigos" ]] || error "no se puede leer: $testigos"
    destino="${1%/}"
    [[ -d "$destino" ]] || error "no existe el destino: $destino"
    comprobar
    if (( problemas )); then
      echo "Problemas encontrados: $problemas"
      exit 1
    fi
    echo "Todo en orden"
    ;;
  *) uso ;;
esac

# Archivos que no pueden faltar en ningún respaldo
home/ana/documentos/contabilidad.ods
home/ana/proyectos/mayus/build.sh
var/backups/postgres/ventas.sql.gz
etc/hosts

$ sudo verificar-respaldo manifiesto /mnt/copias
48213 archivos en /mnt/copias/.manifiestos/2026-10-15.sha256
$ sudo verificar-respaldo comprobar -t /etc/respaldar/testigos /mnt/copias
Instantánea 2026-10-15
ok    tiene 0 días
ok    está home/ana/documentos/contabilidad.ods
ok    está home/ana/proyectos/mayus/build.sh
ok    está var/backups/postgres/ventas.sql.gz
ok    está etc/hosts
ok    coinciden las 48213 sumas del manifiesto
ok    restaurados y comprobados 20 archivos al azar en 1 s
Todo en orden
# … semanas después, con un problema en el disco y una exclusión mal escrita:
$ sudo verificar-respaldo comprobar -t /etc/respaldar/testigos /mnt/copias
Instantánea 2026-11-02
ok    tiene 0 días
ok    está home/ana/documentos/contabilidad.ods
MAL   falta o está vacío: home/ana/proyectos/mayus/build.sh
ok    está var/backups/postgres/ventas.sql.gz
ok    está etc/hosts
MAL   hay archivos que no coinciden con el manifiesto:
        ./home/ana/fotos/2019/playa.jpg: FAILED
        sha256sum: WARNING: 1 computed checksum did NOT match
MAL   archivos restaurados que no coinciden:
        ./home/ana/fotos/2019/playa.jpg: FAILED
        sha256sum: WARNING: 1 computed checksum did NOT match
Problemas encontrados: 3
$ echo $?
1

• Informa todos los problemas, no solo el primero: en lugar de terminar en el primer fallo, mal los cuenta y la prueba sigue, de modo que un solo informe muestra todo lo que hay que revisar. Al final, el código de salida es 1 si hubo alguno, que es lo que miran ejecutar-tarea y systemd.
• Los errores de los comandos se capturan con salida=$(… 2>&1) dentro de la condición, donde el modo estricto no detiene el script, y se muestran con sangría bajo el problema al que pertenecen.
• El manifiesto se escribe de forma atómica: primero a un .tmp y luego con mv, como en el tema 24. Si el cálculo falla a mitad de camino, por ejemplo porque un archivo no se pudo leer, no queda un manifiesto incompleto con el nombre definitivo.
• La restauración de prueba usa el camino real: copia los archivos con cp -a --parents, que reproduce sus rutas dentro del directorio temporal, y los comprueba con las mismas líneas del manifiesto, que tienen rutas relativas. El trap borra el directorio temporal al terminar, haya ido bien o mal.
• Los nombres raros no la rompen: las líneas del manifiesto que empiezan con una barra invertida, que corresponden a nombres con saltos de línea, se excluyen de la muestra; los nombres con espacios funcionan, porque la ruta se toma por posición, a partir del carácter 66, y no partiendo la línea en palabras.
• La antigüedad sale del nombre de la instantánea, la fecha en que se hizo, y no de la fecha de modificación del directorio, que rsync puede cambiar.

Para integrarlo con el respaldo diario, el servicio del tema 35 puede tener dos líneas ExecStart, que se ejecutan en orden, la segunda solo si la primera terminó bien: respaldar … y verificar-respaldo manifiesto /mnt/copias. La comprobación va en otro temporizador, semanal, con OnFailure= para el aviso.

13. Errores frecuentes

14. Resumen

• Un respaldo puede no hacerse, copiar lo que no es, dañarse o ser imposible de restaurar sin que el script de respaldo dé ningún error; la única prueba es restaurar.
• La verificación tiene niveles: existencia, contenido esperado, integridad, fidelidad con el original y restauración.
• Una suma SHA-256 cambia por completo ante cualquier cambio del archivo; sha256sum la calcula, y sha256sum -c compara una lista guardada, con --quiet para mostrar solo los problemas.
• Un manifiesto guarda las sumas de todos los archivos de un respaldo, con rutas relativas, calculado al crearlo y guardado aparte.
• Un respaldo con tar se comprueba con gzip -t, con tar -tf y con tar --compare; un archivo único, con su propia suma.
• rsync -an --checksum -i y diff -rq comparan un respaldo con el original.
• La corrupción silenciosa se detecta comprobando las sumas periódicamente; Btrfs y ZFS lo hacen por sí mismos con el scrub.
• Se restaura deteniendo el daño, eligiendo la copia correcta, restaurando aparte, revisando y recién entonces reemplazando; el procedimiento se escribe de antemano.
• Una prueba automática comprueba la antigüedad, los testigos, las sumas y una restauración de una muestra al azar, y solo avisa si encuentra problemas.
• El RPO, cuánto se puede perder, depende de la frecuencia de las copias; el RTO, cuánto se tarda en recuperar, solo se conoce midiéndolo.

15. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Calcula las sumas de varios archivos, guárdalas, modifica uno, borra otro, y comprueba la lista con sha256sum -c, con y sin --quiet.
2. Crea un .tar.gz, corrompe un byte en el medio con printf 'X' | dd of=archivo.tar.gz bs=1 seek=5000 conv=notrunc, y observa qué dicen gzip -t y tar -tzf.
3. Haz dos instantáneas con respaldar, calcula sus manifiestos y compáralos con diff. ¿Qué cambió de un día a otro?
4. Prueba verificar-respaldo comprobar sobre un destino de prueba: primero en orden, luego después de modificar un archivo de la instantánea, borrar un testigo y cambiar la fecha máxima con -d 0.
5. Escribe el procedimiento de restauración de tus propios datos: dónde están las copias, cómo se accede, qué comandos usar, dónde está la clave si hay cifrado. Guárdalo fuera de tu equipo.
6. Agrega a verificar-respaldo una opción -c ORIGEN que compare la última instantánea con el origen usando rsync -an --checksum -i, e informe cuántos archivos difieren.