Firewall Mikrotik Protege LAN y Permite Acceso a Internet

Configuración de firewall para MikroTik (RouterOS)

Protege la red LAN (10.10.10.0/24) y permite acceso a Internet. Las reglas incluyen protección anti-spoofing, bloqueo de tráfico no autorizado, y permiten tráfico legítimo.

El router Mikrotik esta conectado al puerto ehter1 (WAN_ether1) y uno de los puertos ethernet del router ISP usando DHCP Client

Configuración básica de interfaces

/interface bridge
add name=LAN_bridge
/interface bridge port
add bridge=LAN_bridge interface=ether2
add bridge=LAN_bridge interface=ether3
add bridge=LAN_bridge interface=ether4
add bridge=LAN_bridge interface=ether5
add bridge=LAN_bridge interface=wlan1
add bridge=LAN_bridge interface=wlan2
/ip address
add address=10.10.10.1/24 interface=LAN_bridge

DHCP Client en WAN (WAN_ether1)

/ip dhcp-client
add interface=WAN_ether1

NAT para acceso a Internet

/ip firewall nat
add chain=srcnat out-interface=WAN_ether1 action=masquerade

POLÍTICAS POR DEFECTO (FILTER)

/ip firewall filter

CONEXIONES ESTABLECIDAS

add chain=input action=accept connection-state=established,related \
comment="Permitir conexiones Establecidas/Realacionadas (Input)"
add chain=forward action=accept connection-state=established,related \
comment="Permitir conexiones Establecidas/Relacionadas (Forward)"
add chain=output action=accept connection-state=established,related \
comment="Permitir conexiones Establecidas/Relacionadas (Output)"

ANTI-SPOOFING Y SEGURIDAD BÁSICA Bloqueo de IPs falsas en WAN

add chain=input action=drop in-interface=WAN_ether1 src-address=10.10.10.0/24 \
comment="Bloquear LAN IP Spoofing (Input)"
add chain=forward action=drop in-interface=WAN_ether1 src-address=10.10.10.0/24 \
comment="Bloquear LAN IP Spoofing (Forward)"

Protección contra escaneos y ataques comunes

add chain=input action=drop in-interface=WAN_ether1 protocol=tcp psd=21,3s,3,1 \
comment="Bloquear TCP SYN Scans"
add chain=input action=drop in-interface=WAN_ether1 protocol=udp

REGLAS INPUT (TRÁFICO AL ROUTER) Permitir administración solo desde LAN

add chain=input action=accept in-interface=LAN_bridge protocol=tcp dst-port=22,8291,443 \
comment="Acceso Administracion (LAN)"

Permitir ICMP (ping)

add chain=input action=accept protocol=icmp comment="Allow ICMP"

Permitir DHCP desde ISP

add chain=input action=accept in-interface=WAN_ether1 protocol=udp src-port=67-68 dst-port=67-68 \
comment="DHCP Cliente"

Bloquear todo lo demás en WAN

add chain=input action=drop in-interface=WAN_ether1 \
comment="Bloquear Todo WAN Input"

REGLAS FORWARD (TRÁFICO A TRAVÉS DEL ROUTER)

Permitir LAN -> Internet

add chain=forward action=accept in-interface=LAN_bridge out-interface=WAN_ether1 \
connection-state=new comment="LAN a Internet"

Bloquear Internet -> LAN (excepto respuestas)

add chain=forward action=drop in-interface=WAN_ether1 out-interface=LAN_bridge \
connection-state=new comment="Bloquear Internet a LAN"

Permitir tráfico entre interfaces LAN (opcional)

add chain=forward action=accept in-interface=LAN_bridge out-interface=LAN_bridge \
comment="Inter-LAN Tráfico"

REGLAS OUTPUT (TRÁFICO DESDE EL ROUTER)

add chain=output action=accept comment="Permitir Router Output" disabled=no

REGLAS ADICIONALES DE SEGURIDAD Bloqueo de redes reservadas/rfc1918 desde WAN

