Páginas

Buscar este blog

Mostrando entradas con la etiqueta Replication. Mostrar todas las entradas
Mostrando entradas con la etiqueta Replication. Mostrar todas las entradas

lunes, 21 de septiembre de 2026

FreeBSD 14.4 Replicación Incremental ZFS Cliente Servidor - Envío Remoto

1. Replicación de datos ZFS FreeBSD

2. Script Copia de Seguridad de un Conjunto de Datos ZFS Envío Remoto Versión 1.0.0

3. Script Replicación Incremental ZFS Cliente Servidor - Envío Remoto Versión 1.1.0

# cat ~/bin/zfsresp.sh

#!/bin/sh
### BEGIN INFO
# PROVIDE:
# REQUIRE:
# KEYWORD:
# NOMBRE:  Replicación Incremental ZFS cliente - servidor
# DESC:    Replica zroot/home/carlos (solaris) -> zbackup/solaris/home/carlos (tormenta)
# VERSION: 1.2.0
# FECHA:   2026-10-14
### END INFO

### INICIO DEL GUION

# Detectar fallos en cualquier punto de la tubería (zfs send | ssh).
set -o pipefail

NOMBRE="Replicacion Incremental ZFS cliente - servidor"
VERSION="1.2.0"

snap_prefix=snap
retention=30   # margen amplio por si el cliente pasa días apagado

# Patrón estricto de snapshot diario: snap-YYYYMMDD (8 dígitos).
# Excluye nombres manuales tipo snap-14.4-RELEASE-p8-... que romperían
# el orden lexicográfico y podrían colarse como base del incremental.
snap_pat="${snap_prefix}-[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]"

# Rutas absolutas para cron.
date=/bin/date
cut=/usr/bin/cut
grep=/usr/bin/grep
sed=/usr/bin/sed
sort=/usr/bin/sort
xargs=/usr/bin/xargs
zfs=/sbin/zfs

src_0="zroot/home/carlos"
dst_0="zbackup/solaris/home/carlos"
host="root@192.168.88.160"

# Keepalive SSH: evita "Timeout, server ... not responding".
SSH_OPTS="-o ConnectTimeout=10 -o ServerAliveInterval=30 \
          -o ServerAliveCountMax=10 -o TCPKeepAlive=yes \
          -o BatchMode=yes"

today="$snap_prefix-`$date +%Y%m%d`"
snap_today="$src_0@$today"

log=/home/carlos/cronlog

echo >> $log
echo "$NOMBRE v$VERSION" >> $log
echo "(ejecucion manual)" >> $log
$date >> $log
echo >> $log

# Comprobar conectividad SSH antes de nada.
if ! ssh $SSH_OPTS $host true 2>/dev/null; then
    echo "ERROR: no hay conexion SSH con $host. Abortando." >> $log
    echo "**********" >> $log
    exit 1
fi

# Limpia el estado del destino: desmonta y aborta receives colgados.
# Elimina el error "dataset is busy".
# Nota: se usa sh -c para evitar que csh/tcsh (shell por defecto de root
# en FreeBSD) interprete mal el "2>" como argumento en lugar de redirección.
clean_dst() {
    ssh $SSH_OPTS $host "sh -c 'zfs unmount \"$dst_0\" 2>/dev/null; zfs receive -A \"$dst_0\" 2>/dev/null; true'"
}

# --- Snapshots locales antiguas (para purga) ---
snap_old=`$zfs list -t snapshot -o name \
  | $grep "${src_0}@${snap_pat}" \
  | $sort -r \
  | $sed 1,${retention}d \
  | $sort \
  | $xargs -n 1`

# --- Snapshot base en destino remoto ---
snap_base_name=`ssh $SSH_OPTS $host "zfs list -t snapshot -o name \
  | grep '${dst_0}@${snap_pat}' \
  | sort -r \
  | sed 1q \
  | cut -d@ -f2"`
snap_base="${src_0}@$snap_base_name"

# --- Snapshots remotas antiguas (para purga) ---
snap_old_dst_0=`ssh $SSH_OPTS $host "zfs list -t snapshot -o name \
  | grep '${dst_0}@${snap_pat}' \
  | sort -r \
  | sed 1,${retention}d \
  | sort"`

# --- Snapshot de hoy en origen ---
if $zfs list -H -o name -t snapshot | $grep "${snap_today}$" > /dev/null
then
    echo "La instantánea de hoy '$snap_today' ya existe." >> $log
else
    echo "Tomando la instantánea de hoy: $snap_today" >> $log
    # Sin -r: no hay datasets hijos.
    if ! $zfs snapshot "$snap_today" >> $log 2>&1; then
        echo "ERROR: no se pudo crear la instantánea $snap_today." >> $log
        echo "**********" >> $log
        exit 1
    fi
fi

echo >> $log

# --- Comparar la PUNTA de origen y destino ---
# No basta con "existe hoy en destino": puede existir la de hoy pero
# faltar intermedias si hubo un apagado prolongado. Comparamos extremos.
snap_last_src=`$zfs list -t snapshot -o name \
  | $grep "${src_0}@${snap_pat}" \
  | $sort -r \
  | sed 1q`
snap_last_dst=`ssh $SSH_OPTS $host "zfs list -t snapshot -o name \
  | grep '${dst_0}@${snap_pat}' \
  | sort -r \
  | sed 1q"`

src_suffix=`echo "$snap_last_src" | $cut -d@ -f2`
dst_suffix=`echo "$snap_last_dst" | $cut -d@ -f2`

if [ -n "$src_suffix" ] && [ "$src_suffix" = "$dst_suffix" ]; then
    echo "Origen y destino ya sincronizados en @$src_suffix. Nada que enviar." >> $log
else
    echo "Destino desfasado (@${dst_suffix:-vacio} vs @${src_suffix:-vacio}). Replicando..." >> $log

    if [ -n "$snap_base_name" ] && $zfs list -H -o name -t snapshot \
      | $grep "${snap_base}$" > /dev/null
    then
        echo "Usando '$snap_base' como base del incremental (-I)..." >> $log
        clean_dst
        # Sin -R (no hay hijos). -I envía TODOS los snapshots intermedios
        # entre base y hoy, rellenando huecos de días apagado.
        # Sin -F: no queremos que ZFS destruya snapshots del destino
        # silenciosamente si algo se ha desincronizado. Mejor fallar y
        # enterarnos por el log.
        if $zfs send -I "$snap_base" "$snap_today" \
           | ssh $SSH_OPTS $host "zfs receive -vu -x mountpoint '$dst_0'"
        then
            echo "Replicacion completada." >> $log
        else
            echo "ERROR: fallo la replicacion incremental." >> $log
            echo "**********" >> $log
            exit 1
        fi
    else
        echo "No se encontró snapshot común entre origen y destino." >> $log
        echo "Realizando envío completo (puede tardar)..." >> $log
        clean_dst
        # Sin -R. Sin -F (mismo razonamiento que arriba).
        if $zfs send "$snap_today" \
           | ssh $SSH_OPTS $host "zfs receive -vu -x mountpoint '$dst_0'"
        then
            echo "Envío completo finalizado." >> $log
        else
            echo "ERROR: fallo el envio completo." >> $log
            echo "**********" >> $log
            exit 1
        fi
    fi
fi

echo >> $log

# --- Purga local ---
echo "Intentando destruir instantáneas antiguas $src_0..." >> $log
if [ -n "$snap_old" ]
then
    echo "Destruyendo las siguientes instantáneas antiguas:" >> $log
    echo "$snap_old" >> $log
    $zfs list -t snapshot -o name \
      | $grep "${src_0}@${snap_pat}" \
      | $sort -r \
      | $sed 1,${retention}d \
      | $sort \
      | $xargs -n 1 $zfs destroy >> $log 2>&1
else
    echo "No se pudo encontrar ninguna instantánea local para destruir." >> $log
