Páginas

Buscar este blog

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

domingo, 15 de noviembre de 2026

Boot Environments en FreeBSD con bectl: guía práctica desde cero

Las tres capas de seguridad

CAPA 3 Boot Environment bectl create -r

Sistema completo arrancable. El rollback "nuclear": si todo falla, arrancas desde el BE anterior y listo.

▼
CAPA 2 Script de rollback rollback-whitesur.sh

Dataset por dataset, con dry-run y confirmación interactiva. El rollback quirúrgico.

▼
CAPA 1 Snapshot ZFS zfs snapshot -r

Todo el árbol en segundos. La red de seguridad instantánea antes de tocar nada.

Tres capas que se complementan y cubren escenarios distintos.

Versión del documento: 1.0
Ámbito: FreeBSD 12+ con ZFS (con notas para 13/14/15)
Caso práctico conductor: proteger el sistema antes de instalar el tema WhiteSur en XFCE

Índice

  1. Introducción
  2. Conceptos clave
  3. Crear un BE
  4. Listar e inspeccionar
  5. Montar un BE
  6. Activar un BE
  7. Integración con el cargador de arranque
  8. Destruir y limpiar
  9. Renombrar y otras operaciones
  10. Caso práctico completo: WhiteSur en XFCE
  11. Tabla resumen de comandos
  12. Apéndice: beadm para quien venga de ahí

1. Introducción

1.1 Qué es un Boot Environment

Un Boot Environment (BE) es una copia completa y coherente del sistema operativo (y, opcionalmente, de los datos que tú decidas) que puedes arrancar como si fuera el sistema real. Internamente, un BE no es una copia física: es un clon ZFS de un snapshot, lo que significa que:

  • Ocupa muy poco espacio inicialmente (solo los bloques que cambian respecto al snapshot original).
  • Es atómico: se crea en una sola operación, sin estados intermedios.
  • Es reversible: puedes volver al estado anterior en segundos.

La idea es la misma que los "boot environments" de Solaris/illumos o los snapshots de sistema de otras plataformas: una red de seguridad de bajo coste y alta fiabilidad.

1.2 bectl vs beadm: la transición al estándar moderno

Históricamente, la herramienta de gestión de BEs en FreeBSD era beadm, instalada desde ports. A partir de FreeBSD 12, el sistema base incluye bectl, llamada a ser su reemplazo definitivo. Las diferencias prácticas son importantes:

Aspectobeadm (legacy)bectl (moderno)
OrigenPort (pkg install beadm)Sistema base
Recursivo por defecto✅ Sí❌ No (requiere -r)
Confirmación al destruir✅ Sí❌ No (cuidado)
EstadoMantenido por la comunidadEstándar oficial
⚠️ Advertencia clave: el hecho de que bectl no sea recursivo por defecto es la diferencia más importante que debes interiorizar. Si vienes de beadm, esto te puede pillar desprevenido. Lo detallamos en la sección 2.

1.3 Requisitos

  • FreeBSD con el sistema raíz sobre ZFS.
  • Versión 12.0 o superior (para tener bectl en el sistema base).
  • El script /etc/rc.d/zfsbe presente para la integración con el cargador de arranque (lo está por defecto en versiones modernas).
  • Privilegios de root para la mayoría de operaciones.

Comprobación rápida del entorno:

# Verificar que ZFS está activo y cuál es el pool raíz
zpool list
zfs list

# Verificar que bectl está disponible
bectl --version 2>/dev/null || which bectl

# Verificar el script de integración con el loader
ls -l /etc/rc.d/zfsbe

2. Conceptos clave

2.1 Relación entre BE, snapshot ZFS y clon

Un BE se compone de tres piezas:

  1. Snapshot ZFS: una "foto" inmutable del dataset en un instante concreto.
  2. Clon ZFS: un dataset nuevo que comparte los bloques del snapshot y solo diverge cuando se escribe en él (copy-on-write).
  3. Entrada en el menú de arranque: el loader de FreeBSD detecta los clones y te permite elegir cuál arrancar.

Cuando ejecutas bectl create mi-be, internamente se hace algo equivalente a:

zfs snapshot zroot/ROOT/default@mi-be
zfs clone zroot/ROOT/default@mi-be zroot/ROOT/mi-be

(Los nombres exactos varían según la configuración, pero la lógica es esta.)

2.2 El matiz del -r: beadm era recursivo, bectl no

Este es el punto que más confusión genera y el que tienes que tener grabado a fuego.

  • beadm create mi-be: creaba un snapshot recursivo (zfs snapshot -r) y un clon de todos los datasets bajo el punto de montaje raíz. Esto incluía zroot/usr/home, zroot/var/log, etc. Tu home quedaba protegido automáticamente.
  • bectl create mi-be: solo actúa sobre el dataset de nivel superior del BE (normalmente zroot/ROOT/default). Tu home NO se incluye.
  • bectl create -r mi-be: replica el comportamiento de beadm, incluyendo recursivamente todos los datasets hijos.
Implicación práctica: si quieres que tu directorio personal (/usr/home) quede protegido en el BE, debes usar -r. Esto es especialmente importante en el caso de WhiteSur, porque el tema se instala en ~/.themes.
# Solo protege el sistema base
sudo bectl create antes-whitesur

# Protege el sistema base Y el home
sudo bectl create -r antes-whitesur

2.3 Arrancar desde un BE vs activar un BE

Son dos operaciones distintas y conviene no confundirlas:

  • Arrancar desde un BE (selección puntual en el menú del loader): afecta solo a este arranque. En el siguiente reinicio, volverás al BE por defecto.
  • Activar un BE (bectl activate): cambia el BE por defecto de forma permanente (hasta que lo cambies otra vez).

Esto te da dos modos de uso:

  • Modo "prueba": seleccionas el BE en el menú del loader, compruebas que funciona, y si te convence, lo activas.
  • Modo "rollback": activas directamente el BE anterior y reinicias. El BE roto queda como "el otro" por si acaso.

3. Crear un BE

3.1 Creación básica (solo sistema base)

sudo bectl create antes-whitesur

Esto crea un BE llamado antes-whitesur a partir del estado actual de zroot/ROOT/default. No incluye /usr/home, /var/log, ni otros datasets hijos.

3.2 Creación recursiva (sistema + home + resto)

sudo bectl create -r antes-whitesur

Este es el comando que debes usar si quieres una red de seguridad completa, como la que ofrecía beadm por defecto. Incluye recursivamente todos los datasets bajo el punto de montaje raíz.

3.3 Cuándo usar cada uno

EscenarioComando recomendado
Solo vas a tocar el sistema base (kernel, drivers, actualizaciones)bectl create nombre
Vas a instalar software que escribe en tu home (temas, dotfiles)bectl create -r nombre
Quieres una red de seguridad "total" antes de algo riesgosobectl create -r nombre
Quieres un BE mínimo para pruebas rápidas de kernelbectl create nombre

3.4 Verificación inmediata

bectl list

Deberías ver el nuevo BE en la lista. Si usaste -r, también puedes verificar los datasets incluidos:

bectl list -a

O directamente con ZFS:

zfs list -r zroot/ROOT

4. Listar e inspeccionar

4.1 bectl list: interpretación de columnas

bectl list

Salida típica:

BE               Active Mountpoint Space Created
default          NR     /          12.5G 2026-11-10 09:00
antes-whitesur   -      -          245M  2026-11-11 12:30
ColumnaSignificado
BENombre del Boot Environment
ActiveN = activo ahora, R = activo en el próximo arranque, - = inactivo
MountpointPunto de montaje (solo si está montado)
SpaceEspacio que ocupa (incluye lo compartido con otros BEs)
CreatedFecha de creación

4.2 bectl list -a: todos los datasets incluidos

bectl list -a

Muestra, para cada BE, todos los datasets que lo componen. Es la forma de confirmar que tu home está o no incluido.

4.3 Comparación con zfs list

Para ver los clones ZFS subyacentes:

zfs list -r -t all zroot/ROOT

Verás los datasets zroot/ROOT/default, zroot/ROOT/antes-whitesur, y sus snapshots asociados.

5. Montar un BE

Esta es, probablemente, la funcionalidad más útil y menos conocida de bectl. Te permite inspeccionar, reparar o extraer archivos de un BE sin arrancar desde él.

5.1 Montar

sudo bectl mount antes-whitesur

Salida:

/tmp/be_mount.XXXX

Ese directorio temporal contiene el BE montado en modo lectura-escritura. Puedes navegar por él como si fuera tu sistema:

ls /tmp/be_mount.XXXX/etc
cat /tmp/be_mount.XXXX/etc/rc.conf

5.2 Casos de uso típicos

  • Recuperar un archivo borrado: si borraste accidentalmente algo y el BE anterior lo tiene, puedes copiarlo desde el montaje.
  • Revisar logs del estado anterior: comparar /var/log del BE con el actual.
  • Reparar configuración: si el sistema no arranca porque rompiste /etc/fstab o /etc/rc.conf, puedes editar el archivo desde el BE montado.
  • Inspeccionar un BE sospechoso: antes de arrancar desde él, verificar que tiene lo que esperas.

5.3 Desmontar

sudo bectl umount antes-whitesur

O especificando el punto de montaje:

sudo umount /tmp/be_mount.XXXX

5.4 bectl jail: ejecutar comandos dentro del BE

Una variante muy potente: en lugar de montar y editar a mano, puedes ejecutar un comando dentro del BE como si fuera un jail:

sudo bectl jail antes-whitesur

Esto te deja en una shell dentro del BE. Desde ahí puedes:

  • Regenerar la configuración de red.
  • Reparar paquetes con pkg.
  • Recompilar el kernel.
  • Ejecutar freebsd-update sobre ese BE.

Salir con exit desmonta y limpia automáticamente.

Nota: bectl jail requiere que el BE no esté activo. Es una herramienta de reparación, no de uso diario.

6. Activar un BE

6.1 Activación permanente

sudo bectl activate antes-whitesur

En el próximo arranque, el sistema usará antes-whitesur como BE por defecto. Verifica con:

bectl list

La columna Active mostrará R en antes-whitesur y N en el actual hasta que reinicies.

6.2 Activación temporal (solo próximo arranque)

sudo bectl activate -t antes-whitesur

Esto es oro puro para pruebas: el próximo arranque usará antes-whitesur, pero si no te convence, el siguiente volverá al BE original. Ideal para:

  • Probar un rollback en un servidor remoto sin riesgo.
  • Validar que un BE recién creado arranca correctamente.
  • Hacer cambios experimentales sin compromiso.

6.3 Verificar cuál se usará en el próximo arranque

bectl list

La columna Active te lo dice: R marca el que se usará en el próximo arranque.

7. Integración con el cargador de arranque

7.1 El menú automático