add chain=input action=drop in-interface=WAN_ether1 src-address-list=private_ranges \
comment="Bloquear IPs Privada (Input)"
add chain=forward action=drop in-interface=WAN_ether1 src-address-list=private_ranges \
comment="Bloquear IPs Privada (Forward)"

Lista de redes reservadas

/ip firewall address-list
add address=172.16.0.0/12 list=private_ranges
add address=10.0.0.0/8 list=private_ranges
add address=192.168.0.0/16 list=private_ranges
add address=169.254.0.0/16 list=private_ranges

LOGGING (OPCIONAL)

add chain=input action=log log-prefix="[BLOQUEO DE CORTAFUEGOS] " \
comment="Log Bloqueado Input"
add chain=forward action=log log-prefix="[BLOQUEO DE CORTAFUEGOS] " 
comment="Log Bloqueado Forward"

Configurar servicios:

/ip service
set ssh address=10.10.10.0/24,192.168.88.0/24
set winbox address=10.10.10.0/24,192.168.88.0/24
set ftp disable=yes
set telnet disable=yes
set api disable=yes
set api-ssl disable=yes
set www disable=yes
set www-ssl disable=yes

Protección bridge:

/interfaces bridge settings
set use-ip-firewall=yes

Protección extra:

/ip firewall filter
add chain=forward protocol=tcp tcp-flags=syn,!ack action=drop comment="Bloquear SYN-flood"
add chain=forward protocol=udp limit=10/1m action=drop comment="Limite UDP floods"

Explicación:

1. Conexiones Establecidas: - Acepta tráfico de respuestas en todas las cadenas (input, forward, output).

2. Protección Anti-Spoofing: - Bloquea tráfico WAN con IPs de la LAN (10.10.10.0/24). - Bloquea redes reservadas (RFC 1918) desde WAN.

3. Reglas INPUT: - Solo permite administración (SSH, Winbox, WebFig) desde la LAN. - Permite ICMP (ping) y DHCP del ISP. - Bloquea todo el tráfico entrante no autorizado en WAN.

4. Reglas FORWARD: - Permite nuevas conexiones desde LAN hacia Internet. - Bloquea nuevas conexiones desde Internet hacia LAN. - Permite comunicación entre dispositivos LAN (opcional).

5. Reglas OUTPUT: - Permite todo el tráfico generado por el router (se puede ajustar si es necesario).

6. Protección Adicional: - Bloqueo de escaneos TCP/UDP desde Internet. - Logging de tráfico bloqueado para diagnóstico.

Notas: - Políticas por Defecto: - Input: drop (implícito por reglas). - Forward: drop (regla final bloquea tráfico no autorizado). - Output: accept.

- NAT: La regla masquerade en srcnat permite a la LAN acceder a Internet usando la IP WAN (asignada por DHCP).

- Personalización: - Para permitir acceso desde Internet (ej: servidor web), agregar reglas `forward` específicas. - Ajustar puertos de administración en reglas `input` según necesidades.

Esta configuración equilibra seguridad y funcionalidad, protegiendo la LAN de amenazas externas mientras permite acceso a Internet.

FreeBSD es genial!.

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

Fuente:

https://www.iceflatline.com/2015/07/using-zfs-replication-features-in-freebsd-to-improve-my-offsite-backups/

El autor de este sencillo e ingenioso guión es iceflatline. Contiene algunas modificaciones para adaptarlo a este laboratorio

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

Crear el pool de respaldo zbackup

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

Conjuntos de datos zbackup

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

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

Seguridad contra modificaciones accidentales

Evita conflictos de rutas

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

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

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

carlos@tormenta:~ % zfs list -r zbackup
zbackup                            48.9G  1.71T  4.86M  none
zbackup/solaris                    40.8G  1.71T    96K  none
zbackup/solaris/home               40.8G  1.71T    96K  none
zbackup/solaris/home/carlos        40.8G  1.71T  39.9G  none
zbackup/tormenta-confiles           800K  1.71T   800K  none
zbackup/usr                        8.16G  1.71T   104K  none
zbackup/usr/backup                 7.80G  1.71T   104K  none
zbackup/usr/backup/docs            7.80G  1.71T  7.80G  none
zbackup/usr/home                    368M  1.71T   132M  none