fi

echo >> $log

# --- Purga remota ---
echo "Intentando destruir instantáneas antiguas $dst_0..." >> $log
if [ -n "$snap_old_dst_0" ]
then
    echo "Destruyendo las siguientes instantáneas antiguas en $host:" >> $log
    echo "$snap_old_dst_0" >> $log
    ssh $SSH_OPTS $host "zfs list -t snapshot -o name \
      | grep '${dst_0}@${snap_pat}' \
      | sort -r \
      | sed 1,${retention}d \
      | sort \
      | xargs -n 1 zfs destroy" >> $log 2>&1
else
    echo "No se pudo encontrar ninguna instantánea remota para destruir." >> $log
fi

echo "**********" >> $log

exit 0

Lanzar el script

cd /home/carlos/bin
./zfsrep.sh 
receiving incremental stream of zroot/home/carlos@snap-20260921 into zbackup/solaris/home/carlos@snap-20260921
received 186M stream in 101.31 seconds (1.84M/sec)

Verificar que todo llegó bien

En tormenta, comprobar que están todas las snapshots intermedias:

ssh root@192.168.88.160 "zfs list -t snapshot -o name -r zbackup/solaris/home/carlos"
NAME
...
zbackup/solaris/home/carlos@snap-20260811
zbackup/solaris/home/carlos@snap-20260812
zbackup/solaris/home/carlos@snap-20260813
zbackup/solaris/home/carlos@snap-20260814
zbackup/solaris/home/carlos@snap-20260815
zbackup/solaris/home/carlos@snap-20260916
zbackup/solaris/home/carlos@snap-20260918
zbackup/solaris/home/carlos@snap-20260919
zbackup/solaris/home/carlos@snap-20260920
zbackup/solaris/home/carlos@snap-20260921

Si se lanza el script zfsrep.sh seguido. Debe decir:

Origen y destino ya sincronizados en @snap-20260920. Nada que enviar.

Si dice eso, el script es idempotente

Revisar archivo /home/carlos/cronlog

cat ~/cronlog

**********

zfsrep.sh (ejecucion manual)
Mon Sep 21 07:16:13 CEST 2026

Tomando la instantánea de hoy: zroot/home/carlos@snap-20260921

Destino desfasado (@snap-20260920 vs @snap-20260921). Replicando...
Usando 'zroot/home/carlos@snap-20260920' como base del incremental (-I)...
Replicacion completada.

Intentando destruir instantáneas antiguas zroot/home/carlos...
No se pudo encontrar ninguna instantánea local para destruir.

Intentando destruir instantáneas antiguas zbackup/solaris/home/carlos...
No se pudo encontrar ninguna instantánea remota para destruir.
**********

Comprobar que no queda un receive pendiente

ssh root@192.168.88.160 "zfs get receive_resume_token zbackup/solaris/home/carlos"
NAME                         PROPERTY              VALUE      SOURCE
zbackup/solaris/home/carlos  receive_resume_token  -          -

Debe devolver - (sin receive pendiente).

Resumen del estado

Aspecto				   Estado
Conexión SSH con tormenta        - Correcta
Detección de desfase 		 - Correcta
Replicación incremental con -I	 - Completada
Relleno de huecos por apagados	 - Funciona
dataset is busy	                 - Resuelto por clean_dst()
Timeout SSH	                 - Resuelto por SSH_OPTS
Mensaje "Replicacion completada" - Ahora es fiable
Idempotencia (2ª ejecución)	 - Funciona
La comparación de puntas funciona (detecta que ya está al día). El script es idempotente: ejecutarlo varias veces no rompe nada ni duplica envíos. No hay receives colgados ni estados "busy" residuales. "Replicacion completada" ahora es un mensaje fiable, no un falso positivo.

Estado final del script

Escenario		     Comportamiento
Cliente apagado varios días -I rellena los snapshots intermedios
Destino ya al día 	    - Salta sin enviar nada
Destino con receive colgado - clean_dst() lo aborta antes de recibir
SSH lento o pausado         - ServerAliveInterval evita el timeout
Fallo en zfs send o ssh	    - pipefail + if lo detectan y abortan con error
Sin hijos en el dataset	    -R eliminado; operaciones simples
Retención	            - 30 snapshots, purga automática en ambos lados

Recomendaciones

Si algún vez el cliente pasa más de 30 días apagado, la base común desaparecerá y el script hará un envío completo aunque tardará más. Si se quiere evitar, debe aumentarse el valor de retention, o crear una snapshot "ancla" con zfs hold que nunca se borre.

Guardar una copia del script corregido en un sitio seguro (por ejemplo, dentro del propio pool ZFS que se replica, o en git).

Revisar el log cada cierto tiempo:

tail -50 /home/carlos/cronlog
Si algún día salta "ERROR: fallo la replicacion...", sabrás que es real y no un falso "completada".

Se puede considerar automatizarlo con cron si se quiere. El script ya tiene rutas absolutas y BatchMode=yes, así que está preparado. Solo se necesita una clave SSH sin passphrase entre carlos@solaris y root@tormenta (la tiene, porque funciona manualmente).

Servidor tormenta - zpools

carlos@tormenta:~ % zpool list
NAME      SIZE  ALLOC   FREE  CKPOINT  EXPANDSZ   FRAG    CAP  DEDUP    HEALTH  ALTROOT
zbackup  1.81T   958G   898G        -         -     0%    51%  1.00x    ONLINE  -
zroot     448G   206G   242G        -         -     8%    45%  1.00x    ONLINE  -
 
carlos@tormenta:~ % zfs list -r zbackup
NAME                          USED  AVAIL  REFER  MOUNTPOINT
zbackup                      1008G   790G  92.5M  none
zbackup/dellhome             56.6G   790G  56.6G  none
zbackup/nfsv4                36.6G   790G    96K  none
zbackup/nfsv4/docs           7.80G   790G  7.80G  none
zbackup/nfsv4/secrets        28.8G   790G  28.8G  none
zbackup/recovery              755G   790G   104K  none
zbackup/recovery/solaris      282G   790G   282G  none
zbackup/recovery/tormenta     473G   790G   473G  none
zbackup/reserved               50G   840G    96K  none
zbackup/solaris              81.4G   790G    96K  none
zbackup/solaris/home         81.4G   790G    96K  none
zbackup/solaris/home/carlos  81.4G   790G  74.3G  none
zbackup/usr                   147M   790G   104K  none
zbackup/usr/home              147M   790G   140M  none
FreeBSD es genial!.

martes, 15 de abril de 2025

Script sh Replicar Instantáneas de Conjunto de Datos ZFS desde Servidor FreeBSD Local a otra Máquina FreeBSD Externa

El autor de este sencillo e ingenioso guión es iceflatline. Lamentablemente su sitio web está caido. Contiene algunas modificaciones para adaptarlo a este laboratorio

Script mejorado

https://gnulinuxcodigo.blogspot.com/2025/03/crear-particiones-en-disco-duro-usb-con.html

Crear el pool de respaldo zbackup

 zpool create -o ashift=12 \
-O compression=lz4 \
-O atime=off \
-O mountpoint=none \
backup /dev/gpt/zbackup

Conjuntos de datos zbackup

 sudo zfs create -o mountpoint=none zbackup/solaris
 sudo zfs create -o mountpoint=none zbackup/solaris/home
 sudo zfs create -o mountpoint=none zbackup/solaris/home/carlos
 sudo zfs create -o mountpoint=none zbackup/tormenta-confiles
 sudo zfs create -o mountpoint=none zbackup/usr/
 sudo zfs create -o mountpoint=none zbackup/usr/backup
 sudo zfs create -o mountpoint=none zbackup/usr/backup/docs
 sudo zfs create -o mountpoint=none zbackup/usr/home

Flujo de trabajo recomendado para un disco de respaldo mountpoint=none

