Páginas

Buscar este blog

Mostrando entradas con la etiqueta recovery. Mostrar todas las entradas
Mostrando entradas con la etiqueta recovery. 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!.

jueves, 19 de febrero de 2026

Migración de SSD a disco de mayor capacidad en FreeBSD 14.3 send receive vía USB

Estado actual del sistema

zpool status
zpool list 
zpool list -t all

Identificar discos

geom disk list
camcomtrol devlist

Anotar el disco actual (ada0) y el nuevo disco USB (da0)


Limpiar el disco nuevo completamente

gpart destroy -F da0
dd -if=/dev/zero of=/dev/da0 bs=1M count=100

Crear tabla de particiones GPT

gpart create -s gpt da0

Partición de arranque EFI (si el sistema usa UEFI)

gpart add -t efi -s 260M -l efiboot-new da0

Partición de arranque BIOS/GPT (para compatibilidad legacy)

gpart add -t freebsd-boot -s 512k -l gptboot-new da0

Partición swap

gpart add -t freebsd-swap -s 8G -a 1M -l swap0 da0

Particion ZFS (el resto del disco)

gpart add -t freebsd-zfs -a 1M -l zroot-new da0

Para sistemas UEFI


Montar partición EFI del disco nuevo

newfs_msdos -F 32 -c 1 /dev/da0p1
mount -t msdosfs /dev/da0p1 /mnt

Copiar EFI loader desde el actual disco

mkdir -p /mnt/EFI/BOOT
cp -r /boot/efi/EFI/BOOT /mnt/EFI/

umount /mnt

Crear pool temporal en el nuevo disco

Crear pool temporal con nombre diferente para evitar conflictos
zpool create -o altroot=/mnt \
             -o ashift=12 \
             -O compression=lz4 \
             -O atime=off \
             -O xattr=sa \
             -O acltype=posix \
             -m none \
             zroot-new /dev/da0p3

Verificar

zpool status zroot-new

Listar todos los datasets a migrar

zfs list -H -o name -t filesystem,volume

Tomar snapshot recursivo de todo el pool (Shell zsh)

sudo zfs snapshot -r zroot@migracion

Verificar snapshot creado

zfs list -t snapshot -o name | grep "$migracion" 
zroot@migracion
zroot/ROOT@migracion
zroot/ROOT/14.3-RELEASE-filebrowser-tailscale-serve-certs-https@migracion
zroot/ROOT/14.3-RELEASE_2026-02-14_193200@migracion
zroot/ROOT/default@2026-02-14-19:32:00-0
zroot/ROOT/default@2026-02-17-17:48:09-0
zroot/ROOT/default@migracion
zroot/home@migracion
zroot/home/carlos@migracion
zroot/tmp@migracion
zroot/usr@migracion
zroot/usr/ports@migracion
zroot/usr/src@migracion
zroot/var@migracion
zroot/var/audit@migracion
zroot/var/crash@migracion
zroot/var/log@migracion
zroot/var/mail@migracion
zroot/var/tmp@migracion

Enviar snapshot raíz primero

zfs send -Lec zroot@migration-$(date +%Y%m%d) | \
    zfs receive -Fuv zroot-new

Enviar recursivamente todos los datasets hijos

zfs send -RLec zroot@migration-$(date +%Y%m%d) | \
    zfs receive -Fuv zroot-new

Banderas (flags)

-R Recursivo (todos los datasets hijos)
-L Incluye large blocks
-e Embed data (bloques pequeños inline)
-c Comprime el stream
-F En receive: fuerza rollback si es necesario
-u No monta los datasets al recibirlos
-v Verbose

Comprobar la replicación


Comparar conjuntos de datos entre pools

zfs list -r zroot
zfs list -r zroot-new

Verificar propiedades

zfs get all zroot
zfs get all zroot-new

Cantidad de instantáneas

zfs list -t snapshot -r zroot | wc -l
zfs list -t snapshot -r zroot-new | wc -l

Configurar bootfs en el nuevo pool

zpool set bootfs=zroot-new/ROOT/default zroot-new

Verificar

zpool get bootfs zroot-new

Ajustar cachefile y otros parámetros del pool

zpool set cachefile=/boot/zfs/zpool.cache zroot-new

Ver propiedades del pool original para replicarlas

zpool get all zroot

Montar el dataset raíz del nuevo disco

zfs set mountpoint=/mnt zroot-new/ROOT/default
zfs mount zroot-new/ROOT/default

Verificar /boot/loader.conf

cat /mnt/boot/loader.conf

Debe contener algo como:

zfs_load="YES"
vfs.root.mountfrom="zfs:zroot/ROOT/default"

Si el nombre del pool cambió, actualizar:

sed -i '' 's/zroot-new/zroot/g' /mnt/boot/loader.conf

También verificar /etc/fstab (en ZFS puro suele estar sin referencias a ada0)

cat /mnt/etc/fstab

Cambiar el disco y primer arranque


Apagar el sistema

shutdown -p now