#!/bin/sh
### BEGIN INFO
# PROVIDE:
# REQUIRE:
# KEYWORD:

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

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

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

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

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

log=/home/carlos/cronlog

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

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

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

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

echo >> $log

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

echo >> $log

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

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

echo >> $log

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

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

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

### FIN DEL SCRIPT

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

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

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

**********

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

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

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

Replicacion completada.

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

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

FreeBSD es genial!.

Configuración de Zerotier Acceso a Servidor LAN vía SSH FreeBSD 14.2

Configuración para conectar clientes a un servidor FreeBSD via Zerotier y SSH

Instalación y configuración de Zerotier en el servidor FreeBSD

Instalación y puesta en marcha de Zerotier

 pkg install net/zerotier
 sysrc zerotier_enable=YES
 service zerotier start

Unirse a la Red Zerotier (192.168.192.0-24):

 zerotier-cli join <Network ID>

Reemplaza <Network ID> con el ID de tu red Zerotier (puedes verlo en Zerotier central).

Autorizar el servidor en Zerotier, aparecerá en la lista de miembros con su ID

Asigna una IP fija al servidor en la red Zerotier (por ej: 192.168.192.133).

Configuración del cortafuegos PF en el servidor FreeBSD

Habilitar IP Forwarding (Reenvío de paquetes):

echo "net.inet.ip.forwarding=1" >> /etc/sysctl.conf

Aplicar los cambios:

sysctl net.inet.ip.forwarding=1
net.inet.ip.forwarding: 1

Reglas PF (/etc/pf.conf)

# Macros
wan_if = "re0"               # Interfaz conectada al MikroTik (LAN)
lan_net = "192.168.88.0/24"  # Red local
zt_if = "zt1ocu1pr8e2sac"    # Interfaz ZeroTier
zt_net = "192.168.192.0/24"  # Red ZeroTier

# Opciones generales
set block-policy drop
set skip on { lo0, $zt_if }  # ZeroTier no necesita filtrado estricto
scrub in all fragment reassemble

# Reglas predeterminadas
block all
pass out quick keep state

# Permitir tráfico entre redes LAN y ZeroTier
pass quick from $lan_net to $zt_net
pass quick from $zt_net to $lan_net

# Permitir servicios desde la LAN (Samba, NFSv4, SSH)
pass in on $wan_if proto { tcp, udp } from $lan_net to any port { 139, \
445, 111, 2049, 22 }

# Permitir SSH desde ZeroTier (clientes externos)
pass in on $zt_if proto tcp from $zt_net to ($wan_if) port 22

# Reglas para ZeroTier (puerto UDP 9993 y comunicación entre peers)
pass in on $zt_if proto udp from any to any port 9993

# Permitir ICMP (pings y mensajes de error)
pass in inet proto icmp all icmp-type { echoreq, unreach }

Configuración de clientes Zerotier:

Instalar Zerotier en los dispositivos cliente

Unirlos a la red Zerotier

zerotier-cli join <Network ID> o mediante la app

Autoriza los clientes en Zerotier y asígnales IPs fijas si es necesario

Acceso SSH al servidor

Conectarse desde un cliente usando la IP de Zerotier del servidor

 ssh usuario@192.168.192.133

Ruta estática entre la red local (192.168.88.0/24) y Zerotier (192.168.192.0/24)

¿Por qué es necesaria?

Los clientes en Zerotier (192.168.192.0/24) no saben como llegar a la red local del servidor (192.168.88.0/24) por defecto.

La ruta estática indica a Zerotier que el servidor actúa como puerta de enlace para la red local.

Configuración en Zerotier Central:

Ir a su red en Zerotier
En Advanced > Managed Routes,
añadir:

 - Destination: 192.168.88.0/24
 - Via: 192.168.192.133 (IP Zerotier del servidor)

Explicación Técnica

Zerotier como VPN Layer 2:

Crea una red virtual donde todos los dispositivos aparecen como si estuvieran en la misma LAN, evitando la necesidad de port forwarding

Ruta estática:

Dirige el tráfico desde Zerotier hacia la red local a través del servidor, que actúa como router.

Regla de Cortafuegos en Mikrotik

Agregar una regla que permita el tráfico SSH desde la red ZeroTier hacia el servidor FreeBSD

# En Mikrotik (RouterOS CLI)

/ip firewall filter add chaind=filter action=accept protocol=tcp \
dst-port=22 src-address=192.168.192.0/24 comment="Permitir SSH desde ZeroTier"

El servidor usa la IP de ZeroTier para SSH, asegúrese de que SSH está configurado para escuchar en esa IP

# En /etc/ssh/sshd_config
ListenAddress 192.168.192.133

Reiniciar SSH después

service sshd restart

Verificaión:

Desde un cliente Zerotier, por ej: desactivo la conexión wifi de mi teléfono móvil y activo los datos para conectarme desde una red externa:

 ssh carlos@192.168.192.133

Captura de tráfico

 tcpdump -i zt1ocu1pr8e2sac

Optimizar ZeroTier:

- En /usr/local/etc/zerotier-one/zerotier-one.conf, configura allowManaged y allowGlobal para controlar el acceso a rutas:

   {
     "settings": {
       "allowManaged": true,
       "allowGlobal": false
     }
   }

Diagrama de Flujo

Esta configuración garantiza que solo los servicios necesarios estén expuestos, y la comunicación entre redes se realice de manera segura y controlada.

FreeBSD es genial!.

Replicación de datos ZFS FreeBSD

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

Diagrama Dia

Replication ZFS en FreeBSD

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

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

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

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

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

Sumas de Verificación de un Extremo a Otro

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

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

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

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

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

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

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

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

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

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

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

Archivo /etc/hosts

cat /etc/hosts| grep tormenta
192.168.88.160   tormenta

Archivo ~/.ssh/config

$ cat .ssh/config
Host tormenta
	HostName 192.168.88.160
	User carlos
	Port 30000
	AddressFamily inet
	BindInterface em0
	CheckHostIP yes
...

$ ssh tormenta
Last login: Sat Dec 14 06:50:20 2024 from solaris
...

Compruebe que el ssh basado en clave funciona

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

 ssh-keygen

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

 ssh tormenta
 
 carlos@tormenta:~ %

Particionar el Disco Para las Copias de Seguridad

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

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

 gpart
 gpart show

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

 

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

 /sbin/dmesg | tail
 

Preparar el dispositivo de almacenamiento

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

Ya conoce el disco a particionar?

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

gpart destroy -F /dev/da1

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

zpool create backups /dev/da1p1

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

zfs set mountpoint=/export backups

Consultar propiedades

zfs get mountpoint,name backups
NAME     PROPERTY    VALUE       SOURCE
backups  mountpoint  /export     local
backups  name        backups     -

Crear Conjunto de Datos en pool backups

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

Listar recursivamente backups

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

Listar recursivamente pool zroot servidor tormenta

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

Exportar e Importar backups

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

zpool export backups

Grupos disponibles para importar

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

	backups     ONLINE
	  da0p1     ONLINE

zpool import backups	  

Listar Información Sobre los Grupos de Almacenamiento ZFS

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

Disponible para importar

zpool import
no pools available to import

Crear las instantáneas

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

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

Listar instantáneas creadas

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

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

Enviar la primera instantánea completa

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

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

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

Envío incremental

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

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

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

Tomar las instantáneas

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

Listar instantáneas creadas

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

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

Enviar el flujo de datos

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

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

Replicación remota a través de SSH

Origen FreeBSD solaris, destino backups servidor tormenta

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

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

Listar instantánea

solaris~ # zfs list -t snapshot zroot/home@snap-20241213
NAME                       USED  AVAIL  REFER  MOUNTPOINT
zroot/home@snap-20241213  25.4M      -  39.2G  -

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

Replicación remota incremental

Tomar la instantánea

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

Listar las intantáneas

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