Seguridad contra modificaciones accidentales

Evita conflictos de rutas

Comportamiento en el arranque — Con mountpoint=none ZFS no intenta montar nada del pool zbackup al arrancar, lo que acelera el boot y evita errores si el disco USB no está conectado en ese momento.

Acceso bajo demanda — Cuando se necesita recuperar algo, se monta puntualmente el dataset de interés, se hace lo que se necesita, y luego se desmonta.

Los scripts no se ven afectados — zfs receive escribe directamente al dataset sin necesidad de que esté montado. mountpoint=none no interfiere en absoluto con zfs send/receive.

carlos@tormenta:~ % zfs list -r zbackup
zbackup                            48.9G  1.71T  4.86M  none
zbackup/solaris                    40.8G  1.71T    96K  none
zbackup/solaris/home               40.8G  1.71T    96K  none
zbackup/solaris/home/carlos        40.8G  1.71T  39.9G  none
zbackup/tormenta-confiles           800K  1.71T   800K  none
zbackup/usr                        8.16G  1.71T   104K  none
zbackup/usr/backup                 7.80G  1.71T   104K  none
zbackup/usr/backup/docs            7.80G  1.71T  7.80G  none
zbackup/usr/home                    368M  1.71T   132M  none
#!/bin/sh
### BEGIN INFO
# PROVIDE:
# REQUIRE:
# KEYWORD:

### INICIO DEL GUION
# Estas variables se nombran primero porque están anidadas en otras variables.
snap_prefix=snap
retention=15

# Se necesitan rutas completas a estas utilidades al ejecutar el script desde \
cron.
date=/bin/date
grep=/usr/bin/grep
sed=/usr/bin/sed
sort=/usr/bin/sort
xargs=/usr/bin/xargs
zfs=/sbin/zfs

src_0="zroot/home/carlos"
dst_0="zbackup/solaris/home/carlos"
host="root@192.168.88.160"

# Usar $date en lugar de date para consistencia con rutas absolutas.
today="$snap_prefix-`$date +%Y%m%d`"
yesterday="$snap_prefix-`$date -v -1d +%Y%m%d`"
snap_today="$src_0@$today"
snap_yesterday="$src_0@$yesterday"

# Patrón grep con sufijo numérico para evitar falsos positivos.
snap_old=`$zfs list -t snapshot -o name \
  | $grep "${src_0}@${snap_prefix}-[0-9]" \
  | $sort -r \
  | $sed 1,${retention}d \
  | $sort \
  | $xargs -n 1`

log=/home/carlos/cronlog

# Todo el pipeline de listado remoto corre en tormenta vía SSH.
snap_old_dst_0=`ssh $host "$zfs list -t snapshot -o name \
  | grep '${dst_0}@${snap_prefix}-[0-9]' \
  | sort -r \
  | sed 1,${retention}d \
  | sort"`

# Crea una línea en blanco entre la entrada de registro anterior y esta.
echo >> $log

# Imprimir el nombre del script.
echo "zfsrep.sh" >> $log
# Imprime la fecha de hoy.
$date >> $log
# Crea una línea en blanco.
echo >> $log

# Buscar instantánea de hoy y, si no la encuentra, créala.
if $zfs list -H -o name -t snapshot \
  | $sort \
  | $grep "${snap_today}$" > /dev/null
then
	echo "La instantánea de hoy '$snap_today' ya existe." >> $log
else
	echo "Tomando la instantánea de hoy: $snap_today" >> $log
	$zfs snapshot -r $snap_today >> $log 2>&1
fi

echo >> $log

# Replicar el snapshot diario (ayer) o mostrar error si falta.
if $zfs list -H -o name -t snapshot \
  | $sort \
  | $grep "${snap_yesterday}$" > /dev/null
then
	echo "La instantánea de ayer '$snap_yesterday' existe. Continuando \
    con la replicacion..." >> $log
	$zfs send -R -i $snap_yesterday $snap_today \
	  | ssh $host $zfs receive -vuF -x mountpoint $dst_0 >> $log 2>&1
	echo >> $log
	echo "Replicacion completada." >> $log
else
	echo "Error: Replicacion no completada. Falta la instantánea de \
    ayer." >> $log
fi

echo >> $log

# Eliminar instantáneas locales más antiguas que el valor asignado a retention.
echo "Intentando destruir instantáneas antiguas $src_0..." >> $log

if [ -n "$snap_old" ]
then
	echo "Destruyendo las siguientes instantáneas antiguas:" >> $log
	echo "$snap_old" >> $log
	$zfs list -t snapshot -o name \
	  | $grep "${src_0}@${snap_prefix}-[0-9]" \
	  | $sort -r \
	  | $sed 1,${retention}d \
	  | $sort \
	  | $xargs -n 1 $zfs destroy -r >> $log 2>&1
else
	echo "No se pudo encontrar ninguna instantánea local para \
    destruir." >> $log
fi

echo >> $log

# Purgar snaps remotos > retention
# Todo el pipeline, incluido zfs destroy, corre en tormenta vía SSH.
echo "Intentando destruir instantáneas antiguas $dst_0..." >> $log

if [ -n "$snap_old_dst_0" ]
then
	echo "Destruyendo las siguientes instantáneas antiguas en $host:" >> $log
	echo "$snap_old_dst_0" >> $log
	ssh $host "$zfs list -t snapshot -o name \
	  | grep '${dst_0}@${snap_prefix}-[0-9]' \
	  | sort -r \
	  | sed 1,${retention}d \
	  | sort \
	  | xargs -n 1 $zfs destroy -r" >> $log 2>&1
else
	echo "No se pudo encontrar ninguna instantánea remota para \
    destruir." >> $log
fi

# Marcar el fin del script con un delimitador.
echo "**********" >> $log

### FIN DEL SCRIPT

Luego, agregue una tarea a la tabla cron bajo la cuenta del usuario. El script se ejecuta todos los días a las 22:00 (hora local):

# Ejecuta script backup cada día a las 22:00
0 22 * * * /home/carlos/bin/zfsrep.sh

Las entradas del archivo /home/carlos/cronlog se verán así:

**********

zfsrep.sh
Tue Apr 15 09:45:19 CEST 2025

Tomando la instantánea de hoy: zroot/home@snap-20250415

La instantánea de ayer 'zroot/home@snap-20250414' existe. \
Continuando con la replicacion...
receiving incremental stream of zroot/home@snap-20250415 into \
zbackup/solaris/home/carlos@snap-20250415
received 312B stream in 0.91 seconds (341B/sec)
receiving incremental stream of zroot/home/carlos@snap-20250415 \
into zbackup/solaris/home/carlos@snap-20250415
received 16.3M stream in 7.07 seconds (2.30M/sec)

Replicacion completada.

Intentando destruir instantáneas antiguas zroot/home...
Destruyendo las siguientes instantáneas antiguas:
zroot/home@snap-20250327

Intentando destruir instantáneas antiguas zbackup/solaris...
No se pudo encontrar ninguna instantánea para destruir.
FreeBSD es genial!.

sábado, 14 de diciembre de 2024

Replicación de datos ZFS FreeBSD

Bibliografía:
klarasystems.com
Klara Inc. Allan Jude y Jim Salter
Illumos ZFS Administracion

1. Replicación de datos ZFS FreeBSD

2. Script Copia de Seguridad de un Conjunto de Datos ZFS Envío Remoto Versión 1.0.0

3. Script Replicación Incremental ZFS Cliente Servidor - Envío Remoto Versión 1.1.0

Diagrama Dia

Replication ZFS en FreeBSD

Lo que hace la replicación ZFS es poder serializar un sistema de archivos. Cuando serializa un objeto en ciencia de datos o programación de computadoras se trata de hacerlo en formato que pueda transportarse con facilidad de tal manera que podamos recrear ese sistema de archivos en el otro lado, de forma que nos permite cruzar sistemas operativos, no importa si la fuente es FreeBSD y el destino es Linux, Illumos, Mac o Windows, etc.