Desconectar el disco viejo Conectar el nuevo disco en el slot interno (ya no como USB) Comprobar en BIOS/UEFI que el nuevo disco sea el primero en el orden de arranque Arrancar

Verificación después del arranque


Comprobar salud del pool

zpool status
zpool list

Verificar que todos los datasets montaron

zfs list -t filesystem

Verificar espacio disponible (debe reflejar el disco nuevo mayor)

df -h

Verificar que el sistema arrancó desde el disco correcto

geom disk list
camcontrol devlist

Limpiar snapshots de migración

zfs destroy -r zroot@migracion

Problemas y posibles soluciones después del primer arranque


Renombrar zpool zroot-new a zroot

zpool import -f zroot-new zroot

Error

zpool export zroot-new Cannot unmount /

Es el error clásico: el dataset raíz (/) está montado desde zroot-new, así que ZFS no puede desmontarlo en caliente

Solución Desde loader prompt o LiveCD


Desde el LiveCD

zpool import -f zroot-new zroot
zpool set bootfs=zroot/ROOT/default zroot
zpool export zroot

zpool import -f zroot-new zroot
   zpool set bootfs=zroot/ROOT/default zroot
   zpool export zroot hecho.

Reiniciar

shutdown -r now

FreeBSD al arrancar y no encontrar zroot buscará pools disponibles. Si el disco nuevo ya está interno, lo encontrará como zroot-new y podrás importarlo con el nombre correcto.

Después de reiniciar sin el LiveCD el sistema arranca desde el nuevo disco duro.

Estos dos errores son normales y esperables en este proceso.

1. swapon: /dev/da0p3: No such file or directory, 
2. Import of zpool cache /etc/zfs/zpool.cache failed

El archivo /etc/fstab del sistema nuevo todavía referencia el dispositivo del disco USB (da0) que ya no existe. Ahora el disco está interno, probablemente como ada0 o nvme0ns1.

Montar el sistema de ficheros rw

mount -u -o rw /

Averiguar cómo se llama el disco ahora geom disk list o camcontrol devlist.

geom disk list                                    
Geom name: ada0
Providers:
1. Name: ada0
   Mediasize: 250059350016 (233G)
   Sectorsize: 512
   Mode: r3w3e7
   descr: WDC WDS250G2B0A-00SM50
   lunid: 5001b448b8a2a91f
   ident: 192686806761
   rotationrate: 0
   fwsectors: 63
   fwheads: 16

Cambiar la línea de swap, por ejemplo

/dev/da0p3  none   swap  sw   0   0
 por
/dev/ada0p3  none   swap  sw   0   0

Mejor aún, usar la etiqueta (label) GPT que es independiente del nombre del dispositivo

gpart show -l ada0
=>       40  488397088  ada0  GPT  (233G)
         40     532480     1  efiboot0  (260M)
     532520       1024     2  gptboot0  (512K)
     533544        984        - free -  (492K)
     534528   16777216     3  swap0  (8.0G)
   17311744  471085056     4  zroot-new  (225G)
  488396800        328        - free -  (164K)
ls /dev/gpt/
efiboot0 gptboot0 swap0

En el archivo /etc/fstab usar la etiqueta en lugar del dispositivo

...
/dev/gpt/swap0	  none	  swap	  sw	 0	0
...

Error 2

Import of zpool cache /etc/zfs/zpool.cache failed

El zpool.cache fue generado cuando el pool se llamaba zroot-new y estaba en da0. Ahora el pool se llama zroot y el dispositivo cambió. El caché está obsoleto.

Sencillamente borrarlo, ZFS lo regenera automáticamente

rm /etc/zfs/zpool.cache

Antes de reiniciar para verificar el nombre correcto del dispositivo

swapinfo -h
Device              Size     Used    Avail Capacity
/dev/gpt/swap0      8.0G       0B     8.0G     0%

Si el sistema arrancó pero con errores no críticos Ambos errores no impiden el funcionamiento del sistema. El swap simplemente no está activo hasta que corrijas el fstab, y el zpool.cache se regenera solo. Si llegaste al prompt de login, la migración fue exitosa.

Reiniciar

shutdown -r now

Error 3.

Can't open /dev/gpt/efiboot0

Ese error indica que el bootloader está buscando la partición EFI por su label GPT (efiboot0) pero no la encuentra, probablemente porque el label en el disco nuevo es diferente o no se asignó correctamente

ls /dev/gpt
efiboot0 gptboot0 swap0

Montar el sistema de ficheros rw

mount -u -o rw /

Solución. Renombrar el label al esperado

...
/dev/gpt/efiboot0    /boot/efi	  msdosfs    rw	   2	2
...

Corregir el label

gpart modify -i 1 -l efiboot0 ada0

Si la partición EFI estaba vacía, reinstalar loader

newfs_msdos -F 32 -c 1 /dev/ada0p1
mount -t msdosfs /dev/ada0p1 /mnt
mkdir -p /mnt/EFI/BOOT
cp /boot/loader.efi /mnt/EFI/BOOT/BOOTX64.EFI

umount /mnt

 

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!.