Replicar el flujo de datos

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

Exportar e importar pool backups

 zfs export backups
 zfs import backups
 

Donde están las instantáneas?

Conectarse al servidor tormenta vía SSH

solaris~ $ ssh tormenta

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

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

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

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

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

Listar todas las instantáneas en backups

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

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

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

Restaurar instantánea de forma remota

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

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

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

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

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

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

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

Enviar el flujo de datos a un archivo

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

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

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

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

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

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

Creacion de los conjuntos de datos

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

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

Tomar las instantáneas

 zfs snapshot -r zroot/usuarios@hoy

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

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

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

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

Y luego se recuperan

 zfs receive -Fd zroot < /snaps/usuarios

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

FreeBSD es genial!.

Montar Directorios Usando SSHFS en FreeBSD 13.1

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

Envío y recepción de datos ZFS

El comando zfs send crea una representación de flujo de datos de una instantánea que se graba en una salida estándar. De forma predeterminada, se crea un flujo de datos completo. Puede redirigir la salida a un archivo u otro sistema.

El comando zfs receive crea una instantánea cuyo contenido se especifica en el flujo de datos que figura en la entrada estándar. Si se recibe un flujo de datos completo, también se crea un sistema de archivos. Con estos comandos puede enviar y recibir datos de instantáneas ZFS y sistemas de archivos.

El hostname solaris será el cliente y tormenta el servidor. Ambos corren FreeBSD 13.1.

solaris:~/bsdfetch-main % ./bsdfetch

OS: FreeBSD
Release: 13.1-RELEASE-p3
Version: FreeBSD 13.1-RELEASE-p3 GENERIC
Host: solaris
Arch: amd64
Shell: csh
User: carlos
Packages: 1245
Uptime: 0d 0h 47m
RAM: 16221 MB
Loadavg: 0.17 0.17 0.20
CPU: Intel(R) Core(TM) i5-8350U CPU @ 1.70GHz
Cores: 8 of 8 processors online
 -> Core [1]: 39.0 °C
 -> Core [2]: 39.0 °C
 -> Core [3]: 39.0 °C
 -> Core [4]: 39.0 °C
 -> Core [5]: 40.0 °C
 -> Core [6]: 40.0 °C
 -> Core [7]: 41.0 °C
 -> Core [8]: 41.0 °C

Archivo config ssh (cliente)

 cat .ssh/config
Host tormenta
        HostName 192.168.88.160
        User carlos
        IdentityFile ~/.ssh/id_rsa
        Port 22422
        AddressFamily inet
        BindInterface em0

        CASignatureAlgorithms ssh-ed25519,ecdsa-sha2-nistp256,ecdsa-sha2-nistp384,ecdsa-sha2-nistp521,sk-ssh-ed25519@openssh.com,sk-ecdsa-sha2-nistp256@openssh.com,rsa-sha2-512,rsa-sha2-256

        Ciphers  chacha20-poly1305@openssh.com,aes128-ctr,aes192-ctr,aes256-ctr,aes128-gcm@openssh.com,aes256-gcm@openssh.com

        CheckHostIP yes

Entrar vía ssh al servidor.

tormenta % ./bsdfetch

OS: FreeBSD
Release: 13.1-RELEASE-p3
Version: FreeBSD 13.1-RELEASE-p3 GENERIC
Host: tormenta
Arch: amd64
Shell: csh
User: carlos
Packages: 472
Uptime: 25d 23h 3m
RAM: 32084 MB
Loadavg: 0.40 0.28 0.20
CPU: Intel(R) Celeron(R) N5105 @ 2.00GHz
Cores: 4 of 4 processors online

tormenta:~ % uname -a

FreeBSD tormenta 13.1-RELEASE-p3 FreeBSD 13.1-RELEASE-p3 GENERIC amd64

solaris:~ % uname -a

FreeBSD solaris 13.1-RELEASE-p3 FreeBSD 13.1-RELEASE-p3 GENERIC amd64

Red cableada