Recrea el sistema de archivo exactamente igual sin depender que sea byte por byte. Eso también proporciona compatibilidad hacia delante y hacia atrás, puede hacer una transmisión ZFS 10 con la última versión de ZFS y aún recibirlo con una versión de ZFS de hace 10 años o viceversa.

Otra cosa importante sobre la forma en que esto funciona en la replicación ZFS es que es unidireccional, por lo que el remitente controla todo lo que empaqueta el sistema de archivos en el formato serializado y lo enviará, no requiere ninguna interacción con el lado que lo va a recibir, lo que significa que no tiene que recibirlo ahora mismo.

Lo interesante sobre la forma en que esto funciona es que no requiere un manejo especial para cosas como permisos, atributos extentidos de ACLS y cualquier otra cosa que pueden estar adjuntos al sistema de archivos, todos son sólo datos que se serializan de la misma manera que el contenido de los archivos, por lo que ZFS no tiene que realizar comprobaciones adicionales ni nigún trabajo extra, simplemente envía los datos y el resto, el lado es responsable de interpretarlo, por lo que si usa algunas de las herramientas de depuración de ZFS podemos ver lo que hay dentro de una secuencia de envío, pero básicamente es un comando de objeto que dice que necesitamos crear un nuevo objeto.

Como toda copia de seguridad todavía debe probar y asegurarse de que puede restaurar el sistema de archivos desde su copia de seguridad.

Sumas de Verificación de un Extremo a Otro

ZFS utiliza sumas de verificación de extremo a extremo por lo que sabemos que ZFS almacena una suma de verificación para cada bloque en el que escribe incluido sus propios metadatos internos. Antes de enviar ZFS se asegura de que los datos que está a punto de enviar son correctos comprobando la suma de verificación, luego los envía con la suma de verificación para que cuando llegue al otro lado verificar que lo que recibe sigue siendo los datos correctos. Después se escriben en disco y al volver a leerlos desde la copia de seguridad verifica de nuevo que sigue siendo la misma suma de verificación y que los datos sobrevivieron intactos. Si los datos están cifrados, también hay un código de verificación allí, asegurándose de que no solo los datos estén intactos sino también que no han sido modificados maliciosamente porque verifica que se descibra correctamente.

¿Que ocurre si por algún motivo se interrumpe la replicación?.

En el lado receptor aparece una propiedad llamada token de reanudación y contiene en qué instantánea estábamos, en que objeto en esa instantánea, que tan lejos en ese objeto y permite reanudar esa replicación. Si ejecutamos

  zfs get -H receive_resume_token zroot/backup
 zstream token 1-ca6584b3f-c0-bb2...
 object: 128
 offset: 1507590144
 bytes: 1511357704
 toguid: 2687048938072742180
 toname: 'zroot/usr/home@snap-20241214'
 

Nos dará una cadena, vemos que estamos enviando el objeto 128, este desplazamiento de 1.5 GB y que tenemos otros 1.5 GB para enviar, la cuadrícula de la instantánea y el nombre de la instantánea.

Como toda copia de seguridad todavía debe probar y asegurarse de que puede restaurar el sistema de archivos desde su backup

En el lado de envío (origen) se utiliza:

zfs send -t receive_resume_token 1-ca6584b3f-c0-bb2...

El token contiene el resto de la información sobre exactamente desde dónde continuar y dejaremos que este envio continue.

Conectar al servidor tormenta vía SSH desde el cliente solaris

El archivo de hosts contiene información sobre los hosts conocidos en la red.

Archivo /etc/hosts

cat /etc/hosts| grep tormenta
192.168.88.160   tormenta

Archivo ~/.ssh/config

$ cat .ssh/config
Host tormenta
	HostName 192.168.88.160
	User carlos
	Port 30000
	AddressFamily inet
	BindInterface em0
	CheckHostIP yes
...
$ ssh tormenta
Last login: Sat Dec 14 06:50:20 2024 from solaris
...

Compruebe que el ssh basado en clave funciona

Copiar la clave publica id_rsa.pub del cliente en el archivo authorized_keys de su cuenta en el servidor

 ssh-keygen

 cat ~/.ssh/id_rsa.pub | ssh remote_host "cat >> .ssh/authorized_keys"

 ssh tormenta
 
 carlos@tormenta:~ %

Particionar el Disco Para las Copias de Seguridad

El disco debe estar desmontado, para averiguar el punto de montaje se utiliza mount y unmount para desmontarlo.

Es importante asegurarse del disco sobre el que va a trabajar. Para ello dispone de múltiples opciones.

 gpart
 gpart show

 lsblk
 lsblk -d
 
 Mostrar discos físicos
 sysctl kern.disks

Y por último usando dmesg para identificar discos conectados, por ejemplo, si conecta un dispositivo de almacenamiento vía USB aparece al final del archivo dmesg

 /sbin/dmesg | tail
 

Preparar el dispositivo de almacenamiento

El comando gpart destroy DESTRUYE EL ESQUEMA DE PARTICIONAMIENTO implementado por GEOM. Es un proceso irreversible. Destruye todos los datos. -F Fuerza la destrucción de la tabla de particiones incluso si no está vacía.

Ya conoce el disco a particionar?

En esta laboratorio es (da1) /dev/da1 de 2 TB con una capacidad real de 1862 GB (2x0.9313 = 1.862 TB = 1862 GB)

gpart destroy -F /dev/da1

gpart create -s gpt /dev/da1
gpart add -t freebsd-zfs -a 1m -l backups da1
da1p1 created

zpool create -o ashift=12 \
	-O compression=lz4 \
	-O atime=off \
	-O mountpoint=none \
	backups gpt/backups

zpool set autoexpand=on backups
zpool set listsnapshots=on backups

Consultar propiedades

zfs get compression,atime,dedup,sync,copies,mountpoint zbackup
NAME     PROPERTY     VALUE           SOURCE
zbackup  compression  on              default
zbackup  atime        off             local
zbackup  dedup        off             default
zbackup  sync         standard        default
zbackup  copies       1               default
zbackup  mountpoint   none            local

Crear Conjunto de Datos en pool backups

zfs create -p backups/usr/backup/docs
zfs create backps/usr/home
zfs create -p backups/solarishome/home
zfs create -p backups/recovery/solaris
zfs create backups/recovery/tormenta
zfs create backups/reserved

Listar recursivamente backups

zfs list -r backups
NAME                             USED  AVAIL     REFER  MOUNTPOINT
backups                          480G  1.29T      192K  none
backups/recovery                 330G  1.29T       96K  none
backups/recovery/solaris        67.9G  1.29T     67.9G  none
backups/recovery/tormenta        262G  1.29T      262G  none
backups/reserved                  96K  1.34T       96K  none
backups/solarishome             62.8G  1.29T       96K  none
backups/solarishome/home        62.8G  1.29T     40.4G  none
backups/usr                     7.78G  1.29T       96K  none
backups/usr/backup              7.78G  1.29T       96K  none
backups/usr/backup/docs         7.78G  1.29T     7.78G  none
backups/usr/home                6.14M  1.29T     5.97M  none

Establecer un nombre descriptivo si la versión de OpenZFS lo admite

zpool version
zfs-2.2.9-FreeBSD_g079ba86d7
zfs-kmod-2.2.9-FreeBSD_g079ba86d7

zpool get all backups | grep -E 'comment|compatibility'
backups  comment           -          default
backups  compatibility     off        default

 zpool set comment='Copia Seguridad USB' backups

 zfs get all backups | grep -i comment
 zpool set comment='Copia Seguridad USB' backups

zfs get all backups | grep -i comment
zpool get all backups | grep -E 'comment|compatibility'
backups  comment        Copia Seguridad USB      local
backups  compatibility       off                 default

