Páginas

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

martes, 25 de marzo de 2025

Crear Particiones en Disco Duro USB Sistema de Archivos ZFS con gpart en FreeBSD 14

# Identificar el disco USB

Primero, verifica el nombre del disco USB conectado:

 gpart show

O también:

 camcontrol devlist

El disco USB generalmente aparecerá como daX (por ejemplo: da0).


# Eliminar particiones existentes (si es necesario)

Si el disco ya tiene particiones, puedes limpiarlo con:

 gpart destroy -F /dev/daX

(Reemplaza daX con tu dispositivo, como da0).


# Crear tabla de particiones (GPT)

Crea una tabla de particiones GPT en el disco:

 gpart create -s GPT /dev/daX

# Crear partición para ZFS

Crea una partición que ocupe todo el disco (o el espacio deseado):

 gpart add -t freebsd-zfs -a 1M -l ZFSBACKUP /dev/daX

-t freebsd-zfs: Tipo de partición para ZFS.
-a 1M: Alineación a 1 MiB (mejor rendimiento en discos modernos).
-l ZFSBACKUP`: Etiqueta de la partición (opcional pero útil para identificación).

# Verificar la partición creada

 gpart show /dev/daX

Deberías ver algo como:

=>   40  625142368  da0  GPT  (298G)
     40  625142368    1  freebsd-zfs  (298G)  [ZFSBACKUP]

# Crear el pool ZFS en la partición

Ahora crea un pool ZFS en la partición (no en el disco completo, `/dev/daX`, sino en la partición, /dev/daXp1 o /dev/gpt/ZFSBACKUP si usaste etiqueta):

 zpool create -f zbackup /dev/gpt/ZFSBACKUP

- zbackup: Nombre del pool (cámbialo si lo prefieres).
- f Fuerza la creación si hay restos de particiones anteriores.

# Configurar propiedades del pool (opcional)

Para mejorar la compatibilidad y rendimiento:

 zfs set mountpoint=none zbackup
 zpool set autoexpand=on zbackup
 zpool set listsnapshots=on zbackup

# Habilitar compresión (recomendado)

 zfs set compression=lz4 zbackup

# Verificar el pool ZFS

 zpool status

zfs list

# Enviar instantáneas (snapshots) al disco USB

Desde el sistema origen (donde está el ZFS con los datos), usa zfs send y zfs receive:


# En el sistema origen:

zfs snapshot pool/dataset@backup1
zfs send pool/dataset@backup1 | zfs receive zbackup/dataset

Si el disco está conectado a otro sistema, usa ssh:

 zfs send pool/dataset@backup1 | ssh user@host "zfs receive zbackup/dataset"

# Notas importantes:

USB y ZFS: ZFS en discos USB puede ser lento y no es ideal para uso intensivo. Se recomienda usar discos con conexión SATA o NVMe si es posible.
- Montaje automático: Si deseas que el pool se monte al conectar el disco, agrega zfs_enable="YES" en /etc/rc.conf.
- Exportar el pool: Antes de desconectar el disco, ejecuta:

 zpool export zbackup

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

¡Listo! Ahora tienes un disco USB con ZFS listo para recibir snapshots de FreeBSD.

 

FreeBSD es genial!.

sábado, 14 de diciembre de 2024

Replicación de datos ZFS FreeBSD

Bibliografía:
klarasystems.com
Klara Inc. Allan Jude y Jim Salter
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!.

domingo, 4 de diciembre de 2022

NFS Sistema de Archivos en Red FreeBSD ZFS

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

NFS FreeBSD ZFS utilizando /etc/fstab

NFS Network File System es un protocolo de nivel de aplicación, según el modelo OSI, que permite compartir, en una red local, directorios y particiones entre sistemas tipo Unix como si se tratara de locales. NFS está incluido por defecto en los sistemas operativos UNIX.

La utilidad nfsd se ejecuta en un equipo servidor para atender las peticiones NFS de los equipos de las máquinas cliente. Para que una máquina funcione como servidor, debe ejecutarse al menos un nfsd.

Configurar el servidor NFS

Acceder al servidor a través de SSH con clave pública


% ssh carlos@tormenta
% su
Password:
root@tormenta:/home/carlos #

Active el soporte del servidor NFS con las siguientes opciones de rc.conf. Aunque no todas opciones son estrictamente necesarias para todos los entornos, activarlas todas garantiza el mayor rango de compatibilidad con NFS y un rendimiento adecuado.


sysrc nfs_server_enable="YES"
sysrc rpcbind_enable="YES"
sysrc mountd_enable="YES"
sysrc rpc_lockd_enable="YES"
sysrc rpc_statd_enable="YES"

Archivo /etc/rc.conf


...
nfs_server_enable="YES"
rpcbind_enable="YES"
mountd_enable="YES"
rpc_statd_enable="YES"
rpc_lockd_enable="YES"
...

Reiniciar el sistema.

El demonio rpcbind mapea las llamadas a procedimientos remotos (RPC) en direcciones de red locales. Cada cliente NFS pregunta al demonio rpcbind del servidor dónde puede encontrar un demonio mountd al que conectarse.

El demonio mountd escucha los puertos de alta numeración para las peticiones de montaje de los clientes. Al activar el servidor NFS también se inicia nfsd, que se encarga de la solicitud de archivos. NFS asegura el bloqueo de archivos con rpc.lockd, y rpc.statd monitoriza los clientes NFS para que el servidor NFS pueda liberar recursos cuando el host desaparezca.

Una vez que el NFS esté funcionando, la salida de sockstat mostrará rpc.lockd, rpc.statd, nfsd, mountd, y rpcbind escuchando.

El servidor NFS debería auto negociar las conexiones de forma transparente. También puede ajustar su servidor NFS nfsd para que se adapte mejor a sus clientes y esto se hace con nfsd al inicio, con la opción (/etc/rc.conf) opción nfs_server_flags.

Comprobar que los servicios están activos


# service -e | grep rpcbind
/etc/rc.d/rpcbind
# service -e | grep mountd
/etc/rc.d/mountd
# service -e | grep lockd
/etc/rc.d/lockd
# service -e | grep statd
/etc/rc.d/statd

NFS puede funcionar sobre TCP o UDP que es el protocolo de transporte tradicional de NFS.

Cuando un servidor tiene varias direcciones IP es una buena práctica indicar al servidor NFS que utilice sólo una dirección con -h y la IP del servidor.

Que NFS utilice los protocolos de transporte UDP y TCP y se enlace a la dirección IP 192.168.88.160


nfs_server_flags="nfsd -u -t -h 192.168.88.160"

Configurar NFS Exports

Determinar que puede compartir o exportar el servidor.

FreeBSD le permite configurar las exportaciones a través de:

1. Fichero /etc/exports

2. Un servidor basado en ZFS, a través de la propiedad sharenfs de cada conjunto de datos. El servidor creará el archivo de exportaciones ZFS /etc/zfs/exports en base a estas propiedades. Ambos tienen el mismo formato pero no es buena práctica usar ambos métodos al mismo tiempo. Si utiliza el método ZFS nunca edite /etc/zfs/exports manualmente.

Independientemente del método elegido /etc/exports debe existir

Crear /etc/exports


# touch /etc/exports

NFS a través de /etc/exports

Configurar una exportación

Cada entrada del exports tiene hasta tres partes la primera obligatoria


1. Directorios o particiones a exportar
2. Opciones sobre esa exportación
3. Clientes que pueden conectarse

Dispositivo de disco y clientes sólo pueden tener una línea en el archivo de exportación. De modo que si, p.e., /var/log y /var/mail están en la misma partición, para exportar a un cliente en particular, ambos dos deben aparecer en la misma línea. No puede exportar /var/log y /var/mail a un cliente con permisos diferentes.

Tampoco tiene que exportar todo el dispositivo de disco; puede exportar un directorio dentro de una partición. Si las particiones /var y /var/mail están separadas, la exportación de /var no exporta automáticamnet /var/mail

Esta línea en /etc/exports exporta el directorio /home/mycloud a todos los hosts, no tiene opciones ni restricciones de host


/usr/home/mycloud

Una vez editado el archivo /etc/exports:


# service mountd reload

En NFSv2 y NFSv3 los usuarios son identificados por UID, por ejemplo, en mi portátil el usuario carlos tiene el UID 1001. En el servidor NFS carlos también tiene el UID 1001. Los mismos privilegios en el servidor y en el portátil.

En una red pequeña se puede sincronizar /etc/master.passwd en sus sistemas o asignar el mismo UID.

Si desea que todas las peticiones desde root en un cliente se ejecuten como el usuario nfsroot (uid=10000) en el servidor. Utilizando cuidadosamente los grupos, puede permitir que este usuario tenga un acceso limitado a los archivos.

La opción maproot se usa para asignar root a otro usuario. Por ejemplo, asignar el UID 0 (root) en el cliente, al UID 10000 en el servidor


/usr/home/mycloud   -maproot=10000

Exportando múltiples directorios

Todos los directorios en la misma línea de /etc/exports separados por espacio


/var/log /usr/src/ /usr/obj -maproot=carlos

Los clientes pueden montar cualquiera de estos directorios y las peticiones de root se asignan al usuario carlos

Restricción de clientes

Sólo los clientes listados prodrán acceder a la exportación NFS.


/var/log /usr/src/ /usr/obj -maproot=carlos 192.168.88.100 192.168.88.51

Permitir que cualquier cliente con una dirección IP que empiece en 192.168.88 acceda a los recursos compartidos del servidor NFS.


/var/log /usr/src/ /usr/obj -maproot=carlos -network 192.168.88 -mask 255.255.255.0

El cliente NFS de la dirección IP 192.168.88.101 puede montar la totalidad de /usr y puede hacerlo como root


/var/log /usr/src/ /usr/obj -maproot=carlos 192.168.88.100
/usr -maproot=0 192.168.88.101

NFS a través de ZFS

sharenfs es la propiedad utilizada para activar, desactivar y configurar exportaciones NFS. Se establece en on para compartir globalmente un conjunto de datos y todos sus decendientes.

Este conjunto de datos o cualquiera de sus hijos puede ser montado por cualquier persona, sin restricciones y sin opciones, a menos que tenga control de acceso, como un cortafuegos. Crear un conjunto de datos con la propiedad canmount=off; esta propiedad controla si un conjunto de datos puede ser montado o no. Es lo que querrás hacer si no quieres romper los entornos de arranque (Boot Environments).


# zfs create -o canmount=off zroot/usr/backup
# zfs get mounted zroot/usr/backup
NAME              PROPERTY  VALUE    SOURCE
zroot/usr/backup  mounted   no       -

Ahora puede crear un conjunto de datos separados.


# zfs create zroot/usr/backup/nfsshare
# chown carlos:carlos zroot/usr/backup/nfsshare

Crear el dataset poolrecovery que será utilizado, posteriormente, para duplicar 
un sistema completo FreeBSD ZFS
# zfs create zroot/usr/backup/poolrecovery

Empezar a compartir sharenfs=on


# zfs set sharenfs=on zroot/usr/backup/nfsshare
# zfs set sharenfs=on zroot/usr/backup/poolrecovery

Para dejar de compartir el conjunto de datos, se establece sharenfs en off


# zfs set sharenfs=off zroot/dellhome

Establecer un usuario maproot y restringir los clientes a la red local


# zfs set sharenfs="-maproot=0 192.168.88.51" zroot/usr/backup/poolrecovery
# zfs set sharenfs="-network 192.168.88.0/24 -maproot=carlos" zroot/usr/backup/nfsshare

El uso de ZFS es menos flexible para la gestión de exportaciones NFS porque todos los hosts permitidos obtienen las mismas opciones.

ZFS crea automáticamnet el Fichero /etc/exports


cat /etc/zfs/exports
# !!! DO NOT EDIT THIS FILE MANUALLY !!!

/usr/backup/nfsshare    -network 192.168.88.0/24 -maproot=carlos
/usr/backup/poolrecovery     -maproot=0 192.168.88.51

Mapeos de host a IP
...
192.168.88.160          solaris
192.168.88.51           tormenta
...

habilitar el cliente NFS


Mapeos de host a IP
...
192.168.88.51           tormenta
192.168.88.160          solaris
...

Agregar al archivo /etc/rc.conf


sysrc nfs_client_enable=YES
Listar todas las exportaciones NFS disponibles para un cliente

$ showmount -e tormenta
Exports list on tormenta:
/usr/backup/poolrecovery           192.168.88.51
/usr/backup/nfsshare               192.168.88.0

Montar directorios o sistemas de ficheros exportados por el servidor NFS.


# mkdir /mnt/nfs
# mount tormenta:/nfsshare /mnt/nfs

Opciones de montaje

Para acceder a un servidor NFS utilizando sólo UDP con la opción de montaje udp (-u).

Si el servidor NFS desaparece, los programas en el cliente que intenten acceder al sistema de archivos NFS se cuelgan. Por tanto, su montaje NFS tiene que ser interrumpible con la opción intr; podrá interrumpir los procesos colgados con ctrl-C.

Utilizar un montaje suave (soft) FreeBSD notificará a los programas que el fichero ya no está disponible.

Montar Directorios con las opciones soft,intr,rw


# umount /mnt/nfs
# mount -o soft,intr,rw tormenta:/zroot/nfsshare /mnt/nfs
# mount
...
tormenta:/usr/backup/poolrecovery on /mnt/nfs (nfs)
...

Podria anadir esto a /etc/fstab para el mountaje automático


tormenta:/usr/backup/poolrecovery	/mnt/nfs   nfs  rw,soft,intr   0  0

Que versión de NFS estamos utilizando


# nfsstat -m
solaris:/rpool/nfssolaris on /media/nfs
nfsv3,tcp,resvport,nconnect=1,soft,intr,cto,lockd,sec=sys,acdirmin=3,acdirmax=60,\
acregmin=5,acregmax=60,nametimeo=60,negnametimeo=60,rsize=65536,wsize=65536,\
readdirsize=65536,readahead=1,wcommitsize=16777216,timeout=120,retrans=2

https://gnulinuxcodigo.blogspot.com/2022/12/montaje-de-sistemas-de-archivos-nfs.html


FreeBSD es genial!

lunes, 24 de junio de 2019

Copiar restaurar particiones Linux


Instalar Arch Linux UEFI

Iniciar el sistema desde un usb live Sytem Rescue con soporte UEFI


lsblk lista información a cerca de todos los dispositivos de bloques disponibles


# lsblk

root@sysresccd /root % lsblk 

NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINT

sda      8:0    0  55.9G  0 disk 

├─sda1   8:1    0   512M  0 part 

├─sda2   8:2    0    30G  0 part 

└─sda3   8:3    0  25.4G  0 part 

sdb      8:16   0 465.8G  0 disk 

└─sdb1   8:17   0 211.5G  0 part 

sdc      8:32   1   1.9G  0 disk 

└─sdc1   8:33   1   1.9G  0 part /livemnt/boot

loop0    7:0    0 317.1M  1 loop /livemnt/squashfs

lsblk con la opción -f devuelve información sobre sistemas de archivos

# lsblk -f

NAME FSTYPE LABEL UUID FSAVAIL FSUSE% MOUNTPOINT

sda                                                                   

├─sda1 vfat    CC3A-1EDB 

├─sda2  ext4    38b21575-cd76-4ff5-9733-654c1d50f30f   21,4G    22% /

└─sda3  ext4    e9774ab0-2d95-4820-8c1e-d76563970c86     21G    11% /home

sdb                                                                   

└─sdb1  vfat  SYSRCD-4_5_ 6843-DF82    /livemnt/boot

sdc                                                                

└─sdc1  ext4 ArchlinuxHP   d007c890-2620-44fc-aaeb-5e40f68fa40

loop0  squashfs                                               /livemnt/squashfs 

https://docs.freebsd.org/es/books/handbook/disks/#backup-basics

“No hacer nada” no es un programa, pero es la estrategia de respaldo más extendida. No tiene coste. No hay un calendario de respaldos a seguir. Simplemente hay que decir que no. Si algo le sucediera a sus datos sonría y acostúmbrese a su nueva situación.


Copia de seguridad con tar

Se crea el punto de montaje y se monta en modo rw (lectura y escritura) el disco duro externo donde se guardarán las copias de seguridad en formato tar.gz

root@sysresccd /root % mkdir /mnt/backuprestore
root@sysresccd /root % mount -t ext4 -o rw /dev/sdc1 /mnt/backuprestore

Se crean los puntos de montaje uno para cada partición con nombres que sirvan de referencia.

# mkdir /mnt/archlinuxboot
# mkdir /mnt/archlinuxraiz
# mkdir /mnt/archlinuxhome

Mantar en modo ro (sólo lectura) las particiones del sistema a respaldar

root@sysresccd /mnt % mount -o ro -t vfat /dev/sda1 /mnt/archlinuxboot
root@sysresccd /mnt % mount -o ro -t ext4 /dev/sda2 /mnt/archlinuxraiz
root@sysresccd /mnt % mount -o ro -t ext4 /dev/sda3 /mnt/archlinuxhome

Opciones y argumentos del comando tar
c crea la copia usando tar
v activa el modo verbose para mostrar información por pantalla
z comprime los datos utilizando el formato gzip
p preserva los permisos de los ficheros (predeterminado para root)
f manda la salida a un fichero en lugar de a la salida estandar
--exclude excluye ficheros y directorios de la copia

Se crea y exporta la variable temporal fecha
root@sysresccd /mnt % FECHA=$(date +%d%m%Y)
root@sysresccd /mnt % export FECHA
root@sysresccd /mnt % env | grep FECHA
FECHA=24062019
root@sysresccd /mnt % echo $FECHA
24062019

Una vez hecho esto se cambia al punto de montaje de la partición raiz (sda2) para realizar la copia.
root@sysresccd /mnt % cd /mnt/archlinuxraiz
root@sysresccd /mnt/archlinuxraiz % tar czvf /mnt/backuprestore/Archlinux/archlinuxsda2/archilinuxsda2-$FECHA.tar.gz *

Entrando en el punto de montaje de la partición boot (sda1) para la copia en formato tar.gz utilizando tar
root@sysresccd /mnt % cd /mnt/archlinuxboot
root@sysresccd /mnt/archlinuxboot % tar czvf /mnt/backuprestore/Archlinux/archlinuxsda1/archilinuxsda1-$FECHA.tar.gz *

Por último lo mismo para home (sda3)

root@sysresccd /mnt % cd /mnt/archlinuxhome
root@sysresccd /mnt/archlinuxraiz % tar czvf /mnt/backuprestore/Archlinux/archlinuxsda3/archilinuxsda3-$FECHA.tar.gz --exclude=lost+found *

Restaurar particiones

Iniciar un live usb System Rescue con soporte UEFI

Crear el punto de montaje y montar en modo ro (sólo lectura) la partición que contiene el o los archivos comprimidos a restaurar

# mkdir /mnt/backuprestore
# mount -t ext4 -o ro /dev/sdb1 /mnt/backuprestore

Restaurar la partición raiz

Formatear la partición a restaurar (se perderan todos los datos)
# mkfs.ext4 /dev/sda2

Crear el punto de montaje y montar en modo rw (lectura y escritura) la partición a restaurar

# mkdir /mnt/archraiz
# mount -t ext4 -o rw /dev/sda2 /mnt/archraiz

Entrar en la partición sda2
# cd /mnt/archraiz

Extraer el archivo (no olvide el punto final)
# tar xvzf /mnt/backuprestore/Archlinux/archlinuxsda2/archilinuxsda2-24062019.tar.gz .

Restaurar partición boot (sda1)

Formatear la partición a restaurar (se perderan todos los datos)
# mkfs.vfat /dev/sda1

Crear el punto de montaje y montar en modo rw (lectura y escritura) la partición a restaurar
# mkdir /mnt/archboot
# mount -t vfat -o rw /dev/sda1 /mnt/archboot

Entrar en la partición sda1
# cd /mnt/archboot

Extraer el archivo

# tar xvzf /mnt/backuprestore/Archlinux/archlinuxsda1/archilinuxsda1-24062019.tar.gz .

Restaurar partición home

Formatear la partición a restaurar (se perderan todos los datos)
# mkfs.ext4 /dev/sda3

Crear el punto de montaje y montar en modo rw (lectura y escritura) la partición a restaurar
# mkdir /mnt/archhome
# mount -t ext4 -o rw /dev/sda3 /mnt/archhome

Entrando en la partición sda3

# cd /mnt/archraiz

Extraer el archivo
# tar xvzf /mnt/backuprestore/Archlinux/archlinuxsda3/archilinuxsda3-24062019.tar.gz . 

Finalmente desmontar las particiones

# cd
# umount /mnt/archraiz
# umount /mnt/archboot
# umount /mnt/archhome
# umount /mnt/backuprestore

O desmontar recursivamente.
La relación entre los puntos de montaje está determinada por /proc/self/mountinfo. El sistema de archivos debe ser especificado por la ruta del punto de montaje. Un recursivo desmontado por el nombre del dispositivo o UUID es incompatible.

# umount -R /mnt/*

Reiniciar el sistema
# reboot

OpenBSD es genial!.

viernes, 3 de julio de 2015

Montar almacenamieto USB FreeBSD

El soporte para dispositivos de almacenamiento USB esta integrado en el kernel GENERIC.

Utilice dmesg para confirmar que la unidad aparece en el buffer de mensajes del sistema:


Para que el dispositivo sea mountable como un usuario normal, hacer al usuario miembro del grupo operator utilizando pw.
# pw usermod carles -G operator

Lo siguiente es asegurarse que operator está habilitado para leer y escribir en el dispositivo
# ee /etc/devfs.rules
[localrules=5]
add path 'da*' mode 0660 group operator

# pkg install fusefs-ntfs

Habilitar la regla en /etc/rc.conf
# ee /etc/rc.config
devfs_system_ruleset="localrules"

Indicar al sistema que permita a usuarios regulares montar sistemas de archivos agregando a /etc/sysctl.config
# ee /etc/sysctl.conf
vfs.usermount=1

# sysctl vfs.usermount=1
vfs.usermount: 0 -> 1

Crear un directorio y hacer que pertenezca user group primario del usuario.
# mkdir /mnt/carles
# chown carles:carles /mnt/carles
# ls -ld /mnt/carles/
drwxr-xr-x  2 carles  carles  512 Jul  3 03:24 /mnt/carles/

Suponiendo que el dispositivo USB esta conectado, aparece como /dev/da0 y formateado con el sistema de archivos FAT32, montamos como usuario normal (read write).
$ mount_msdosfs -o rw /dev/da0 /mnt/carles/


Antes de desconectarlo puede desmontar el dispositivo:
# umount /mnt/carles

En caso de dispositivo de almacenamiento USB formateado con el sistema de archivos NTFS
# pkg install fusefs-ntfs
# kldload fuse
# mkdir /mnt/ntfs
# chown carles:carles /mnt/ntfs
$ ntfs-3g -o rw /dev/da0s1 /mnt/ntfs

Cargar el modulo con el sistema, agregar al archivo /boot/loader.conf
# ee /boot/loader.conf
fuse_load="YES"

Unix es genial!.