Si tu sistema arranca desde ZFS y /etc/rc.d/zfsbe está presente, el loader de FreeBSD añade automáticamente una entrada al menú (típicamente la opción #7, "Boot Environments") que lista todos los BEs disponibles.

Flujo típico:

  1. Reinicias.
  2. En el menú del loader, seleccionas la opción de Boot Environments.
  3. Eliges el BE que quieres arrancar.
  4. El sistema arranca desde ese BE solo para esta vez (a menos que luego lo actives).

7.2 Selección puntual sin cambiar el BE por defecto

Esta es la combinación más segura para probar un rollback:

  1. Arrancas desde el BE anterior vía menú del loader.
  2. Compruebas que todo funciona.
  3. Si te convence, sudo bectl activate antes-whitesur y reinicias.
  4. Si no, reinicias normalmente y vuelves al BE original.

7.3 Solución de problemas

El menú de BEs no aparece:

  • Verifica que /etc/rc.d/zfsbe existe y es ejecutable.
  • Comprueba que /boot/loader.conf tiene zfs_load="YES".
  • Revisa que el pool ZFS es arrancable (zpool get bootfs).

El sistema se cuelga al seleccionar un BE:

  • Puede ser un problema del propio BE (kernel corrupto, fstab mal).
  • Alternativa robusta: arrancar en el BE por defecto y usar bectl activate desde ahí.

8. Destruir y limpiar

8.1 Destruir un BE

sudo bectl destroy antes-whitesur
⚠️ Crítico: bectl destroy no pide confirmación. Un typo y adiós BE. Verifica siempre el nombre con bectl list antes de ejecutar.

8.2 Destruir forzando

sudo bectl destroy -F antes-whitesur

La -F fuerza el desmontaje y la destrucción incluso si hay problemas. Útil en scripts, peligroso en uso interactivo.

8.3 Qué NO puedes destruir

  • El BE activo (N en la columna Active): el sistema no te deja, obviamente.
  • El BE que se usará en el próximo arranque (R): tampoco, hasta que cambies la activación.

8.4 Estrategia de limpieza periódica

Los BEs consumen espacio (aunque poco, gracias a copy-on-write). Una rutina saludable:

# 1. Ver todos los BEs y su espacio
bectl list

# 2. Identificar los que ya no necesitas (por fecha, por nombre)
# 3. Destruir los antiguos, uno por uno
sudo bectl destroy nombre-viejo

# 4. Verificar el espacio liberado
zfs list -o name,used,refer
Regla práctica: mantén 2-3 BEs como máximo (el actual, el anterior estable, y quizás uno de "por si acaso"). Más que eso es acumular basura.

9. Renombrar y otras operaciones

9.1 Renombrar un BE

sudo bectl rename nombre-viejo nombre-nuevo

Útil para poner nombres descriptivos (antes-whitesur → pre-whitesur-2026-11).

9.2 Export / Import (según versión)

Algunas versiones de bectl soportan export e import para mover BEs entre sistemas. Consulta man bectl para tu versión concreta, porque la disponibilidad varía.

9.3 bectl en scripts

Todos los comandos son aptos para scripting. Recomendaciones:

  • Usa -F en destroy para evitar prompts.
  • Verifica siempre con bectl list antes de operaciones destructivas.
  • Combina con zfs list para monitorizar espacio.

10. Caso práctico completo: WhiteSur en XFCE

Nota: esta sección usa WhiteSur como ejemplo de flujo de trabajo con BE + snapshot + rollback. La instalación del tema en sí se documenta en un artículo aparte (enlace en 10.2), porque el install.sh original no funciona en FreeBSD.

10.1 Fase 1: crear la red de seguridad

# Opción A: BE recursivo (protege sistema + home)
sudo bectl create -r antes-whitesur

# Opción B: snapshot ZFS adicional (cinturón y tirantes)
sudo zfs snapshot -r zroot@antes-whitesur

# Verificar
bectl list
zfs list -t snapshot | grep antes-whitesur

10.2 Fase 2: instalar el tema

⚠️ Importante: el script install.sh de WhiteSur no funciona en FreeBSD. Está diseñado para GNU/Linux y depende de herramientas como sed, readlink y setterm, que en FreeBSD se comportan de forma distinta y hacen que el script falle.

Para la instalación real, sigue la guía específica para FreeBSD, que explica el método manual (descarga de paquetes compilados y copia de iconos) paso a paso:

Resumen del método que describe la guía (para que tengas el contexto, pero sigue el enlace para los detalles):

  • Tema GTK: descargar el .tar.xz compilado desde la página de Releases (no el "Source code") y extraerlo en ~/.themes/.
  • Iconos: descargar el código fuente, copiar src/* a ~/.local/share/icons/WhiteSur/ y corregir el index.theme manualmente (el sed de FreeBSD requiere -i '', y aun así el script original falla).

10.3 Fase 3: aplicar el tema en XFCE

  1. Apariencia → Estilo: WhiteSur o WhiteSur-Dark (tema GTK).
  2. Apariencia → Iconos: WhiteSur (paquete de iconos).
  3. Gestor de ventanas → Estilo: WhiteSur (bordes de ventana).
  4. Gestor de ventanas → Botones: arrastrar botones a la izquierda.

O por línea de comandos (solo el layout de botones):

xfconf-query -c xfwm4 -p /general/button_layout -s "O|HMC"

10.4 Fase 4a: si algo falla (rollback vía BE)

Escenario: XFCE no arranca o se ve fatal.

# 1. Reiniciar
# 2. En el menú del loader, seleccionar opción de Boot Environments
# 3. Elegir "antes-whitesur"
# 4. El sistema arranca en el estado anterior
# 5. Si todo va bien, activar permanentemente:
sudo bectl activate antes-whitesur
# 6. Reiniciar de nuevo

10.5 Fase 4b: si algo falla (rollback vía snapshot ZFS + script)

Escenario: prefieres un rollback quirúrgico solo del home.

# 1. Arrancar en single-user (opción 2 o 4 del loader)
# 2. Ejecutar el script de rollback
./rollback-whitesur.sh zroot/usr/home antes-whitesur --dry-run
./rollback-whitesur.sh zroot/usr/home antes-whitesur
# 3. Reiniciar

10.6 Fase 5: limpieza

Una vez confirmado que el sistema funciona con el tema (o sin él, tras el rollback):

# Destruir el BE que ya no necesitas
sudo bectl destroy antes-whitesur

# Destruir el snapshot ZFS si ya no lo necesitas
sudo zfs destroy -r zroot@antes-whitesur

10.7 Las tres capas de seguridad (resumen)

CapaHerramientaAlcanceCuándo usarla
1Snapshot ZFS (zfs snapshot -r)Todo el árbolRed de seguridad instantánea
2Script rollback-whitesur.shDataset por datasetRollback quirúrgico
3Boot Environment (bectl create -r)Sistema completo arrancableRollback "nuclear"

11. Tabla resumen de comandos

AcciónComandoNotas
Crear BE (solo sistema)sudo bectl create nombreNo incluye home
Crear BE (recursivo)sudo bectl create -r nombreIncluye home y resto
Listar BEsbectl listVer columna Active
Listar datasets del BEbectl list -aVer qué incluye cada BE
Montar BEsudo bectl mount nombreDevuelve punto de montaje
Desmontar BEsudo bectl umount nombreO umount /tmp/...
Jail en BEsudo bectl jail nombreShell dentro del BE
Activar BE (permanente)sudo bectl activate nombrePróximo arranque en adelante
Activar BE (temporal)sudo bectl activate -t nombreSolo próximo arranque
Renombrar BEsudo bectl rename viejo nuevo—
Destruir BEsudo bectl destroy nombre⚠️ Sin confirmación
Destruir BE (forzado)sudo bectl destroy -F nombrePara scripts
Ver versiónbectl --version—
Ayudaman bectlDocumentación completa

12. Apéndice: beadm para quien venga de ahí

12.1 Tabla de equivalencias

Acciónbeadmbectl
Crearbeadm create nombrebectl create nombre
Crear recursivobeadm create nombre (ya lo es)bectl create -r nombre
Listarbeadm listbectl list
Montarbeadm mount nombre /mntbectl mount nombre
Desmontarbeadm umount nombrebectl umount nombre
Activarbeadm activate nombrebectl activate nombre
Activar temporal(no soportado)bectl activate -t nombre
Destruirbeadm destroy nombrebectl destroy nombre
Destruir forzadobeadm destroy -F nombrebectl destroy -F nombre

12.2 Diferencias de comportamiento a recordar

  1. Recursividad: beadm era recursivo por defecto; bectl requiere -r.
  2. Confirmación al destruir: beadm pedía confirmación; bectl no.
  3. Activación temporal: bectl activate -t es una novedad muy útil que beadm no tenía.
  4. bectl jail: funcionalidad nueva y potente para reparar BEs.
  5. Integración en el sistema base: bectl no requiere instalación; beadm sí.

12.3 Migración práctica

Si tienes scripts con beadm, la migración a bectl requiere:

  • Añadir -r a los create que deban ser recursivos.
  • Añadir -F a los destroy que no deban pedir confirmación (o gestionar el prompt).
  • Revisar la salida de list (el formato es ligeramente distinto).
  • Aprovechar activate -t para pruebas.

Notas finales

  • Versión de FreeBSD: en 14.x y 15.x, bectl es plenamente funcional y recomendado. En 12.x y 13.x también funciona, pero conviene consultar man bectl por si algún flag difiere.
  • Documentación oficial: man bectl, man zfs, y el Handbook de FreeBSD (sección de ZFS y Boot Environments).
  • Combinación recomendada: snapshot ZFS + BE recursivo + script de rollback. Las tres capas se complementan y cubren escenarios distintos.
  • Higiene: revisa y limpia BEs antiguos periódicamente. Copy-on-write es eficiente, pero no infinito.

Fin del tutorial. Versión 1.0 — 2026-11-15.

FreeBSD es genial!

sábado, 14 de noviembre de 2026

Más allá del tema: Red de seguridad para tu FreeBSD con ZFS y bectl

Instalar un tema visual como WhiteSur (estilo macOS) en XFCE es una tarea de bajo riesgo. Al fin y al cabo, los scripts solo escriben en la carpeta de usuario (~/.themes). Si algo sale mal, basta con borrar la carpeta y elegir otro tema en Apariencia.

En el artículo anterior vimos cómo instalar el tema WhiteSur en FreeBSD con XFCE, esquivando los errores de compatibilidad de los scripts de Linux. Hoy, usaremos esa instalación como excusa para aprender a proteger nuestro sistema con ZFS, una de las joyas de FreeBSD.

Sin embargo, esta instalación es la excusa perfecta para aprender y practicar dos herramientas vitales en FreeBSD con ZFS: los snapshots (fotografías del sistema) y los Boot Environments (entornos de arranque). Dominar esto te salvará el día antes de un freebsd-update, un cambio de controladores o una actualización de paquetes.

Contexto: Este tutorial está probado en FreeBSD 14.5 con ZFS. Aprenderemos a crear una red de seguridad de tres niveles: desde lo más rápido (snapshot del home) hasta lo más robusto (arrancar un sistema anterior completo).

Nivel 1: Snapshots ZFS (El "deshacer" instantáneo)

Un snapshot en ZFS es una copia de solo lectura del estado de un dataset en un momento exacto. Son instantáneos, no duplican la información y son tu primera línea de defensa.

1. Crear el snapshot (antes de instalar el tema)

Como el tema se instala en tu directorio personal, basta con hacer un snapshot solo del home. Es rápido y quirúrgico:

sudo zfs snapshot -r zroot/usr/home@antes-whitesur

Si prefieres proteger absolutamente todo el sistema, puedes hacer un snapshot recursivo del pool (aunque para un tema no es necesario):

sudo zfs snapshot -r zroot@antes-whitesur

2. La trampa del rollback recursivo

Aquí hay un matiz que confunde a mucha gente: zfs snapshot -r sí es recursivo (baja a todos los hijos), pero zfs rollback -r no lo es. En el rollback, la opción -r solo destruye snapshots intermedios del mismo dataset, no se aplica a los hijos.

Por lo tanto, si hiciste el snapshot solo del home, revertir es tan sencillo como:

sudo zfs rollback -r zroot/usr/home@antes-whitesur

Reinicia XFCE (o el equipo) y tu carpeta personal volverá al estado exacto anterior a la instalación del tema.

Ojo: Si hiciste un snapshot recursivo de zroot y quieres revertir todo, tendrás que hacerlo dataset por dataset (raíz, home, etc.). En el anexo final te dejo un script que automatiza esta tarea.

Nivel 2: Boot Environments (El "arranque seguro")

Los Snapshots son geniales, pero si el problema afecta al sistema base (por ejemplo, un fallo de arranque), necesitas algo más potente. Aquí entran los Boot Environments (BE): clones completos y arrancables de tu sistema raíz.

En FreeBSD 14.5 no necesitas instalar nada: bectl ya viene incluido en el sistema base. (Aunque existe beadm en los repositorios de paquetes, bectl es la opción nativa y más directa).

1. Crear un entorno de arranque

Antes de aplicar cambios arriesgados (o instalar tu tema), crea un BE:

sudo bectl create antes-whitesur

Puedes verificar que se ha creado y cuál está activo:

bectl list

2. Simulacro de desastre y recuperación

  1. Instalas el tema y, por lo que sea, el entorno gráfico se rompe o el sistema no arranca.
  2. Reinicias el equipo.
  3. En el menú de arranque de FreeBSD (el cargador), seleccionas el entorno antes-whitesur. ¡Listo! El sistema arranca exactamente como estaba antes.
  4. Si quieres que este sea el entorno por defecto de ahora en adelante, ejecuta:
    sudo bectl activate antes-whitesur

El BE con el tema roto seguirá ahí por si quieres arrancarlo para investigar, hasta que decidas eliminarlo con sudo bectl destroy.


El flujo de trabajo recomendado (Paso a paso)

Si quieres tener ambas redes de seguridad antes de personalizar tu sistema:

  1. Snapshot rápido: sudo zfs snapshot -r zroot/usr/home@antes-whitesur
  2. Red de seguridad total: sudo bectl create antes-whitesur
  3. Instala y configura tu tema WhiteSur.
  4. Si solo falla la apariencia: Haz un rollback del home (zfs rollback) y reinicia XFCE.
  5. Si el sistema entero se vuelve inestable: Reinicia y elige el BE antes-whitesur en el menú de arranque.

Anexo: Script para rollback recursivo de ZFS

Si alguna vez necesitas revertir un snapshot recursivo de todo el pool ZFS (por ejemplo, antes de una actualización mayor del sistema), hacerlo dataset por dataset a mano es un tedio. Aquí tienes un pequeño script en sh que lista los datasets, comprueba si tienen el snapshot y los revierte uno por uno, con modo de simulación (--dry-run) para ver qué hará antes de tocar nada.

#!/bin/sh
# Guarda esto como rollback-zfs.sh y dale permisos: chmod +x rollback-zfs.sh
# Uso: sudo ./rollback-zfs.sh zroot antes-whitesur [--dry-run]

set -u
POOL="${1:-}"
SNAP_NAME="${2:-}"
DRY_RUN="no"

for arg in "$@"; do
    [ "$arg" = "--dry-run" ] && DRY_RUN="si"
done

if [ -z "$POOL" ] || [ -z "$SNAP_NAME" ]; then
    echo "Uso: $0 <pool> <nombre_snapshot> [--dry-run]"
    exit 1
fi

DATASETS=$(zfs list -H -r -o name "$POOL" 2>/dev/null)
if [ -z "$DATASETS" ]; then
    echo "Error: No se encontraron datasets en '$POOL'."
    exit 1
fi

if [ "$DRY_RUN" = "si" ]; then
    echo "=== MODO SIMULACIÓN (dry-run) ==="
else
    echo "=== MODO REAL ==="
fi
echo "Pool: $POOL | Snapshot: @$SNAP_NAME"
echo ""

# Fase 1: Mostrar plan
PLAN_OK=0
for ds in $DATASETS; do
    SNAP_FULL="${ds}@${SNAP_NAME}"
    if zfs list -H -t snapshot -o name "$SNAP_FULL" >/dev/null 2>&1; then
        echo "[PLAN] zfs rollback -r $SNAP_FULL"
        PLAN_OK=$((PLAN_OK + 1))
    else
        echo "[SALTADO] ${ds} (no tiene el snapshot)"
    fi
done

if [ "$DRY_RUN" = "si" ]; then
    echo ""
    echo "=== Simulación finalizada. ==="
    exit 0
fi

# Fase 2: Confirmación y ejecución
printf "\n¿Ejecutar rollback real? [s/N]: "
read RESPUESTA
case "$RESPUESTA" in
    s|S|si|SI) ;;
    *) echo "Cancelado."; exit 0 ;;
esac

echo ""
for ds in $DATASETS; do
    SNAP_FULL="${ds}@${SNAP_NAME}"
    if zfs list -H -t snapshot -o name "$SNAP_FULL" >/dev/null 2>&1; then
        echo -n "Revirtiendo ${ds} ... "
        if zfs rollback -r "$SNAP_FULL" 2>/dev/null; then
            echo "OK"
        else
            echo "FALLO (posible clonación o uso activo)"
        fi
    fi
done
echo "=== Proceso finalizado. Reinicia el equipo. ==="
Consejo final: Si haces rollback de la raíz del sistema (zroot/ROOT/default), asegúrate de hacerlo desde el modo single-user (opción 2 del cargador de FreeBSD) para evitar conflictos con procesos activos.

FreeBSD es genial!.

martes, 10 de noviembre de 2026

Replicación Incremental ZFS en FreeBSD: Script Cliente-Servidor Automatizado

"Este artículo detalla cómo crear un sistema de copias de seguridad ZFS profesional entre dos servidores FreeBSD (cliente y servidor), resolviendo los errores más comunes de desincronización de GUIDs y bloqueos de datasets, y automatizando el proceso con cron."

ZFS Replicación Incremental Cliente-Servidor

Entorno: FreeBSD 14.5
Topología: Cliente solaris (192.168.88.51) → Servidor tormenta (192.168.88.160)
Dataset: zroot/home/carlos → zbackup/solaris/home/carlos
Método: Transferencia por red (SSH) con ZFS nativo.

1. Filosofía de Diseño

Este script (zfsrep.sh) está diseñado para ser extremadamente resiliente. No asume que la red funcione siempre, ni que el cliente esté encendido todos los días. Sus principios son:

  • Uso de -I en lugar de -i: Envía todos los snapshots intermedios. Si el equipo ha estado apagado 5 días, ZFS rellena el hueco automáticamente en lugar de fallar.
  • Cero uso de -F: El flag destructivo de ZFS está prohibido. Si el destino se desincroniza (por ejemplo, por un cambio de GUID), el script fallará, pero nunca borrará datos del destino silenciosamente.
  • Auto-saneamiento: Utiliza zfs receive -A antes de empezar para abortar cualquier recepción que se haya quedado colgada (evitando el temido error "dataset is busy").
  • SSH Keepalive: Utiliza opciones de SSH para evitar que la conexión se quede congelada en redes lentas.

2. El Script Completo (v1.2.1)

Ubicación

/home/carlos/bin/zfsrep.sh

Contenido completo

#!/bin/sh
### BEGIN INFO
# NOMBRE:  Replicación Incremental ZFS cliente - servidor
# DESC:    Replica zroot/home/carlos (solaris) -> zbackup/solaris/home/carlos
# VERSION: 1.2.1
### END INFO

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

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

snap_prefix=snap
retention=30

# Patrón estricto: solo acepta snap-YYYYMMDD (8 dígitos).
# Evita que nombres manuales (snap-14.4-RELEASE) rompan el orden.
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
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 $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.
# El uso de sh -c evita que csh/tcsh en el remoto malinterprete el 2>.
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
    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 ---
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
        if $zfs send -I "$snap_base" "$snap_today" \
           | ssh $SSH_OPTS $host "zfs receive -vu -x mountpoint '$dst_0'" >> $log 2>&1
        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. Realizando envío completo..." >> $log
        clean_dst
        if $zfs send "$snap_today" \
           | ssh $SSH_OPTS $host "zfs receive -vu -x mountpoint '$dst_0'" >> $log 2>&1
        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

3. Solución de Problemas (Lecciones Aprendidas)

3.1. El error "most recent snapshot does not match incremental source"

Síntoma: El script falla al intentar el incremental y en la terminal aparece que la snapshot más reciente del destino no coincide con la fuente incremental.

Causa: Aunque las snapshots tengan el mismo nombre en origen y destino (ej. snap-20261020), sus identificadores únicos (GUIDs) son distintos. Esto ocurre tras restauraciones o movimientos de discos que rompen el "ADN" de ZFS.

Solución: El origen es el maestro, el destino es el esclavo. Nunca se destruyen snapshots del origen para igualar. Hay que destruir el dataset en el destino y forzar un envío completo:

# En el servidor destino (tormenta)
zfs destroy -r zbackup/solaris/home/carlos

El script detectará que no hay base y hará un envío completo automático (Full Send).

3.2. El error "dataset is busy" al destruir

Síntoma: Al intentar borrar el dataset en destino, ZFS responde con cannot destroy ... dataset is busy, incluso sin procesos visibles.

Causa: Un intento de zfs receive fallido o interrumpido deja un candado a nivel de kernel.

Solución paso a paso:

# 1. Abortar recepciones colgadas
zfs receive -A zbackup/solaris/home/carlos

# 2. Forzar desmontaje
zfs unmount -f zbackup/solaris/home/carlos

# 3. Si sigue bloqueado, reiniciar el servidor (limpia los candados del kernel)
shutdown -r now

3.3. El problema del shell `csh` en SSH

En FreeBSD, el shell por defecto de root suele ser csh o tcsh. Al enviar comandos por SSH con redirecciones como 2>, csh lo interpreta como un argumento y el comando falla silenciosamente.

Solución: Envolver el comando remoto en sh -c '...', tal y como hace la función clean_dst del script.

4. Automatización (Cron)

Para que el backup se ejecute todos los días a las 3:00 AM sin intervención, añadir al crontab del usuario:

0 3 * * * /home/carlos/bin/zfsrep.sh > /dev/null 2>&1
Nota: El script ya escribe su propio log detallado en /home/carlos/cronlog.
Resultado validado: El script ha sido probado con éxito transfiriendo 75 GB a 68 MB/s tras una resincronización completa, y ha demostrado ser capaz de reanudar cadenas rotas con -I.
FreeBSD es genial!.

sábado, 3 de octubre de 2026

Backup Manual y Recuperación

FreeBSD 14.5

ZFS FreeBSD Copia de seguridad del servidor tormenta
ZFS FreeBSD Copia de seguridad del cliente solaris

Sistema: solaris y tormenta (FreeBSD 14.5)
Método: Backup manual a disco USB (Modelo B — USB guardado fuera)
Fecha: 2026-10-03 (Actualizado tras prueba de recuperación real el 2026-10-21)

1. Introducción y filosofía

Este documento describe el sistema de backup manual a disco USB implementado en solaris y tormenta. Está diseñado para:

  • Ejecutarse manualmente cuando se conecta el disco USB.
  • Mantener los USB guardados fuera de las máquinas para protección ante ransomware y desastres locales.
  • Ser recuperable tanto para archivos individuales como para el sistema completo.
Filosofía del Modelo B: los USB no están conectados permanentemente. Se conectan solo cuando se va a hacer el backup, y después se guardan en otro lugar. Esto protege contra:
  • Ransomware que cifraría también el USB conectado.
  • Robo o incendio que afectaría a máquina y backup a la vez.
  • Errores humanos que borrarían el backup por accidente.

Estado del sistema

Elementosolaristormenta
Pool origenzrootzroot
Pool destino (USB)zbackupzbk
Dataset destinozbackup/recovery/solariszbk/tormenta
Etiqueta USBZFSBACKUPbackup1tb
Tamaño del pool origen~220 GB~312 GB
Script/root/bin/zfs-backup.sh/root/bin/zfs-backup.sh
Log/var/log/zfs-backup.log/var/log/zfs-backup.log
Retención origen7 snapshots7 snapshots
Retención destino30 snapshots30 snapshots

2. El script zfs-backup.sh

Script único que funciona en ambas máquinas, detectando automáticamente el hostname. Versión 2.4.

Ubicación

/root/bin/zfs-backup.sh

Contenido completo

#!/bin/sh
# zfs-backup.sh - Backup incremental de zroot a pool USB
# Versión: 2.4 (snapshot por dataset + export en error)
# Uso: sh /root/bin/zfs-backup.sh

set -e

# ========== CONFIGURACIÓN SEGÚN MÁQUINA ==========
HOSTNAME=$(hostname -s)
case "$HOSTNAME" in
    solaris)
        SRC_POOL="zroot"
        DST_POOL="zbackup"
        DST_DATASET="zbackup/recovery/solaris"
        USB_DEV="/dev/gpt/ZFSBACKUP"
        RETENTION_SRC=7
        RETENTION_DST=30
        ;;
    tormenta)
        SRC_POOL="zroot"
        DST_POOL="zbk"
        DST_DATASET="zbk/tormenta"
        USB_DEV="/dev/gpt/backup1tb"
        RETENTION_SRC=7
        RETENTION_DST=30
        ;;
    *)
        echo "Hostname no reconocido: $HOSTNAME" >&2
        exit 1
        ;;
esac

SNAP_PREFIX="snap"
SNAP_TODAY="${SNAP_PREFIX}-$(date +%Y%m%d)"
LOG="/var/log/zfs-backup.log"
LOCKFILE="/var/run/zfs-backup.lock"

# ========== VARIABLES DE ESTADO ==========
IMPORTED_BY_US=0

# ========== FUNCIONES ==========
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" >> "$LOG"
}

die() {
    log "ERROR: $*"
    if [ "${IMPORTED_BY_US:-0}" -eq 1 ]; then
        log "Exportando pool $DST_POOL antes de salir..."
        zpool export "$DST_POOL" >> "$LOG" 2>&1 || log "Aviso: no se pudo exportar"
    fi
    rm -f "$LOCKFILE"
    exit 1
}

# ========== BLOQUEO ==========
if [ -f "$LOCKFILE" ]; then
    PID=$(cat "$LOCKFILE" 2>/dev/null)
    if kill -0 "$PID" 2>/dev/null; then
        echo "Ya hay una ejecución en curso (PID $PID)"
        exit 0
    fi
    rm -f "$LOCKFILE"
fi
echo $ > "$LOCKFILE"

log "=========================================="
log "Iniciando backup en $HOSTNAME"
log "=========================================="

# ========== VERIFICAR POOL USB ==========
if ! zpool list "$DST_POOL" >/dev/null 2>&1; then
    log "Pool $DST_POOL no está importado. Intentando importar..."
    if [ ! -e "$USB_DEV" ]; then
        die "Disco USB $USB_DEV no encontrado. ¿Está conectado?"
    fi
    if ! zpool import "$DST_POOL" 2>>"$LOG"; then
        die "No se pudo importar el pool $DST_POOL"
    fi
    log "Pool $DST_POOL importado correctamente"
    IMPORTED_BY_US=1
else
    log "Pool $DST_POOL ya estaba importado"
    IMPORTED_BY_US=0
fi

# ========== CREAR SNAPSHOT DE HOY (dataset por dataset) ==========
log "Creando snapshot $SNAP_TODAY en todos los datasets (los que falten)..."

CREATED=0
SKIPPED=0
FAILED=0
for ds in $(zfs list -H -o name -r "$SRC_POOL" 2>/dev/null); do
    if zfs list -t snapshot "$ds@$SNAP_TODAY" >/dev/null 2>&1; then
        SKIPPED=$((SKIPPED + 1))
    else
        if zfs snapshot "$ds@$SNAP_TODAY" >> "$LOG" 2>&1; then
            CREATED=$((CREATED + 1))
        else
            log "  → error al crear $ds@$SNAP_TODAY"
            FAILED=$((FAILED + 1))
        fi
    fi
done
log "Snapshots: creados=$CREATED, ya existían=$SKIPPED, fallos=$FAILED"

if [ "$FAILED" -gt 0 ]; then
    log "AVISO: hubo $FAILED fallos al crear snapshots (se continúa)"
fi

# ========== DETECTAR ÚLTIMA SNAPSHOT EN DESTINO ==========
LAST_DST_SNAP=$(zfs list -t snapshot -H -o name -r "$DST_DATASET" 2>/dev/null \
    | grep '@snap-[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9] \
    | sort -r \
    | head -1 \
    | sed 's/.*@//')

if [ -z "$LAST_DST_SNAP" ]; then
    log "No hay snapshots previas en destino. Envío COMPLETO."
    zfs send -Rwcv "$SRC_POOL@$SNAP_TODAY" \
        | zfs receive -Fsuv -x mountpoint "$DST_DATASET" >> "$LOG" 2>&1 \
        || die "Error en el envío completo"

elif [ "$LAST_DST_SNAP" = "$SNAP_TODAY" ]; then
    log "Última snapshot en destino: $LAST_DST_SNAP"
    log "La snapshot $SNAP_TODAY ya está replicada. Nada que enviar."

elif ! zfs list -t snapshot "$SRC_POOL@$LAST_DST_SNAP" >/dev/null 2>&1; then
    log "AVISO: $LAST_DST_SNAP no existe en origen. Envío COMPLETO."
    zfs send -Rwcv "$SRC_POOL@$SNAP_TODAY" \
        | zfs receive -Fsuv -x mountpoint "$DST_DATASET" >> "$LOG" 2>&1 \
        || die "Error en el envío completo"

else
    log "Enviando incremental desde $LAST_DST_SNAP hasta $SNAP_TODAY"
    zfs send -Rwcv -i "$SRC_POOL@$LAST_DST_SNAP" "$SRC_POOL@$SNAP_TODAY" \
        | zfs receive -Fsuv -x mountpoint "$DST_DATASET" >> "$LOG" 2>&1 \
        || die "Error en el envío incremental"
fi

log "Envío completado correctamente"

# ========== FUNCIÓN DE RETENCIÓN ==========
apply_retention() {
    local root="$1"
    local label="$2"
    local ret="$3"

    log "Aplicando retención de $ret snapshots en $label..."

    zfs list -t snapshot -H -o name -r "$root" 2>/dev/null \
        | grep '@snap-[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9] \
        | sort -t@ -k1,1 -k2,2r \
        | awk -F@ -v r="$ret" '
            {
                ds = $1
                if (ds != prev_ds) { count = 0; prev_ds = ds }
                count++
                if (count > r) print $0
            }' \
        | while read snap; do
            log "Borrando $snap"
            zfs destroy "$snap" >> "$LOG" 2>&1 || log "  → error al borrar"
        done

    log "Retención en $label aplicada"
}

# ========== RETENCIÓN EN DESTINO (30 snapshots) ==========
apply_retention "$DST_DATASET" "destino" "$RETENTION_DST"

# ========== RETENCIÓN EN ORIGEN (7 snapshots) ==========
apply_retention "$SRC_POOL" "origen" "$RETENTION_SRC"

# ========== EXPORTAR POOL ==========
if [ "$IMPORTED_BY_US" -eq 1 ]; then
    log "Exportando pool $DST_POOL"
    zpool export "$DST_POOL" >> "$LOG" 2>&1 || log "Aviso: no se pudo exportar"
    log "Ya puedes desconectar el USB de forma segura"
fi

log "Backup completado con éxito"
log "=========================================="
rm -f "$LOCKFILE"

Características clave

ElementoDescripción
Detección automáticaUsa el hostname para elegir el pool y dataset correctos
Snapshot dataset por datasetEvita el fallo atómico de zfs snapshot -r
Detección de sincronizaciónSi ya está todo replicado, no envía nada
Incremental automáticoDetecta la última snapshot en destino y envía solo diferencias
Fallback a full sendSi no hay base común, hace envío completo automáticamente
Retención independiente7 snapshots en origen, 30 en destino
Export automáticoSi el script importó el USB, lo exporta al terminar
Logging completoTodo se registra en /var/log/zfs-backup.log
LockfileEvita ejecuciones simultáneas

3. Ejecución manual paso a paso

Cuándo ejecutar: semanalmente (recomendado domingo por la tarde), o siempre que haya cambios importantes que se quieran respaldar.

Paso 1 — Conectar el USB

Conectar el disco USB (ZFSBACKUP en solaris, backup1tb en tormenta) a la máquina correspondiente. Esperar unos segundos a que el sistema lo detecte.

ls -la /dev/gpt/ZFSBACKUP    # En solaris
ls -la /dev/gpt/backup1tb    # En tormenta

Debe aparecer el device node. Si no aparece, probar con otro puerto USB o revisar dmesg:

dmesg | tail -20

Paso 2 — Ejecutar el script

sh /root/bin/zfs-backup.sh
Importante: NO ejecutar el script si no se está seguro de que el USB está conectado. Si no lo está, el script fallará limpiamente sin tocar nada.

Paso 3 — Verificar el resultado

tail -30 /var/log/zfs-backup.log

Debe verse al final:

[XX:XX:XX] Backup completado con éxito
[XX:XX:XX] ==========================================

Paso 4 — Desconectar el USB

Si el script importó el pool, lo habrá exportado automáticamente. Se verá en el log:

[XX:XX:XX] Ya se puede desconectar el USB de forma segura

Verificar que el pool está exportado:

zpool list

El pool de backup (zbackup o zbk) no debe aparecer en la lista. Si aparece, exportarlo manualmente antes de desconectar:

zpool export zbackup    # En solaris
zpool export zbk        # En tormenta

sync

Paso 5 — Guardar el USB en lugar seguro

Una vez exportado y sincronizado, se puede retirar el cable USB y guardarlo donde corresponda (fuera de casa, caja fuerte, casa de un familiar, etc.).

¡Backup completado! El proceso completo tarda típicamente entre 1 y 15 minutos dependiendo de cuántos datos hayan cambiado desde el último backup.

4. Interpretación del log

Ejemplo de ejecución exitosa (con cambios)

[2026-10-03 18:30:00] ==========================================
[2026-10-03 18:30:00] Iniciando backup en solaris
[2026-10-03 18:30:00] ==========================================
[2026-10-03 18:30:00] Pool zbackup no está importado. Intentando importar...
[2026-10-03 18:30:02] Pool zbackup importado correctamente
[2026-10-03 18:30:02] Creando snapshot snap-20261003 en todos los datasets (los que falten)...
[2026-10-03 18:30:02] Snapshots: creados=18, ya existían=0, fallos=0
[2026-10-03 18:30:03] Última snapshot en destino: snap-20261002
[2026-10-03 18:30:03] Enviando incremental desde snap-20261002 hasta snap-20261003
[2026-10-03 18:32:15] Envío completado correctamente
[2026-10-03 18:32:15] Aplicando retención de 30 snapshots en destino...
[2026-10-03 18:32:15] Retención en destino aplicada
[2026-10-03 18:32:15] Aplicando retención de 7 snapshots en origen...
[2026-10-03 18:32:15] Retención en origen aplicada
[2026-10-03 18:32:15] Exportando pool zbackup
[2026-10-03 18:32:16] Ya puedes desconectar el USB de forma segura
[2026-10-03 18:32:16] Backup completado con éxito
[2026-10-03 18:32:16] ==========================================

Ejemplo de ejecución sin cambios

[2026-10-03 18:30:00] ==========================================
[2026-10-03 18:30:00] Iniciando backup en solaris
[2026-10-03 18:30:00] ==========================================
[2026-10-03 18:30:00] Pool zbackup ya estaba importado
[2026-10-03 18:30:00] Creando snapshot snap-20261003 en todos los datasets (los que falten)...
[2026-10-03 18:30:00] Snapshots: creados=18, ya existían=0, fallos=0
[2026-10-03 18:30:00] Última snapshot en destino: snap-20261003
[2026-10-03 18:30:00] La snapshot snap-20261003 ya está replicada. Nada que enviar.
[2026-10-03 18:30:00] Envío completado correctamente
[2026-10-03 18:30:00] Aplicando retención de 30 snapshots en destino...
[2026-10-03 18:30:00] Retención en destino aplicada
[2026-10-03 18:30:00] Aplicando retención de 7 snapshots en origen...
[2026-10-03 18:30:00] Retención en origen aplicada
[2026-10-03 18:30:00] Backup completado con éxito
[2026-10-03 18:30:00] ==========================================

Ejemplo de error (USB no conectado)

[2026-10-03 18:30:00] ==========================================
[2026-10-03 18:30:00] Iniciando backup en solaris
[2026-10-03 18:30:00] ==========================================
[2026-10-03 18:30:00] Pool zbackup no está importado. Intentando importar...
[2026-10-03 18:30:00] ERROR: Disco USB /dev/gpt/ZFSBACKUP no encontrado. ¿Está conectado?
Este error es normal si se ejecuta el script sin el USB conectado. No corrompe nada. Simplemente conectar el USB y volver a ejecutar.

5. Política de retención

El script aplica automáticamente dos políticas distintas:

UbicaciónSnapshots conservadosRazón
Origen (zroot)7Liberar espacio en el NVMe. Solo se necesitan los últimos días para incrementales.
Destino (USB)30Histórico más largo. El USB tiene más espacio y es el "archivo".

Ajustar la retención

Si se quieren cambiar los valores, editar el script:

ee /root/bin/zfs-backup.sh

Buscar las líneas:

RETENTION_SRC=7
RETENTION_DST=30

Y modifícalas a los valores de preferencia. Por ejemplo, para guardar más histórico en el USB:

RETENTION_SRC=7
RETENTION_DST=60
Espacio: cada snapshot diaria ocupa entre 50 MB y varios GB según lo que cambie. Con 30 snapshots en destino, asegurarse de que el USB tiene espacio suficiente (consultar con zpool list).

6. Recuperación de archivos individuales

Escenario: se ha borrado un archivo por error o se quiere recuperar una versión anterior de algo.

Paso 1 — Conectar el USB y localizar el snapshot

# Conectar el USB de backup
zpool import zbackup        # En solaris
zpool import zbk            # En tormenta

# Ver snapshots disponibles
zfs list -t snapshot -r zbackup/recovery/solaris | grep 'snap-2026'

Paso 2 — Montar el snapshot en un punto temporal

mkdir -p /mnt/snap
mount -t zfs zbackup/recovery/solaris/home/carlos@snap-20261002 /mnt/snap

Ahora /mnt/snap contiene el contenido de /home/carlos tal como estaba en esa fecha.

Paso 3 — Buscar y copiar el archivo

# Ver qué hay
ls -la /mnt/snap/

# Copiar el archivo deseado
cp /mnt/snap/documento.txt /home/carlos/documento_recuperado.txt

Paso 4 — Desmontar y exportar

umount /mnt/snap
rmdir /mnt/snap

zpool export zbackup        # En solaris
zpool export zbk            # En tormenta

sync
Ventaja sobre el método .gz: con el backup ZFS solo montas el snapshot y accedes a los archivos directamente. No hay que descomprimir 300 GB para sacar un documento.

7. Recuperación completa del sistema (Probado en real)

Escenario: el NVMe del sistema ha fallado o necesitas reinstalar FreeBSD desde cero. Este procedimiento está validado en una prueba real de Disaster Recovery y tiene en cuenta los problemas típicos de un entorno Live (read-only, altroot, etc.).

ATENCIÓN: Este procedimiento borra todo el contenido del disco actual. Asegurarse de tener el backup antes de empezar.

Paso 1 — Arrancar desde USB de FreeBSD

Insertar el USB de instalación, arrancar la máquina desde él, y elegir "Shell" en lugar de instalar.

Paso 2 — Identificar discos

geom disk list
gpart show

Identifica el disco destino (ej. nda0 o da1) y el USB de backup (da0).

Paso 3 — Preparar el disco destino

gpart destroy -F nda0
gpart create -s gpt nda0
gpart add -t efi -a 1m -s 260m -l efi0 nda0
gpart add -t freebsd-boot -a 1m -s 512k -l boot0 nda0
gpart add -t freebsd-swap -a 1m -s 16g -l swap0 nda0
gpart add -t freebsd-zfs -a 1m -l zfs0 nda0
newfs_msdos -F 32 -c 1 /dev/nda0p1

Paso 4 — Crear el pool zroot

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

Paso 5 — Importar el USB de backup

zpool import zbackup

Verifica el snapshot más reciente que vas a restaurar:

zfs list -t snapshot zbackup/recovery/solaris | tail -5

Paso 6 — Restaurar el sistema

Importante: Usamos el flag -w (raw) porque tenemos datasets cifrados. NO usamos el flag -d para que la estructura caiga directamente en zroot/ROOT/default y no se anide en zroot/Solaris/ROOT/default.
# Sustituye snap-XXXX por el nombre exacto del snapshot
zfs send -Rwcv zbackup/recovery/solaris@snap-XXXX | zfs receive -Fuv zroot

Paso 7 — Configurar el Boot Environment

zpool set bootfs=zroot/ROOT/default zroot
zpool get bootfs zroot

Paso 8 — Copiar el cargador UEFI (Solución a "Read-only file system")

El entorno Live no permite crear carpetas en /mnt porque la raíz es de solo lectura. Además, la partición EFI puede estar "sucia" y montarse en Read-only. Usaremos /tmp (que está en RAM) y forzaremos el montaje:

# 1. Crear puntos de montaje temporales en RAM
mkdir -p /tmp/myroot /tmp/myefi

# 2. Montar el sistema restaurado para acceder al loader.efi
mount -t zfs zroot/ROOT/default /tmp/myroot

# 3. Reparar la partición EFI por si tiene flags de "sucio"
fsck_msdosfs -f /dev/nda0p1

# 4. Montar la EFI explícitamente en modo escritura
mount -t msdosfs -o rw /dev/nda0p1 /tmp/myefi

# 5. Crear la estructura y copiar el cargador
mkdir -p /tmp/myefi/efi/boot
cp /tmp/myroot/boot/loader.efi /tmp/myefi/efi/boot/bootx64.efi

# 6. Sincronizar y desmontar
sync
umount /tmp/myefi
umount /tmp/myroot

Paso 9 — Ajustar propiedades de montaje (El truco del -u)

No intentes usar zpool set altroot= zroot, ya que dará error "can only be set during pool creation". Tampoco puedes desmontar la raíz. Debemos usar zfs set -u para actualizar las propiedades de montaje sin intentar montar en caliente:

zfs set -u mountpoint=/ zroot/ROOT/default
zfs set -u mountpoint=/home zroot/home
zfs set -u mountpoint=/usr zroot/usr
zfs set -u mountpoint=/var zroot/var
zfs set -u mountpoint=/tmp zroot/tmp
zfs set -u mountpoint=none zroot
zfs set -u mountpoint=none zroot/ROOT

Paso 10 — Regenerar base de datos de usuarios

Para evitar el bucle de login (donde el sistema autentica pero rebota al usuario porque el home no estaba montado), regeneramos las contraseñas:

pwd_mkdb -p /etc/master.passwd

Paso 11 — Exportar y reiniciar

zpool export zbackup
zpool export zroot
reboot

Al reiniciar, el sistema leerá las propiedades corregidas en el Paso 9, montará todo en su sitio y podrás iniciar sesión con normalidad.

8. Recuperación del dataset cifrado

El dataset zroot/nfsv4/secifrado en tormenta está cifrado con ZFS native encryption.

Guardar la clave en al menos 3 sitios distintos:
  • Gestor de contraseñas (Bitwarden, KeePass, etc.).
  • Papel en caja fuerte.
  • USB de emergencia separado del USB de backup.

Ver el contenido de la clave

base64 /etc/zfs/secifrado.key

Restaurar la clave

echo 'TU_CLAVE_EN_BASE64' | base64 -d > /etc/zfs/secifrado.key
chmod 400 /etc/zfs/secifrado.key
chown root:wheel /etc/zfs/secifrado.key
ls -la /etc/zfs/secifrado.key

Montar el dataset cifrado

zfs mount zroot/nfsv4/secifrado
ls -la /nfsv4/secifrado/
Recomendación: una vez al año, haz una prueba real de recuperación del dataset cifrado en una máquina de prueba.

9. Checklist y rutinas

Rutina semanal (domingo)

  • [ ] Conectar USB ZFSBACKUP a solaris
  • [ ] Ejecutar sh /root/bin/zfs-backup.sh
  • [ ] Verificar log: tail -20 /var/log/zfs-backup.log
  • [ ] Confirmar "Backup completado con éxito"
  • [ ] Desconectar USB y guardarlo en lugar seguro
  • [ ] Repetir con USB backup1tb en tormenta

Rutina mensual

  • [ ] Verificar snapshots recientes en los USB
  • [ ] Comprobar espacio disponible: zpool list
  • [ ] Revisar el log en busca de errores: grep "ERROR" /var/log/zfs-backup.log

Rutina semestral

  • [ ] Prueba de restauración de un archivo aleatorio.
  • [ ] Verificar integridad del pool USB: zpool scrub zbackup
  • [ ] Comprobar que las claves de cifrado siguen accesibles.

Apéndice A — Comandos útiles

Ver estado de los pools

zpool list
zpool status
zpool status -v

Ver snapshots

# Todos los snapshots del pool
zfs list -t snapshot -r zroot

# Solo los snapshots diarios (formato snap-YYYYMMDD)
zfs list -t snapshot -r zroot | grep 'snap-2026'

# Contar snapshots por dataset
zfs list -t snapshot -r zroot | awk -F@ '{print $1}' | sort | uniq -c

Comprobar integridad

zpool scrub zroot
zpool scrub zbackup
zpool status

Ver procesos de backup en curso

ps aux | grep -E "zfs (send|receive)" | grep -v grep
tmux ls

Reconectar a una sesión tmux

tmux attach -t backup_usb

Apéndice B — Solución de problemas

Error: "Pool zbackup no está importado"

ls -la /dev/gpt/ZFSBACKUP
zpool import zbackup
sh /root/bin/zfs-backup.sh

Error: "cannot create snapshot ... dataset already exists"

Causa: alguno de los datasets ya tiene la snapshot de hoy. La versión 2.4 del script ya maneja esto dataset por dataset.

Error: "cannot send ... encrypted dataset"

Causa: falta el flag -w en zfs send.

Solución: usar -Rwcv en lugar de -Rcv.

El USB no se puede exportar (pool is busy)

lsof | grep zbackup
fuser -m /zbackup

zfs unmount -a
zpool export -f zbackup

Backup incompleto o corrupto

zpool scrub zbackup
zpool status zbackup

Apéndice C — Glosario

TérminoSignificado
PoolConjunto de discos gestionados por ZFS como una unidad
DatasetSistema de archivos dentro de un pool
SnapshotImagen inmutable de un dataset en un momento concreto
Full sendEnvío completo de un dataset a otro pool
Incremental sendEnvío solo de los cambios desde una snapshot base
RetenciónNúmero de snapshots que se conservan antes de borrar las más antiguas
ashiftTamaño de sector usado por ZFS (12 = 4096 bytes)
-w (raw)Envío de bloques cifrados sin descifrar
BEBoot Environment — entorno de arranque de FreeBSD
tmuxMultiplexor de terminal (permite sesiones persistentes)

Apéndice D — Lecciones aprendidas (Disaster Recovery)

Esta sección documenta los problemas reales que surgieron al realizar una prueba de recuperación en un disco de 250 GB desde el Live CD de FreeBSD. Es vital conocerlos para futuras recuperaciones:

  • El entorno Live es read-only: No se puede usar mkdir /mnt/efi. Usar siempre /tmp/ para los puntos de montaje temporales.
  • El comando zpool set altroot= falla: Esta propiedad solo se puede tocar al importar. Para corregir los puntos de montaje en caliente, usar el flag -u en zfs set -u mountpoint=/....
  • Bucle de login: Si el sistema arranca pero te rebota al login (o el comando su da error "cannot open"), es porque el directorio /home/ no se montó bien. Se soluciona regenerando las contraseñas con pwd_mkdb -p /etc/master.passwd.
  • El snapshot Base es sagrado: El snapshot snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026 es el cimiento de todos los incrementales. Si se borra, ZFS forzará un envío completo (Full Send) de 200 GB en el próximo backup.

 

FreeBSD es genial!.

Realizar copia de seguridad del cliente solaris en disco USB

ZFS FreeBSD Copia de seguridad del servidor tormenta
Backup Manual y Recuperación

FreeBSD14.5

1. Identificar discos

geom disk list
camcontrol devlist
gpart show

En solaris, el disco USB suele aparecer como da0 o da1. Verificar con geom disk list cuál es el correcto (etiqueta ZFSBACKUP).

2. Comprobaciones previas (antes de destruir nada)

¿Tiene particiones?

gpart show da0

¿Tiene restos de ZFS?

zpool import | grep -B2 -A5 da0

¿Está montado en algún sitio?

mount | grep da0

3. Plan resumido

ComandoQué hace
gpart destroy -F da0Borra particiones
zpool labelclear -f /dev/da0Borra restos ZFS
gpart create -s gpt da0Tabla GPT nueva
gpart add -t freebsd-zfs -l ZFSBACKUP da0Partición ZFS
zpool create -o ashift=12 ... zbackup /dev/gpt/ZFSBACKUPPool zbackup
zfs create -o mountpoint=none zbackup/recovery/solarisDataset destino
zfs snapshot -r zroot@snap-$(date +%Y%m%d)Snapshot del sistema
zfs send -Rwcv ... | zfs receive -Fsuv ...Envío local (en tmux)
zpool export zbackupCerrar limpiamente

4. Preparar el disco

gpart destroy -F da0
# → da0 destroyed

Borrar cualquier resto de ZFS (aunque no haya, por asegurar)

zpool labelclear -f /dev/da0 2>/dev/null

Crear tabla GPT nueva

gpart create -s gpt da0
# → da0 created

Crear partición ZFS ocupando todo el disco

gpart add -t freebsd-zfs -l ZFSBACKUP da0
# → da0p1 added

Verificar

gpart show da0
# →       40  3907029088  da0  GPT  (2T)
# →       40  3907029088    1  freebsd-zfs  (2T)

5. Crear el pool zbackup

Los discos modernos suelen tener sectores de 4K, pero muchos discos USB reportan 512B. Es crítico crear el pool con ashift=12 (4096 bytes) para evitar problemas de rendimiento.

Ver ashift que ZFS detectaría por defecto

diskinfo -v da0 | grep -i "sector size"

Si dice 512, hay que forzar ashift=12 al crear el pool.

zpool create -o ashift=12 \
             -O compression=lz4 \
             -O atime=off \
             -O xattr=sa \
             -O relatime=on \
             -O mountpoint=none \
             zbackup /dev/gpt/ZFSBACKUP

Banderas

  • ashift=12 → sectores 4K (crítico para rendimiento en discos modernos).
  • compression=lz4 → compresión ligera y rápida.
  • atime=off → no actualizar tiempo de acceso (más rápido).
  • xattr=sa → atributos extendidos en el inodo.
  • relatime=on → atime solo cuando sea útil.
  • mountpoint=none → no montar automáticamente.

Verificar

zpool status zbackup
zpool list zbackup
zfs list

Crear dataset destino

zfs create -o mountpoint=none zbackup/recovery
zfs create -o mountpoint=none zbackup/recovery/solaris
zfs list -r zbackup

Salida esperada:

zbackup                     XXXG   XXXG    96K  none
zbackup/recovery            XXXG   XXXG    96K  none
zbackup/recovery/solaris    XXXG   XXXG    96K  none

Pool zbackup creado correctamente:

DatoValor
Poolzbackup
Tamaño~2 TB
Dataset destinozbackup/recovery/solaris (listo)
zroot a respaldar~220 G

6. Crear snapshot del sistema

zfs snapshot -r zroot@snap-$(date +%Y%m%d)

Verificar

zfs list -t snapshot -r zroot | grep snap-$(date +%Y%m%d) | wc -l

El resultado depende del número de datasets del sistema. En solaris actual: ~30.

Nota para el futuro: si un script creó el snapshot en un solo dataset sin usar -r, o si otro proceso lo creó antes para otro propósito, puede haber conflictos. Cuando se monte el cron para backups automáticos, usar date +%Y%m%d-%H%M%S para evitar colisiones si se ejecuta dos veces el mismo día.
zfs snapshot -r zroot@snap-$(date +%Y%m%d-%H%M%S)

7. Lanzar el envío en tmux

Entrar en tmux

tmux new -s backup_usb

Comando de envío (dentro de tmux)

zfs send -Rwcv zroot@snap-$(date +%Y%m%d) \
  | zfs receive -Fsuv -x mountpoint zbackup/recovery/solaris

Banderas explicadas

FlagSignificado
-RRecursivo: envía zroot y todos sus hijos
-wRaw: envía los bloques cifrados tal cual (necesario si hay datasets cifrados)
-cCompresión nativa ZFS (lz4)
-vVerbose: muestra progreso por dataset
-FFuerza rollback en destino si hay divergencias
-sGuarda token de resume en /var/tmp/ (permite reanudar si se corta)
-uNo monta los datasets recibidos
-x mountpointNo replica los mountpoints del origen
Importante sobre -w: aunque solaris no tiene datasets cifrados actualmente, el -w es inofensivo si no hay cifrado. Mantener el mismo script/comando que en tormenta para consistencia y por si en el futuro se añade cifrado.

8. Salir de tmux sin matar el proceso

Ctrl+b  d

9. Monitorizar (en otra terminal)

Ver datasets llegando en tiempo real

watch -n 10 'zfs list -r zbackup/recovery/solaris | head -30'

Ver velocidad de escritura al USB

zpool iostat zbackup 5

Ver espacio consumido

watch -n 30 'zfs list zbackup'

10. Verificar tras el envío

Volver a la sesión tmux

tmux attach -t backup_usb

Si ya terminó, se verá el real Xm Ys del comando. Entonces:

Contar snapshots origen vs destino

zfs list -t snapshot -r zroot | wc -l
zfs list -t snapshot -r zbackup/recovery/solaris | wc -l

Deben coincidir.

Verificar datasets replicados

zfs list -r zbackup/recovery/solaris | head -30

Espacio usado

zfs list zbackup
zpool list zbackup

11. Si algo falla durante el envío

¿Sigue algún proceso zfs vivo?

ps aux | grep -E "zfs (send|receive)" | grep -v grep

Si aparece algo, sigue corriendo. Esperar y dejarlo terminar.

¿En qué estado está el destino?

zfs list zbackup
zfs list -r zbackup/recovery/solaris | head -20

Se verá si quedó un dataset a medias (zbackup/recovery/solaris con datos parciales).

¿Hay un token de resume guardado?

ls -la /var/tmp/ | grep -i zfs
ls -la / | grep -i zfs
El token de resume solo existe si se usó -s en el zfs receive. Si no se usó, no hay reanudación posible: hay que empezar de cero.

¿El proceso murió? Limpiar el destino parcial

zfs destroy -r zbackup/recovery/solaris
zfs create -o mountpoint=none zbackup/recovery/solaris
zfs list -r zbackup/recovery

Relanzar con -s para permitir resume

tmux new -s backup_usb

Dentro de tmux:

zfs send -Rwcv zroot@snap-20261002 \
  | zfs receive -Fsuv -x mountpoint zbackup/recovery/solaris
El flag -s en zfs receive guarda un token de reanudación en /var/tmp/. Si se vuelve a cortar, se podrá reanudar con:
zfs send -t $(ls /var/tmp/zfs_*.resume 2>/dev/null | head -1)

Salir de tmux con Ctrl+b d antes de cerrar SSH. No cerrar la sesión SSH hasta que tmux esté desconectado.

12. Exportar el pool y desconectar el USB

Verificar que no hay nada escribiendo

zpool status zbackup
lsof | grep zbackup 2>/dev/null

Exportar limpiamente

zpool export zbackup

Y por último

sync

Ya se puede retirar el cable USB.

13. Tiempo estimado

Velocidad USB~220 GB
80 MB/s~45 min
120 MB/s~30 min
200 MB/s~18 min
400 MB/s~9 min

Con el chip ASMT USB 3.0 + disco SATA: ~15-30 min si es SSD, ~40-60 min si es HDD.

Recordatorio: para poder cerrar la sesión SSH sin que se corte el envío, primero entrar en tmux con tmux new -s backup_usb, lanzar el envío, y salir con Ctrl+b d.
Recomendación adicional: poner una etiqueta al disco físico con rotulador o adhesivo:
  • Backup Solaris
  • snap-20261002
  • zbackup pool

14. Restaurar archivos de configuración

No requiere reiniciar. Solo copia los archivos desde el snapshot.

Paso 1: Montar el snapshot

mkdir -p /mnt/snap
mount -t zfs zroot/ROOT/default@snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026 /mnt/snap

Paso 2: Comparar qué cambió

diff /etc/pf.conf       /mnt/snap/etc/pf.conf
diff /etc/rc.conf       /mnt/snap/etc/rc.conf
diff /etc/sysctl.conf   /mnt/snap/etc/sysctl.conf
diff /boot/loader.conf  /mnt/snap/boot/loader.conf

Paso 3: Backup de los actuales

cp /etc/pf.conf       /etc/pf.conf.broken-$(date +%Y%m%d)
cp /etc/rc.conf       /etc/rc.conf.broken-$(date +%Y%m%d)
cp /etc/sysctl.conf   /etc/sysctl.conf.broken-$(date +%Y%m%d)
cp /boot/loader.conf  /boot/loader.conf.broken-$(date +%Y%m%d)

Paso 4: Restaurar desde el snapshot

cp /mnt/snap/etc/pf.conf       /etc/pf.conf
cp /mnt/snap/etc/rc.conf       /etc/rc.conf
cp /mnt/snap/etc/sysctl.conf   /etc/sysctl.conf
cp /mnt/snap/boot/loader.conf  /boot/loader.conf

Paso 5: Desmontar y probar

umount /mnt/snap
rmdir /mnt/snap

# Recargar pf (sin reiniciar)
pfctl -f /etc/pf.conf

# Ver rutas
netstat -rn

# Probar red
ping -c 3 192.168.88.1
ping -c 3 8.8.8.8
ping -c 3 google.com

Paso 6: Si funciona, reiniciar para aplicar loader.conf y sysctl.conf

shutdown -r now

15. Rollback completo

Requiere arrancar en modo monousuario. No se puede hacer con el dataset montado.

Paso 1: Crear snapshot de seguridad del estado actual

Antes de tocar nada, para poder volver si algo falla:

zfs snapshot -r zroot@before-rollback-$(date +%Y%m%d-%H%M)

Paso 2: Reiniciar en modo monousuario

shutdown -r now

En el menú de arranque de FreeBSD, pulsar 2 (Boot Single User).

Paso 3: Preparar el sistema

zfs set readonly=off zroot
zfs mount -a

Paso 4: Rollback

Esto destruye los snapshots posteriores a este (incluido el de before-rollback).
zfs rollback -R zroot/ROOT/default@snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026

Paso 5: Salir del modo monousuario y reiniciar

exit

O directamente:

reboot

Qué se pierde con el rollback

ElementoEstado
pf.confVuelve al estado del snapshot
loader.confVuelve al estado del snapshot
sysctl.confVuelve al estado del snapshot
/etc/rc.confEstado del snapshot
Archivos en /home/carlosNO se pierden (dataset separado)
Archivos en /varNO se pierden (dataset separado, si no se hace rollback ahí)
Solo afecta a zroot/ROOT/default (el sistema base). Los datos personales en zroot/home/carlos no se tocan.

16. Uso del script automatizado

Solaris tiene instalado el script /root/bin/zfs-backup.sh que automatiza todo el proceso.

Ejecución manual (modelo B: USB guardado fuera)

# 1. Conectar el USB ZFSBACKUP a solaris
# 2. Ejecutar:
sh /root/bin/zfs-backup.sh

# 3. Ver el resultado
tail -20 /var/log/zfs-backup.log

# 4. Cuando termine, el script exporta el pool automáticamente
# 5. Desconectar el USB y guardarlo en lugar seguro

Qué hace el script automáticamente

  • Detecta que está en solaris y usa zbackup/zbackup/recovery/solaris/ZFSBACKUP.
  • Importa el pool zbackup si no está importado.
  • Crea el snapshot zroot@snap-YYYYMMDD (dataset por dataset, sin fallos atómicos).
  • Detecta la última snapshot en destino y envía solo el incremental.
  • Aplica retención: 7 snapshots en origen, 30 en destino.
  • Exporta el pool al terminar (para poder desconectar el USB).
  • Registra todo en /var/log/zfs-backup.log.

Frecuencia recomendada

Semanal (domingo por la tarde). Total: 5-15 minutos por backup.

17. Errores comunes a evitar

  • Usar zfs send -Rcv sin -w → falla si hay datasets cifrados.
  • Olvidar -s en zfs receive → no hay reanudación posible si se corta.
  • Cerrar la sesión SSH sin tmux → el envío muere al desconectar.
  • No guardar la clave de cifrado fuera del backup → backup inútil si se pierde.
  • Usar zfs destroy sin -n primero → riesgo de borrar snapshots con dependencias.
  • Ejecutar el script de retención sin verificar → puede borrar snapshots indiscriminadamente.
  • Importar el mismo pool en dos máquinas simultáneamente → corrompe metadatos.
  • Desconectar el USB sin zpool export → riesgo de corrupción.

18. Checklist final

  • [ ] Disco USB identificado y preparado
  • [ ] Pool zbackup creado con ashift=12
  • [ ] Dataset zbackup/recovery/solaris creado
  • [ ] Snapshot del sistema creado (zfs snapshot -r)
  • [ ] Envío lanzado dentro de tmux
  • [ ] Proceso monitorizado hasta el final
  • [ ] Verificado: snapshots origen vs destino coinciden
  • [ ] Pool exportado limpiamente (zpool export zbackup)
  • [ ] USB desconectado y guardado en lugar seguro
  • [ ] Clave de cifrado guardada en al menos 2 sitios distintos (si aplica)

19. Dónde guardar el USB

UbicaciónProtección
❌ Junto a la máquinaNinguna (robo/incendio afecta a ambos)
⚠️ Otra habitación de la casaProtección baja
✅ Otra planta / garaje / trasteroProtección media
✅✅ Casa de un familiar / amigoProtección alta
✅✅✅ Caja de seguridad del bancoProtección máxima

Recomendación: caja fuerte pequeña en casa + copia secundaria en casa de un familiar.

20. Verificaciones periódicas (cada 3-6 meses)

# 1. Conectar el USB ZFSBACKUP a solaris
# 2. Importar el pool
zpool import zbackup

# 3. Verificar el pool
zpool status zbackup

# 4. Contar snapshots en destino
zfs list -t snapshot -r zbackup/recovery/solaris | grep 'snap-2026' | wc -l

# 5. Ver las más recientes
zfs list -t snapshot -r zbackup/recovery/solaris | grep 'snap-2026' | sort | tail -5

# 6. Exportar
zpool export zbackup

Si todo está en orden, los datos son recuperables.

FreeBSD es genial!.

viernes, 2 de octubre de 2026

Realizar copia de seguridad del servidor tormenta en disco USB

ZFS FreeBSD Copia de seguridad del cliente solaris
Backup Manual y Recuperación

FreeBSD 14.5

1. Identificar discos

geom disk list
camcontrol devlist
gpart show

2. Comprobaciones previas (antes de destruir nada)

¿Tiene particiones?

gpart show da1

¿Tiene restos de ZFS?

zpool import | grep -B2 -A5 da1

¿Está montado en algún sitio?

mount | grep da1

3. Plan resumido

ComandoQué hace
gpart destroy -F da1Borra particiones
zpool labelclear -f /dev/da1Borra restos ZFS
gpart create -s gpt da1Tabla GPT nueva
gpart add -t freebsd-zfs -l backup1tb da1Partición ZFS
zpool create -o ashift=12 ... zbk /dev/gpt/backup1tbPool zbk
zfs create -o mountpoint=none zbk/tormentaDataset destino
zfs snapshot -r zroot@snap-$(date +%Y%m%d)Snapshot del sistema
zfs send -Rwcv ... | zfs receive -Fsuv ...Envío local (en tmux)
zpool export zbkCerrar limpiamente

4. Preparar el disco

gpart destroy -F da1
# → da1 destroyed

Borrar cualquier resto de ZFS (aunque no haya, por asegurar)

zpool labelclear -f /dev/da1 2>/dev/null

Crear tabla GPT nueva

gpart create -s gpt da1
# → da1 created

Crear partición ZFS ocupando todo el disco

gpart add -t freebsd-zfs -l backup1tb da1
# → da1p1 added

Verificar

gpart show da1
# →       40  1953525088  da1  GPT  (932G)
# →       40  1953525088    1  freebsd-zfs  (932G)

5. Crear el pool zbk

Los discos modernos suelen tener sectores de 4K, pero muchos discos USB reportan 512B. Es crítico crear el pool con ashift=12 (4096 bytes) para evitar problemas de rendimiento.

Ver ashift que ZFS detectaría por defecto

diskinfo -v da1 | grep -i "sector size"

Si dice 512, hay que forzar ashift=12 al crear el pool.

zpool create -o ashift=12 \
             -O compression=lz4 \
             -O atime=off \
             -O xattr=sa \
             -O relatime=on \
             -O mountpoint=none \
             zbk /dev/gpt/backup1tb

Banderas

  • ashift=12 → sectores 4K (crítico para rendimiento en discos modernos).
  • compression=lz4 → compresión ligera y rápida.
  • atime=off → no actualizar tiempo de acceso (más rápido).
  • xattr=sa → atributos extendidos en el inodo.
  • relatime=on → atime solo cuando sea útil.
  • mountpoint=none → no montar automáticamente.

Verificar

zpool status zbk
zpool list zbk
zfs list

Crear dataset destino

zfs create -o mountpoint=none zbk/tormenta
zfs list -r zbk

Salida esperada:

zbk           XXXG   XXXG    96K  none
zbk/tormenta   96K   XXXG    96K  none

Pool zbk creado correctamente:

DatoValor
Poolzbk
Tamaño928 G
Disponible899 G
Dataset destinozbk/tormenta (listo)
zroot a respaldar312 G

6. Crear snapshot del sistema

zfs snapshot -r zroot@snap-$(date +%Y%m%d)

Verificar

zfs list -t snapshot -r zroot | grep snap-$(date +%Y%m%d) | wc -l

El resultado depende del número de datasets del sistema. En tormenta actual: ~48.

Nota para el futuro: si un script creó el snapshot en un solo dataset sin usar -r, o si otro proceso lo creó antes para otro propósito, puede haber conflictos. Cuando se monte el cron para backups automáticos, usar date +%Y%m%d-%H%M%S para evitar colisiones si se ejecuta dos veces el mismo día.
zfs snapshot -r zroot@snap-$(date +%Y%m%d-%H%M%S)

7. Lanzar el envío en tmux

Entrar en tmux

tmux new -s backup_usb

Comando de envío (dentro de tmux)

zfs send -Rwcv zroot@snap-$(date +%Y%m%d) \
  | zfs receive -Fsuv -x mountpoint zbk/tormenta

Banderas explicadas

FlagSignificado
-RRecursivo: envía zroot y todos sus hijos
-wRaw: envía los bloques cifrados tal cual (necesario si hay datasets cifrados como zroot/nfsv4/secifrado)
-cCompresión nativa ZFS (lz4)
-vVerbose: muestra progreso por dataset
-FFuerza rollback en destino si hay divergencias
-sGuarda token de resume en /var/tmp/ (permite reanudar si se corta)
-uNo monta los datasets recibidos
-x mountpointNo replica los mountpoints del origen
Importante sobre -w: el dataset zroot/nfsv4/secifrado está cifrado con ZFS native encryption. Con zfs send -Rcv (sin -w) el envío falla. Siempre usar -Rwcv.

8. Cifrado: consideraciones

El flag -w envía el dataset cifrado tal cual (raw). Ventaja: funciona, conserva el cifrado, es rápido. Inconveniente: en destino el dataset también estará cifrado y necesitarás la clave para montarlo.

¿Qué se necesita para recuperarlo?

La passphrase o keyfile utilizada para cifrar zroot/nfsv4/secifrado. Sin ella, el backup es inútil.

GUARDAR LA PASSPHRASE/KEYFILE
Si se pierde la clave, se pierden los datos y el backup. Guardarla en:
  • Un gestor de contraseñas (Bitwarden, KeePass, etc.)
  • Un archivo en un USB que no sea el mismo del backup
  • Papel impreso en un lugar seguro

Comprobar qué método de cifrado se utilizó

zfs get encryption,keyformat,keylocation zroot/nfsv4/secifrado

# NAME                       PROPERTY     VALUE                        SOURCE
# zroot/nfsv4/secifrado      encryption   aes-256-gcm                  -
# zroot/nfsv4/secifrado      keyformat    raw                          -
# zroot/nfsv4/secifrado      keylocation  file:///etc/zfs/secifrado.key

Si dice keyformat=passphrase, se necesita esa passphrase.
Si dice keyformat=raw con keylocation=file:///..., es necesario ese archivo.

Ver el contenido (para copiarlo en un gestor de contraseñas)

Convertir a base64 para poder copiarlo como texto:

base64 /etc/zfs/secifrado.key

9. Salir de tmux sin matar el proceso

Ctrl+b  d

10. Monitorizar (en otra terminal)

Ver datasets llegando en tiempo real

watch -n 10 'zfs list -r zbk/tormenta | head -30'

Ver velocidad de escritura al USB

zpool iostat zbk 5

Ver espacio consumido

watch -n 30 'zfs list zbk'

11. Verificar tras el envío

Volver a la sesión tmux

tmux attach -t backup_usb

Si ya terminó, se verá el real Xm Ys del comando. Entonces:

Contar snapshots origen vs destino

zfs list -t snapshot -r zroot | wc -l
zfs list -t snapshot -r zbk/tormenta | wc -l

Deben coincidir (probablemente ~300+).

Verificar datasets replicados

zfs list -r zbk/tormenta | head -30

Espacio usado

zfs list zbk
zpool list zbk

12. Si algo falla durante el envío

¿Sigue algún proceso zfs vivo?

ps aux | grep -E "zfs (send|receive)" | grep -v grep

Si aparece algo, sigue corriendo. Esperar y dejarlo terminar.

¿En qué estado está el destino?

zfs list zbk
zfs list -r zbk/tormenta | head -20

Se verá si quedó un dataset a medias (zbk/tormenta con datos parciales).

¿Hay un token de resume guardado?

ls -la /var/tmp/ | grep -i zfs
ls -la / | grep -i zfs
El token de resume solo existe si se usó -s en el zfs receive. Si no se usó, no hay reanudación posible: hay que empezar de cero.

¿El proceso murió? Limpiar el destino parcial

zfs destroy -r zbk/tormenta
zfs create -o mountpoint=none zbk/tormenta
zfs list -r zbk

Relanzar con -s para permitir resume

tmux new -s backup_usb

Dentro de tmux:

zfs send -Rwcv zroot@snap-20260930 \
  | zfs receive -Fsuv -x mountpoint zbk/tormenta
El flag -s en zfs receive guarda un token de reanudación en /var/tmp/. Si se vuelve a cortar, se podrá reanudar con:
zfs send -t $(ls /var/tmp/zfs_*.resume 2>/dev/null | head -1)

Salir de tmux con Ctrl+b d antes de cerrar SSH. No cerrar la sesión SSH hasta que tmux esté desconectado.

13. Exportar el pool y desconectar el USB

Verificar que no hay nada escribiendo

zpool status zbk
lsof | grep zbk 2>/dev/null

Exportar limpiamente

zpool export zbk

Y por último

sync

Ya se puede retirar el cable USB.

14. Tiempo estimado

Velocidad USB312 GB
80 MB/s~1.1 h
120 MB/s~43 min
200 MB/s~26 min
400 MB/s~13 min

Con el chip ASMT USB 3.0 + disco SATA: ~20–45 min si es SSD, ~50–80 min si es HDD.

Recordatorio: para poder cerrar la sesión SSH sin que se corte el envío, primero entrar en tmux con tmux new -s backup_usb, lanzar el envío, y salir con Ctrl+b d.
Recomendación adicional: poner una etiqueta al disco físico con rotulador o adhesivo:
  • Backup Tormenta
  • snap-20260930
  • zbk pool

15. Restaurar archivos de configuración

No requiere reiniciar. Solo copia los archivos desde el snapshot.

Paso 1: Montar el snapshot

mkdir -p /mnt/snap
mount -t zfs zroot/ROOT/default@snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026 /mnt/snap

Paso 2: Comparar qué cambió

diff /etc/pf.conf       /mnt/snap/etc/pf.conf
diff /etc/rc.conf       /mnt/snap/etc/rc.conf
diff /etc/sysctl.conf   /mnt/snap/etc/sysctl.conf
diff /boot/loader.conf  /mnt/snap/boot/loader.conf

Paso 3: Backup de los actuales

cp /etc/pf.conf       /etc/pf.conf.broken-$(date +%Y%m%d)
cp /etc/rc.conf       /etc/rc.conf.broken-$(date +%Y%m%d)
cp /etc/sysctl.conf   /etc/sysctl.conf.broken-$(date +%Y%m%d)
cp /boot/loader.conf  /boot/loader.conf.broken-$(date +%Y%m%d)

Paso 4: Restaurar desde el snapshot

cp /mnt/snap/etc/pf.conf       /etc/pf.conf
cp /mnt/snap/etc/rc.conf       /etc/rc.conf
cp /mnt/snap/etc/sysctl.conf   /etc/sysctl.conf
cp /mnt/snap/boot/loader.conf  /boot/loader.conf

Paso 5: Desmontar y probar

umount /mnt/snap
rmdir /mnt/snap

# Recargar pf (sin reiniciar)
pfctl -f /etc/pf.conf

# Ver rutas
netstat -rn

# Probar red
ping -c 3 192.168.88.1
ping -c 3 8.8.8.8
ping -c 3 google.com

Paso 6: Si funciona, reiniciar para aplicar loader.conf y sysctl.conf

shutdown -r now

16. Rollback completo

Requiere arrancar en modo monousuario. No se puede hacer con el dataset montado.

Paso 1: Crear snapshot de seguridad del estado actual

Antes de tocar nada, para poder volver si algo falla:

zfs snapshot -r zroot@before-rollback-$(date +%Y%m%d-%H%M)

Paso 2: Reiniciar en modo monousuario

shutdown -r now

En el menú de arranque de FreeBSD, pulsar 2 (Boot Single User).

Paso 3: Preparar el sistema

zfs set readonly=off zroot
zfs mount -a

Paso 4: Rollback

Esto destruye los snapshots posteriores a este (incluido el de before-rollback).
zfs rollback -R zroot/ROOT/default@snap-14.4-RELEASE-p8-casa.lan-2026-28-sept-2026

Paso 5: Salir del modo monousuario y reiniciar

exit

O directamente:

reboot

Qué se pierde con el rollback

ElementoEstado
pf.confext_if="wlan0" (vuelve atrás)
loader.confSin hw.em.eee_setting=1
sysctl.confSin dev.em.0.eee_control=0
/etc/rc.confEstado del snapshot
Archivos en /home/carlosNO se pierden (dataset separado)
Archivos en /varNO se pierden (dataset separado, si no se hace rollback ahí)
Solo afecta a zroot/ROOT/default (el sistema base). Los datos personales en zroot/home/carlos no se tocan.

17. Errores comunes a evitar

  • Usar zfs send -Rcv sin -w → falla si hay datasets cifrados.
  • Olvidar -s en zfs receive → no hay reanudación posible si se corta.
  • Cerrar la sesión SSH sin tmux → el envío muere al desconectar.
  • No guardar la clave de cifrado fuera del backup → backup inútil si se pierde.
  • Usar zfs destroy sin -n primero → riesgo de borrar snapshots con dependencias.
  • Ejecutar el script de retención sin verificar → puede borrar snapshots indiscriminadamente.

18. Checklist final

  • [ ] Disco USB identificado y preparado
  • [ ] Pool zbk creado con ashift=12
  • [ ] Dataset zbk/tormenta creado
  • [ ] Snapshot del sistema creado (zfs snapshot -r)
  • [ ] Envío lanzado dentro de tmux
  • [ ] Proceso monitorizado hasta el final
  • [ ] Verificado: snapshots origen vs destino coinciden
  • [ ] Pool exportado limpiamente (zpool export zbk)
  • [ ] USB desconectado y guardado en lugar seguro
  • [ ] Clave de cifrado guardada en al menos 2 sitios distintos
FreeBSD es genial!.