zpool get comment backups
NAME     PROPERTY  VALUE                SOURCE
backups  comment   Copia Seguridad USB  local

Listar recursivamente pool zroot servidor tormenta

zfs list -r zroot 
NAME                                   USED  AVAIL   REFER  MOUNTPOINT
zroot                                  170G   264G    112K  /zroot
zroot/ROOT                            40.8G   264G     96K  none
zroot/ROOT/default                    40.8G   264G   36.0G  /
zroot/confsolaris                     1.16M   264G   1.16M  /zroot/confsolaris
zroot/jails                           1.25G   264G     96K  /jails
zroot/jails/loghost                   1.25G   264G   1.25G  /jails/loghost
zroot/jails/media                       96K   264G     96K  /jails/media
zroot/reserved                          96K   289G     96K  /zroot/reserved
zroot/tmp                             2.87G   264G   2.87G  /tmp
zroot/usr                             90.7G   264G     96K  /usr
zroot/usr/backup                      88.5G   264G    128K  /usr/backup
zroot/usr/backup/confiles              284M   264G     96K  /usr/backup/confiles
zroot/usr/backup/confiles/tormenta    4.71M   264G    860K  /usr/backup/confiles/tormenta
zroot/usr/backup/docs                 7.78G   264G   7.78G  /usr/backup/docs
zroot/usr/home                        6.57M   264G   4.82M  /usr/home
zroot/usr/ports                        924M   264G    924M  /usr/ports
zroot/usr/src                         1.26G   264G   1.26G  /usr/src
zroot/var                             1.27G   264G     96K  /var
zroot/var/audit                         96K   264G     96K  /var/audit
zroot/var/crash                         96K   264G     96K  /var/crash
zroot/var/db                            96K   264G     96K  /var/db
zroot/var/jail                        1.26G   264G     96K  /var/jail
zroot/var/jail/www                    1.26G   264G   1.26G  /var/jail/www
zroot/var/log                         3.86M   264G   2.64M  /var/log
zroot/var/mail                         144K   264G    144K  /var/mail
zroot/var/tmp                          152K   264G     96K  /var/tmp

Exportar e Importar backups

Esto asegura que el pool se cierre correctamente y se liberen todos los recursos asociados. Luego, el disco puede ser desconectado de forma segura.

zpool export backups

Grupos disponibles para importar

z
zpool import
  pool: backups
     id: 10639314260213971789
  state: ONLINE
 action: The pool can be imported using its name or numeric identifier.
 config:

	backups     ONLINE
	  da0p1     ONLINE
zpool import backups	  

Listar Información Sobre los Grupos de Almacenamiento ZFS

zpool list 
NAME      SIZE  ALLOC   FREE  CKPOINT  EXPANDSZ   FRAG    CAP  DEDUP    HEALTH
backups  1.81T   430G  1.39T        -         -     0%    23%  1.00x    ONLINE
zroot     448G   142G   306G        -         -     4%    31%  1.00x    ONLINE

Disponible para importar

zpool import
no pools available to import

Crear las instantáneas

Para crear instantáneas y todos sus sistemas de archivos descendientes se utiliza -r Crear las instantáneas de los conjunto de datos zroot/usr/backup/docs y zroot/usr/home

zfs snapshot -r zroot/usr/home@snap-`date +%Y%m%d`
zfs snapshot -r zroot/usr/backup/docs@snap-`date +%Y%m%d`

Listar instantáneas creadas

zfs list -t snapshot zroot/usr/home@snap-20241213
NAME                           USED  AVAIL     REFER  MOUNTPOINT
zroot/usr/home@snap-20241213   172K      -     5.97M  -

zfs list -t snapshot zroot/usr/backup/docs@snap-20241213
NAME                                  USED  AVAIL     REFER  MOUNTPOINT
zroot/usr/backup/docs@snap-20241213   216K      -     7.78G  -

Enviar la primera instantánea completa

-R con el comando zfs send. Esta opción preservará las propiedades ZFS de cualquier conjunto de datos, instantáneas y clones descendientes en la secuencia.
-d Utilice la ruta completa de la instantánea enviada sin el primer elemento (sin el nombre del grupo) para determinar el nombre de la nueva instantánea
-u No montar el flujo recibido
-v Imprime información detallada sobre la secuencia y el tiempo necesario para realizar la operación de recepción

En el primer envío se utiliza la ruta de destino completa (backups/usr/backup/docs)
En el flujo incremental sólo se utiliza el nombre del pool (backups)

zfs send -R -v zroot/usr/home@snap-20241213 | zfs receive -vd backups/usr/home
zfs send -R -v zroot/usr/backup/docs@snap-20241213 | zfs receive -vdF \
backups/usr/backup/docs

Envío incremental

Tenga en cuenta que el envío de un flujo incremental sólo tendrá éxito si ya existe una instantánea completa inicial en el lado receptor.

Envía todos los bloques que tienen una hora de creacion entre zroot@snap-20241213 y zroot@snap-20241214, se serializan y envían al otro lado que ya tiene zroot@snap-20241213 por lo que puede aplicar los cambios y tener eso también sin tener que mirar lo que hay en zroot@snap-20241213, al contrario que rsync que tiene que revisar archivo por archivo.

Si recibe un error como este al realizar una replicación incremental: "No se puede recibir el flujo incremental las copias de seguridad de destino se han modificado desde la snapshot más reciente", es decir, que las instantáneas de origen y destino ya no son idénticas ZFS aborta la replicación. Use receive -F para forzar al sistema receptor a retroceder al estado de la última instantánea recibida para que los sistemas estén nuevamente sincronizados.

Tomar las instantáneas

zfs snapshot zroot/usr/home@snap-`date +%Y%m%d`
zfs snapshot zroot/usr/backup/docs@snap-`date +%Y%m%d`

Listar instantáneas creadas

zfs list -t snapshot zroot/usr/home@snap-20241213
NAME                           USED  AVAIL   REFER  MOUNTPOINT
zroot/usr/home@snap-20241214   172K      -   5.97M  -

zfs list -t snapshot zroot/usr/backup/docs@snap-20241213
NAME                                  USED  AVAIL   REFER  MOUNTPOINT
zroot/usr/backup/docs@snap-20241214   216K      -   7.78G  -

Enviar el flujo de datos

-F Fuerce una reversión del sistema de archivos a la instantánea más reciente antes de realizar la operación de recepción. Si recibe un flujo de replicación incremental (por ejemplo, uno generado por zfs send -R [-i|-I]), destruya las instantáneas y los sistemas de archivos que no existan en el lado de envío.

zfs send -R -i zroot/usr/home@snap-20241213 zroot/usr/home@snap-20241214 | zfs \
>receive -vdF backups
zfs send -R -i  zroot/usr/backup/docs@snap-20241213 \
zroot/usr/backup/docs@snap-20241214 | zfs receive -vdF backups

Replicación remota a través de SSH

Origen FreeBSD solaris, destino backups servidor tormenta

Tomar la instatánea del conjunto de datos zroot/home

solaris~ # zfs snapshot zroot/home@snap-`date +%Y%m%d`
 

Listar instantánea

solaris~ # zfs list -t snapshot zroot/home@snap-20241213
NAME                       USED  AVAIL  REFER  MOUNTPOINT
zroot/home@snap-20241213  25.4M      -  39.2G  -
solaris~ # zfs send -Rv zroot/home@snap-20241213 | ssh root@tormenta "zfs \
receive -vdF backups/solarishome/home"
 

Replicación remota incremental

Tomar la instantánea

solaris~ # zfs snapshot zroot/home@snap-`date +%Y%m%d`

Listar las intantáneas

solaris~ # zfs list -t snapshot | grep "zroot/home@snap-*"   
zroot/home@snap-20241213           185M      -  39.2G  -
zroot/home@snap-20241214            53.4M    -  39.2G  -