#
::1                 localhost localhost.my.domain
127.0.0.1           localhost localhost.my.domain
192.168.88.247      synology  # nas synology
192.168.88.160      tormenta  # servidor freebsd
192.168.88.51       solaris   # cliente freebsd
192.168.88.200		raspberry # servidor dns
192.168.88.205		switch    # switch gestionado
192.168.88.43       macbook	  # cliente 
192.168.88.1		mikrotik  # router firewall
192.168.1.1			router2   # red 2 
...

Crear un conjunto de datos en solaris (cliente)

 zfs create -o mountpoint=/usr/tormentabck zroot/usr/tormentabck

Instalar sshfs (servidor)

 pkg search sshfs
fusefs-sshfs-3.7.3_1           Mount remote directories over ssh

 pkg install fusefs-sshfs

Permitir acceso a través de ssh. Habilitar ssh en solaris (cliente)

 sysrc ssh_enable=YES

Tener el mismo usuario en ambos sistemas

Crear conjunto de datos en el cliente

 solaris: # zfs create zroot/usr/tormentabck

Montar directorio en el servidor

[tormenta:~] carlos@pts/0 % sudo sshfs -o allow_other \
carlos@192.168.88.51:/usr/tormentabck /mnt/solaris

Realizar comprobación

[tormenta:~] carlos@pts/0 % mount
 --> /dev/fuse on /mnt/solaris (fusefs.sshfs)
 ...

Crear una instantánea recursiva en el servidor

 [tormenta:~] zfs snapshot -r zroot@tormenta_120123

Enviar el conjunto de datos al cliente (solaris)

 [tormenta:~] zfs send -Rv zroot@tormenta_120123 | gzip > \
 /mnt/solaris/zroot.tormenta.snap1.gz

Llegados a este punto tenemos una copia del sistema completo del servidor en el cliente.

 [tormenta:~] % ls -l /mnt/solaris
 total 64934092
 -rw-r--r--  1 carlos  carlos  66492508708 Jan 12 21:51 zroot.tormenta.snap1.gz

Desmontar el directorio

sudo umount /mnt/solaris/

En la maquina cliente (donde físicamente está el fichero)

ls -l /usr/tormentabck/
total 64954481
-rw-r--r--  1 carlos  carlos  66492508708 Jan 12 21:51 zroot.tormenta.snap1.gz

FreeBSD es genial!.

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

Configurar ssh

configurar un sshd único para esta sesión.

# mkdir /tmp/etc
# mount_unionfs /tmp/etc /etc
# edit /etc/ssh/sshd_config

editar /etc/ssh/sshd_config y cambiar la configuración de PermitRootLogin de no a sí y eliminar el comentario, puede utilizar Ctrl-Y para buscar "root".

Establecer una contrasena para el usuario root (no teclee root directamente, utilice passwd root)

# passwd root

Importar el zpool

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

Incluir la direccion IP en el archivo /etc/exports del servidor nfs tormenta

Agregar en el archivo /etc/rc.conf la línea

nfs_client_enable

# service nfsclient start
NFS access cache time=60

Montar recurso compartido NFS

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

ls /mnt/
zroot.snap1.gz 

Ya tenemos el archivo que utilizaremos

Lanzamos el comando, gzcat descomprime el archivo, lee el archivo y la operacion de lectura redirige al comando receive, para recibir el sistema de archivos en el pool zroot

# gzcat /mnt/zroot.snap1.gz | zfs receive -Fv zroot

Establecer el sistema de archivos de arranque

zpool set bootfs=zroot/ROOT/default zroot

Exportar zroot

# zpool export zroot

Reiniciar el sistema

# reboot

Sí, ha funcionado

En este punto tenemos todo tal y como estaba en el momento en que se crearon las instantáneas

Utilizar el usuario no privilegiado carlos para el envío y recepción de instantáneas

Permisos para el envío de instantáneas

 zfs allow -u carlos create,destroy,hold,mount,receive,send,snapshot zroot

Permisos para la recepción de instantáneas

 zfs allow -u carlos create,destroy,mount,mountpoint,quota,receive,send,\
 snapdir zroot

FreeBSD es genial!.