Replicar el flujo de datos

 solaris~ # zfs send -R -v zroot/home@snap-20241213 zroot/home@snap-20241214 | \
 ssh root@tormenta "zfs receive -vdF backups"

Exportar e importar pool backups

 zfs export backups
 zfs import backups
 

Donde están las instantáneas?

Conectarse al servidor tormenta vía SSH

solaris~ $ ssh tormenta
carlos@tormenta~ $ % ls -l /export/solarishome/home/.zfs/snapshot
total 1
drwxr-xr-x  5 root  wheel  5 May 30  2024 snap-20241213
drwxr-xr-x  5 root  wheel  5 May 30  2024 snap-20241214

carlos@tormenta~ $ % ls -l /export/usr/home/.zfs/snapshot
total 1
drwxr-xr-x  4 root  wheel  4 Jul 24 17:31 snap-20241213
drwxr-xr-x  4 root  wheel  4 Jul 24 17:31 snap-20241214

carlos@tormenta:~ % ls -l /export/usr/backup/docs/.zfs/snapshot
total 289
drwxr-xr-x  30 carlos  wheel  923 Dec 12 08:19 snap-20241212
drwxr-xr-x  30 carlos  wheel  926 Dec 13 07:34 snap-20241214

carlos@tormenta:~ % zfs list -t snapshot -o name | grep "zroot/usr/backup/docs@snap-"
zroot/usr/backup/docs@snap-20241213    248K    -   7.78G  -
zroot/usr/backup/docs@snap-20241214    216K    -   7.78G  -

carlos@tormenta:~ % zfs list -t snapshot -o name | grep "zroot/usr/home@snap-"
zroot/usr/home@snap-20241213    172K    -   5.97M  -
zroot/usr/home@snap-20241214    172K    -   5.97M  -

Listar todas las instantáneas en backups

carlos@tormenta:~ % zfs list -t snapshot -r backups
NAME                                     USED  AVAIL   REFER  MOUNTPOINT
backups/solarishome/home@snap-20241213  22.5G      -   62.8G  -
backups/solarishome/home@snap-20241214     0B      -   40.4G  -
backups/usr/backup/docs@snap-20241213    276K      -   7.78G  -
backups/usr/backup/docs@snap-20241214      0B      -   7.78G  -
backups/usr/home@snap-20241213           172K      -   5.97M  -
backups/usr/home@snap-20241214             0B      -   5.97M  -

Tenga en cuenta las siguientes consideraciones al restaurar una instantánea:

. Se restaura la instantánea y el sistema de archivos.
. El sistema de archivos y todos los sistemas de archivos descendientes se desmontan.
. Los sistemas de archivos son inaccesibles mientras se restauran.
. El sistema de archivos original que e va a restaurar no debe exister mientras está siendo restaurado.
. Si existe un nombre de sistema de archivos en conflicto, puede utilizarse zfs rename para cambiar el nombre del sistema de archivos.

Restaurar instantánea de forma remota

-d Utilice la ruta completa de la instantánea enviada sin el primer elemento (sin el nombre del grupo) para determinar el nombre de la nueva instantánea.

 
ssh root@tormenta "zfs send -Rv backups/filesolaris/confsolaris@snap-20241215" \
| zfs receive -vFd zroot

full send of toshiba/filesolaris/confsolaris@snap-20241215 estimated size is 1.20M
total estimated size is 1.20M
receiving full stream of toshiba/filesolaris/confsolaris@snap-20241215 into \
zroot/filesolaris/confsolaris@snap-20241215
received 1.20M stream in 0.06 seconds (19.0M/sec)

Recuperar el flujo de datos desde tormenta (pool backups) a solaris

solaris~ # ssh root@tormenta "zfs send -Rv backups/usr/backup/docs@snap-20241216" \
zfs receive zroot/documentos

full send of toshiba/usr/backup/docs@snap-20241216 estimated size is 7.88G
send from @snap-20241216 to toshiba/usr/backup/docs@snap-20241217 estimated size is 105K
total estimated size is 7.88G
TIME   SENT   SNAPSHOT toshiba/usr/backup/docs@snap-20241216
...

 zfs list | grep "zroot/documentos"
zroot/documentos    96K   330G   96K  /zroot/documentos

Enviar el flujo de datos a un archivo

zfs send zroot/usr/home@-20241222-snap1 > usr.home.20241222.servidor

Podemos utilizar el comando receive y proporcionar el grupo en el que desea importarlo y podría ser un grupo completamente diferente, y es probablemente la principal razon por la que usarias esto para transferir un conjunto de datos a otro sistema, especifica el grupo y el conjunto de datos al que desea importarlo, si no proporciona uno simplemente creará un conjunto de datos con el nombre que se usó desde el momento en que se creo la instantánea. Ahora, usando cat nombre del archivo y canalizarlo a través de una tuberia a zfs receive, se creará un nuevo conjunto de datos llamado zroot/homeservidor

 cat usr.home.20241222.tormenta | zfs receive zroot/home.20241222.servidor

Listar el conjunto de datos
 zfs list | grep "zroot/homeservidor"
zroot/homeservidor  4.82M  264G  4.82M  /zroot/home.20241222.servidor


Otro ejemplo de envío y recepción de datos ZFS:

El comando zfs send crea una representación de flujo de una instantánea que está escrita, a la salida estándar. Puede redirigir la salida a un archivo o a un sistema diferente. El comando zfs receive crea una instantánea cuyo contenido se especifica en la secuencia que se proporciona en la entrada estándar. Si se recibe una transmisión completa, un nuevo sistema de archivos también se crea.

Creacion de los conjuntos de datos

 zfs -p create zroot/usuarios/user1
 zfs create zroot/usuarios/user2
 zfs create zroot/usuarios/user3

 zfs list -r zroot/usuarios
 NAME                   USED  AVAIL  REFER  MOUNTPOINT
 zroot/usuarios        63.5M   351G  63.2M  /zroot/usuarios
 zroot/usuarios/user1    96K   351G    96K  /zroot/usuarios/user1
 zroot/usuarios/user2    96K   351G    96K  /zroot/usuarios/user2
 zroot/usuarios/user3    96K   351G    96K  /zroot/usuarios/user3

Tomar las instantáneas

 zfs snapshot -r zroot/usuarios@hoy

Se crea una secuencia de replicación para todas las instantáneas de usuarios

 zfs send -R zroot/usuarios@hoy > /snaps/usuarios

A continuación, los sistemas de archivos originales y las instantáneas se destruyen

 zfs destroy -r zroot/usuarios
 zfs list -r zroot/usuarios
 cannot open 'zroot/usuarios': dataset does not exist

Y luego se recuperan

 zfs receive -Fd zroot < /snaps/usuarios
 zfs list -r zroot/usuarios
 NAME                   USED  AVAIL  REFER  MOUNTPOINT
 zroot/usuarios        63.6M   351G   112K  /zroot/usuarios
 zroot/usuarios/user1    96K   351G    96K  /zroot/usuarios/user1
 zroot/usuarios/user2    96K   351G    96K  /zroot/usuarios/user2
 zroot/usuarios/user3    96K   351G    96K  /zroot/usuarios/user3
FreeBSD es genial!.

domingo, 18 de diciembre de 2022

Replicar, Recuperar Pool Root FreeBSD ZFS

NFS Sistema de Archivos en Red FreeBSD
Montaje de Sistema de Archivos NFS Usando Autofs
Replicar, Recuperar Pool Root ZFS FreeBSD

Contruir o reconstruir un sistema a partir de instantáneas (snapshot)

Replicar instantáneas en otro sistema es una característica de OpenZFS que mejora la administración de datos, proporciona un mecanismo para manejar una falla de hardware con una pérdida de datos y un tiempo de inactividad mínimos. La replicación también es una forma conveniente de transferir una copia de un sistema existente a otro, por ejemplo, implementar un laboratorio completo de sistemas similares.

Escenario

Servidor: tormenta FreeBSD 13.1 NUC 11 Essential DDR4-2933 CPU 4 \
          32GB RAM M.2 NVMe PCIe 3.0
Cliente: solaris FreeBSD 13.1 Dell Latitude 7390 DDR4-2400 CPU 8 \
          16GB RAM M.2 NVMe PCIe 3.0

Enviar una copia de seguridad al servidor vía ssh utilizando zfs send receive

% cat /etc/hosts | grep tormenta
...
192.168.88.160          tormenta
...

Configurar acceso SSH

OpenZFS utiliza SSH para cifrar la replicación durante la transferencia de red.

Puede generar un par de claves con ssh-keygen y luego enviar una copia de la clave pública al servidor. Presione enter en todas las indicaciones para aceptar los valores predeterminados y no solicitar una frase de contraseña.

Dado que root enviará la replica, cambie esta línea en el archivo de configuración del demonio SSH /etc/ssh/sshd_config

#PermitRootLogin no

a

PermitRootLogin yes

Recargar la configuración del demonio SSH

service sshd reload

Enviar una copia de la clave pública al sistema recector (tormenta)

cat ~/.ssh/id_rsa.pub | ssh 192.168.88.160 'cat >>.ssh/authorized_keys' 
Password for root@192.168.88.160: 
exit

Crear un conjunto de datos para almacenar las instatáneas replicadas /usr/backup/poolrecovery.

tormenta # zfs create -p zroot/usr/backup/poolrecovery

Creamos la instantánea recursiva del conjunto de datos del pool zroot que incluye los sistemas de archivos secundarios

solaris # zfs snapshot -r zroot@zroot.snap1_dell

Comprobar los recursos compartidos por el servidor tormenta

solaris % showmount -e tormenta
Exports list on tormenta:
...
/usr/backup/poolrecovery        192.168.88.0 
...

Montar el recurso compartido

# mount -o soft,intr,rw tormenta:/usr/backup/poolrecovery /mnt

Enviar la instantánea de forma recursiva, redirigimos (como archivo comprimido .gz) a la ubicación compartida para poder acceder a esta ubicación al construir el cliente

# zfs send -Rv zroot@snap1_dell | gzip > /mnt/zroot.snap1.gz

Enviar a un sistema que se encuentra en otra ubicación geografica a través de una conexión ssh

zfs send -Rv zroot@snap-20241125 | ssh root@185.166.84.138 "gzip > \ 
/export/recovery/solaris/zroot@snap-solaris-20241125.gz"

Enviar al servidor de la red local a través de una conexión ssh

zfs send -Rv zroot@snap-20241125 | ssh root@192.168.88.160 "gzip > \ 
/export/recovery/solaris/zroot@snap-solaris-20241125.gz"

Proceso de recuperación

Asumimos que ha realizado una instalación limpia en el sistema a restaurar eligiendo el particionado auto ZFS en el instalador FreeBSD.

Iniciar con una memoria usb que contenga una img de FreeBSD 13.1 (misma RELEASE usada en la instalación del sistema a recuperar)

En la pantalla de instalacion

Install Shell Live cd

Elegir (live cd)

login: root

Intro (no necesita contrasena)

Iniciar la red con el comando

dhclient em0

Ver información de la conexión

# ifconfig

Comprobar conectividad

# ping freebsd.org

Importar el zpool

mkdir /tmp/zroot
zpool import -fR /tmp/zroot zroot

Para poder recibir directamente sobre zroot (sin el error de hijos), renombrar los conjuntos de datos de la instalación limpia a .old antes de lanzar el zfs receive.

Alternativa más elegante (un solo comando para todos)

Renombrar TODOS los hijos directos de zroot

for ds in $(zfs list -H -o name zroot | grep -v "^zroot$"); do 
	zfs rename -r "$ds" "${ds}.old"
done

Esto captura ROOT, tmp, usr, var, home y cualquier otro que haya aparecido.

Inspeccionar el contenido del backup antes de recibirlo (por comprobar su estructura)

ssh root@192.168.88.160 "cat /zbackup/recovery/solaris/zroot@snap-freebsd-14.3-release-p7-2026-5-enero.gz" | gzcat | zfs receive -nv zroot

La opción -n (dry-run) simula la recepción y muestra qué datasets se crearían, sin escribir nada.

Si se quere ver el progreso en porcentaje durante la transferencia, se puede intercalar pv (si está instalado)

ssh root@192.168.88.160 "cat /zbackup/recovery/solaris/zroot@snap-freebsd-14.3-release-p7-2026-5-enero.gz" | gzcat | pv | zfs receive -Fv zroot

Justo después de renombrar los datasets viejos (.old), y antes del zfs receive real, puedes añadir este paso de verificación robusta:

Verificación robusta

Verificación con zstreamdump (muestra resumen + checksum). zstreamdump puede ser lento con backups grandes y es opcional, pero muy recomendable para detectar corrupción antes de empezar.

ssh root@192.168.88.160 "cat /zbackup/recovery/solaris/zroot@snap-freebsd-14.3-release-p7-2026-5-enero.gz" | gzcat | zstreamdump

Si todo está bien, verás algo parecido a

BEGIN record
...
Total write size = 1234567890
END checksum = f1e2d3c4b5a6...

Pasar el archivo por red sin montar ningún directorio


Restaurar el backup (recibe directamente sobre zroot)

ssh root@192.168.88.160 "cat /zbackup/recovery/solaris/zroot@snap-freebsd-14.3-release-p7-2026-5-enero.gz" | gzcat | zfs receive -Fv zroot

VERIFICAR la Estructura Restaurada ANTES DE REINICIAR


Listar toda la jerarquía restaurada

zfs list -r zroot

Buscar el dataset que contiene el directorio /boot (señal inequívoca de sistema base)

zfs list -r zroot/ROOT
NAME                                           USED  AVAIL  REFER  MOUNTPOINT
zroot/ROOT                                     110G   177G    96K  none
zroot/ROOT/default                             110G   177G  26.5G  /

Confirmar el arranque apuntando a este conjunto de datos

zpool set bootfs=zroot/ROOT/default zroot

Ajustar el punto de montaje para que al reiniciar se monte en /

zfs set mountpoint=/ zroot/ROOT/default

Exportar el zpool y reiniciar

zpool export zroot
shutdown -r now

Si después de reiniciar todo funciona, limpiar los restos de la vieja instalación (ya dentro del nuevo sistema)

zfs destroy -rf zroot/ROOT.old zroot/tmp.old zroot/usr.old zroot/var.old zroot/home.old

-r recursivamente destruye todos los hijos
-f Si algún dataset está montado fuerza el desmontaje del conjunto de datos

FreeBSD es genial!.

martes, 19 de octubre de 2021

ZFS Local Replication en FreeBSD

Disco ZFS Local Send Receive Snapshots en FreeBSD La replicación de ZFS consta de dos partes: zfs send que serializa una instantánea o una serie de instantáneas en un flujo de datos mezclado, y zfs receive, que convierte ese flujo en un sistema de archivos ZFS. La replicación basada en instantáneas significa que puede hacer una replicación incremental, enviando sólo los bloques que han cambiado; los mismos datos nunca se envían dos veces. El conjunto de datos ZFS transmitido es totalmente coherente, a diferencia del volcado o rsyncing de un sistema de archivos en vivo. Crear un punto de montaje # mkdir /mnt/zbackupsConectar la unidad usb # lsblk

 DEVICE         MAJ:MIN SIZE TYPE                          LABEL MOUNT
ada0             0:96  112G GPT                               - -
  ada0p1         0:97  260M efi                          gpt/efiboot0 /boot/efi
  ada0p2         0:98  512K freebsd-boot                 gpt/gptboot0 -
  free         -:-   492K -                                       - -
  ada0p3         0:99  2.0G freebsd-swap                    gpt/swap0 SWAP
  ada0p3.eli     0:93  2.0G freebsd-swap                           - SWAP
  ada0p4         0:100 110G freebsd-zfs                      gpt/zfs0 zfs
  free         -:-   452K -                                       - -
da0              1:164 932G GPT                               - -
  da0p1          1:166 932G freebsd-zfs                             - zfs

# geom disk list

Geom name: ada0
Providers:
1. Name: ada0
   Mediasize: 120034123776 (112G)
   Sectorsize: 512
   Stripesize: 4096
   Stripeoffset: 0
   Mode: r3w3e6
   descr: Samsung SSD 850 EVO 120GB
   lunid: 5002538d4010a7f6
   ident: S21UNXAG517311N
   rotationrate: 0
   fwsectors: 63
   fwheads: 16

Geom name: da0
Providers:
1. Name: da0
   Mediasize: 1000204886016 (932G)
   Sectorsize: 512
   Stripesize: 4096
   Stripeoffset: 0
   Mode: r0w0e0
   descr: HGST HTS 541010A9E680
   lunname: HGST HTS541010A9E680    160324JD1042ZF1J
   lunid: 3016032414104216
   ident: 160324A41042A61A4543
   rotationrate: unknown
   fwsectors: 63
   fwheads: 255

Particionar el disco externo. Esta es una operación destructiva e irreversible

# gpart destroy -F da0 
  # gpart create -s gpt da0
  da0 created 
  # gpart add -t freebsd-zfs -s 900G -l zbackups da0
  da0p1 added 
  # gpart show da0
=>        40  1953525088  da0  GPT  (932G)
          40  1887436800    1  freebsd-zfs  (900G)
  1887436840    66088288       - free -  (32G)

gpart show -p da0
=>        40  1953525088    da0  GPT  (932G)
          40  1887436800  da0p1  freebsd-zfs  (900G)
  1887436840    66088288         - free -  (32G)

# zpool create zbackups da0p1

Establecer el punto de montaje

# zfs set mountpoint=/mnt/zbackups zbackups

Crear conjunto de datos (dataset) en la unidad zbackups - los puntos de montaje se crean automáticamente.

# zfs create zbackups/carlos
# zfs create zbackups/vm
# zfs create zbackups/vm/alpine
# zfs create zbackups/vm/arch
# zfs create zbackups/vm/freebsd
# zfs list

NAME                           USED  AVAIL     REFER  MOUNTPOINT
zbackups                      1.02M   868G       96K  /mnt/zbackups
zbackups/carlos                104K   868G      104K  /mnt/zbackups/carlos
zbackups/vm                    384K   868G       96K  /mnt/zbackups/vm
zbackups/vm/alpine              96K   868G       96K  /mnt/zbackups/vm/alpine
zbackups/vm/arch                96K   868G       96K  /mnt/zbackups/vm/arch
zbackups/vm/freebsd             96K   868G       96K  /mnt/zbackups/vm/freebsd
...

Listar snapshot

# zfs list -t snapshot

Enviar el conjunto de datos del directorio personal a la unidad externa zbackups.

Primero crear la instantánea para después enviar

(snap_`date +%d%m%y%H%M`)
zfs snapshot zroot/usr/home@/carlos@snap_`date +%d%m%y%H%M`
# zfs snapshot zroot/usr/home/carlos@snap_1910211203

Enviar el conjunto de datos a zbackups/carlos

# zfs send -v zroot/usr/home/carlos@snap_1910211203 | zfs receive -F \ 
zbackups/carlos

# zfs snapshot zroot/vm@snap_1910211203

# zfs send -v zroot/vm@snap_1910211203 | zfs receive -F zbackups/vm

# zfs snapshot zroot/vm/alpine@snap_1910211203

# zfs send -v zroot/vm/alpine@snap_1910211203 | zfs receive -F \ 
zbackups/vm/alpine

# zfs snapshot zroot/vm/arch@snap_1910211203

# zfs send -v zroot/vm/arch@snap_1910211203 | zfs receive -F zbackups/vm/arch

# zfs snapshot zroot/vm/freebsd-12-2@snap_1910211203
# zfs snapshot zroot/vm/freebsd-12-2/disk1@snap_1910211203

# zfs send -Rv zroot/vm/freebsd-12-2@snap_1910211203 | zfs receive \
-F zbackups/vm/freebsd

snapshot del pool completo zroot

# zfs snapshot -r zroot@snap1_021121

Crear dataset zbackups

# zfs create zbackups/snap1full

Enviar recursivamente las snpashots

# zfs send -vR zroot@snap_021121 | zfs receive zbackups/snap1full

Los conjuntos de datos de las instantáneas recibidas deben estar impecables para que los zfs reciban aceptar actualizaciones incrementales o diferenciales. La bandera -F le dice a zfs Receive que revierte cualquier cambio que impida aceptar esto instantánea.

# zfs send -vR zroot@snap_021121 | zfs receive -F zbackups/snap1full 
# grc zfs list -t all -r zbackups

Instantáneas incrementales

Crear las instantánea(s)
# zfs snapshot zroot/usr/home/carlos@snap_20102112020

Enviar instantáneas incrementales.

# zfs send -i zroot/usr/home/carlos@snap_1910211203 \ 
zroot/usr/home/carlos@snap_20102112020 | zfs receive \ 
-F zbackups/carlos

% smartctl -a /dev/ada0

smartctl 7.2 2020-12-30 r5155 [FreeBSD 13.0-RELEASE-p4 amd64] (local build)
Copyright (C) 2002-20, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Family:     Samsung based SSDs
Device Model:     Samsung SSD 850 EVO 120GB
Serial Number:    S21UNXAG517311N
LU WWN Device Id: 5 002538 d4010a7f6
Firmware Version: EMT01B6Q
User Capacity:    120.034.123.776 bytes [120 GB]
Sector Size:      512 bytes logical/physical
Rotation Rate:    Solid State Device
TRIM Command:     Available
Device is:        In smartctl database [for details use: -P show]
ATA Version is:   ACS-2, ATA8-ACS T13/1699-D revision 4c
SATA Version is:  SATA 3.1, 6.0 Gb/s (current: 6.0 Gb/s)
Local Time is:    Wed Oct 20 00:00:26 2021 CEST
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

=== START OF READ SMART DATA SECTION ===
SMART overall-health self-assessment test result: PASSED
...

% smartctl -a /dev/da0
martctl 7.2 2020-12-30 r5155 [FreeBSD 13.0-RELEASE-p4 amd64] (local build)
Copyright (C) 2002-20, Bruce Allen, Christian Franke, www.smartmontools.org

=== START OF INFORMATION SECTION ===
Model Family:     HGST Travelstar 5K1000
Device Model:     HGST HTS541010A9E680
Serial Number:    160324JD1042ZF1J45DS
LU WWN Device Id: 5 000cca 887d56d1c
Firmware Version: JA0OA5M0
User Capacity:    1.000.204.886.016 bytes [1,00 TB]
Sector Sizes:     512 bytes logical, 4096 bytes physical
Rotation Rate:    5400 rpm
Form Factor:      2.5 inches
Device is:        In smartctl database [for details use: -P show]
ATA Version is:   ATA8-ACS T13/1699-D revision 6
SATA Version is:  SATA 2.6, 3.0 Gb/s (current: 3.0 Gb/s)
Local Time is:    Wed Oct 20 00:02:24 2021 CEST
SMART support is: Available - device has SMART capability.
SMART support is: Enabled

=== START OF READ SMART DATA SECTION ===
SMART Status not supported: Incomplete response, ATA output registers missing
SMART overall-health self-assessment test result: PASSED
...
FreeBSD es genial!.