Páginas

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

martes, 10 de marzo de 2026

Formatear y montar dispositivo USB exFAT en FreeBSD 14.3

Fuente:

https://docs.freebsd.org/en/books/handbook/filesystems/

En FreeBSD 14.3, el sistema no tiene soporte nativo para exFAT en el kernel. Para el montaje de un disco USB exFAT (/dev/da0 o /dev/da0p1 /dev/da0s1), se necesita utilizar FUSE y el puerto fusefs-exfat.

Instalar los paquetes necesarios

pkg install fusefs-libs fusefs-exfat

pkg info | grep -i exfat
exfat-utils-1.4.0_1    Utilities to create, check, label and dump exFAT filesystem
fusefs-exfat-1.4.0_1   Full-featured exFAT FS implementation as a FUSE module

Cargar el módulo FUSE

kldload fusefs

Para cargar siempre al inicio

sysrc kld_list+="fusefs"

Identificar correctamente el dispositivo

dmesg
da0 at umass-sim0 bus 0 scbus1 target 0 lun 0
da0: <ASMT USB 3.0 TOSATA 0> Fixed Direct Access SPC-4 SCSI device
da0: Serial Number 0000000000A3
da0: 400.000MB/s transfers
da0: 38166MB (78165360 512 byte sectors)
da0: quirks=0x2

Particionar /dev/da0 desde FreeBSD 14.3

Desmontar si está montado (por seguridad)

umount /dev/da0p1 2>/dev/null || true 

Formatear dispositivo /dev/da0

Borrar todo y crear tabla GPT (destructivo)

sudo gpart destroy -F da0
da0 destroyed

gpart create -s gpt da0 
da0 created

Agregar una partición que ocupe todo el disco con el tipo ms-basic-data que Windows/macOS reconocen como exFAT

gpart add -t ms-basic-data -l "MiSSD" da0
da0p1 added

Formatear la partición (da0p1)

mkexfatfs /dev/da0p1
mkexfatfs 1.4.0
Creating... done.
Flushing... done.
File system created successfully.

Crear punto de montaje y montar la particion

mkdir /mnt/usb
mount.exfat /dev/da0p1 /mnt/usb
FUSE exfat 1.4.0 (libfuse2)

Mostrar espacio libre en disco

df -h /mnt/usb 
Filesystem    Size   Used   Avail Capacity  Mounted on
/dev/da0p1     37G   1.6M     37G     0%    /mnt/usb

Listar las particiones

gpart show da0
=>      40  78165280  da0  GPT  (37G)
        40  78165280    1  ms-basic-data  (37G)

El dispositivo real suele ser

/dev/da0p1 (GPT con letra p)
/dev/da0s1 (MBR/slice con letra s)

Es importante desmontar antes de desconectar

umount /mnt/usb
FreeBSD es genial!.

jueves, 19 de febrero de 2026

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

Estado actual del sistema

zpool status
zpool list 
zpool list -t all

Identificar discos

geom disk list
camcomtrol devlist

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


Limpiar el disco nuevo completamente

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

Crear tabla de particiones GPT

gpart create -s gpt da0

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

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

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

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

Partición swap

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

Particion ZFS (el resto del disco)

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

Para sistemas UEFI


Montar partición EFI del disco nuevo

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

Copiar EFI loader desde el actual disco

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

umount /mnt

Crear pool temporal en el nuevo disco

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

Verificar

zpool status zroot-new

Listar todos los datasets a migrar

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

Tomar snapshot recursivo de todo el pool (Shell zsh)

sudo zfs snapshot -r zroot@migracion

Verificar snapshot creado

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

Enviar snapshot raíz primero

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

Enviar recursivamente todos los datasets hijos

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

Banderas (flags)

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

Comprobar la replicación


Comparar conjuntos de datos entre pools

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

Verificar propiedades

zfs get all zroot
zfs get all zroot-new

Cantidad de instantáneas

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

Configurar bootfs en el nuevo pool

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

Verificar

zpool get bootfs zroot-new

Ajustar cachefile y otros parámetros del pool

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

Ver propiedades del pool original para replicarlas

zpool get all zroot

Montar el dataset raíz del nuevo disco

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

Verificar /boot/loader.conf

cat /mnt/boot/loader.conf

Debe contener algo como:

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

Si el nombre del pool cambió, actualizar:

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

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

cat /mnt/etc/fstab

Cambiar el disco y primer arranque


Apagar el sistema

shutdown -p now

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

Verificación después del arranque


Comprobar salud del pool

zpool status
zpool list

Verificar que todos los datasets montaron

zfs list -t filesystem

Verificar espacio disponible (debe reflejar el disco nuevo mayor)

df -h

Verificar que el sistema arrancó desde el disco correcto

geom disk list
camcontrol devlist

Limpiar snapshots de migración

zfs destroy -r zroot@migracion

Problemas y posibles soluciones después del primer arranque


Renombrar zpool zroot-new a zroot

zpool import -f zroot-new zroot

Error

zpool export zroot-new Cannot unmount /

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

Solución Desde loader prompt o LiveCD


Desde el LiveCD

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

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

Reiniciar

shutdown -r now

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

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

Estos dos errores son normales y esperables en este proceso.

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

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

Montar el sistema de ficheros rw

mount -u -o rw /

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

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

Cambiar la línea de swap, por ejemplo

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

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

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

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

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

Error 2

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

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

Sencillamente borrarlo, ZFS lo regenera automáticamente

rm /etc/zfs/zpool.cache

Antes de reiniciar para verificar el nombre correcto del dispositivo

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

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

Reiniciar

shutdown -r now

Error 3.

Can't open /dev/gpt/efiboot0

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

ls /dev/gpt
efiboot0 gptboot0 swap0

Montar el sistema de ficheros rw

mount -u -o rw /

Solución. Renombrar el label al esperado

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

Corregir el label

gpart modify -i 1 -l efiboot0 ada0

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

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

umount /mnt

 

FreeBSD es genial!.

viernes, 4 de julio de 2025

Borrar Disco FreeBSD 14.2

Borrar disco

Arranque el dispositivo objetivo desde el medio de instalación. En el menú de arranque de FreeBSD, presione s para seleccionar el modo de usuario único de arranque.

Use geom para identificar discos

 geom disk list
Geom name: nda0
Providers:
1. Name: nda0
...

Use dd para sobrescribir todo el disco con ceros:

 dd if=/dev/zero of=/dev/nda0 bs=4M conv=fsync oflag=direct status=progress

Esta operación tomará un poco de tiempo. En mi nvme 500G, por ejemplo, tardó aproximadamente 14 minutos en borrar completamente el disco. Sea paciente.

Instalación

Después de que termine la operación de borrado, ingrese el comando reboot para volver al Menú de Arranque. Presione <Enter> para iniciar el instalador.

 reboot
En la pantalla de bienvenida, elija Install.
FreeBSD es genial!.

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

jueves, 28 de octubre de 2021

Crear particiones e instalar FreeBSD 13.0 zfs UEFI

A diferencia del valor predeterminado de bsdinstall para ZFS, no establece puntos de montaje explícitos para conjuntos de datos, sino que se basa en la herencia.

Este conjunto de instrucciones configura partición freebsd-boot, una particion ESP para la instalacion UEFI, intercambio cifrado con GELI y un grupo raíz.  

Iniciar el instalador de FreeBSD


Elegir shell para el particionado manual

Limpiar disco - Esta es una operación destructiva


# gpart destroy -F ada0
ada0 destroyed

Configurar nueva tabla de partición GPT.

Antes de poder crear particiones de disco, se debe marcar el disco con el tipo de esquema de partición que utilizará, gpart create con la marca -s y el esquema, como gpt o mbr. Aquí, el disco usa el esquema GPT


# gpart create -s gpt ada0
ada0 created

Añadir particiones con etiquetas (label -l) para acceder a ellas por su nombre.

Crear partición boot para arranque Legacy (aunque no será utilizada). No puede ser mayor de 545k.

 # gpart add -t freebsd-boot -s 512k -l boot0 ada0
ada0p1 added

UEFI ESP arranque UEFI.


# gpart add -t efi -s 200M -l efi0 ada0 
ada0p2 added

ESP debe ser vfat/fat32:


# newfs_msdos -F 32 -c 1 /dev/ada0p2
/dev/gpt/efi0: 2003 sectors in 2003 FAT12 clusters (512 bytes/cluster)
BytesPerSec=512 SecPerClust=1 ResSectors=1 FATs=2 RootDirEnts=512 Sectors=2048 \
Media=0xf0 FATsecs=6 SecPerTrack=63 Heads=255 HiddenSecs=0

Partición swap

# gpart add -t freebsd-swap -l swap0 -a 1m -s 2048m ada0

Resto del disco

# gpart add -t freebsd-zfs -l zroot0 -a 1m ada0

Crear el root pool

.
# zpool create -R /mnt -o cachefile=/tmp/zpool.cache -O mountpoint=/ \
    -O atime=off -O canmount=off -O compression=on \
    zroot gpt/zroot0
# zfs create -o canmount=off -o mountpoint=none zroot/ROOT
# zfs create -o mountpoint=/ zroot/ROOT/default

Definir el conjunto de datos de arranque predeterminado para este zpool

# zpool set bootfs=zroot/ROOT/default zroot

Crear el resto de los sistemas de archivos


# zfs create -o canmount=off zroot/usr
# zfs create zroot/usr/home
# zfs create zroot/usr/local
# zfs create zroot/usr/obj
# zfs create zroot/usr/src
# zfs create zroot/usr/ports
# zfs create -o canmount=off zroot/var
# zfs create zroot/var/jail
# zfs create zroot/var/log
# zfs create zroot/var/tmp
# zfs create zroot/tmp
# zfs set setuid=off zroot/tmp
# zfs set setuid=off zroot/var
# zfs set exec=off zroot/var
# zfs set setuid=off zroot/usr/src 
# zfs set exec=off zroot/usr/src
# zfs set setuid=off zroot/usr/ports
# zfs set exec=on zroot/var/tmp

Copiar el caché de zpool


# mkdir -p /mnt/boot/zfs
# cp /tmp/zpool.cache /mnt/boot/zfs

No olvide elegir la opción shell para terminar la configuración al final de la instalación.


# exit

Elegir

 Install  

Keymap Selection

Set Hostname

Distribution Select 

Partitioning

En este punto elegir la opción:

open a shell and partition by hand

# exit

Fetching Distribution

Comprobing checksum

Archive Extraction 

New Password

Retype New Password

Network Configuration

Would you like to configure
IPv6..? No

Resolver Configuration

Select local or UTC (Greenwich Mean Time) clock

System Configuration 

System Hardening

Add User Accounts (Yes)

Final Configuration 

Exit (Apply configuration and exit installer) OK

Manual Configuration Yes

Elegir Yes para seguir con la configuración


# cat >> /boot/loader.conf<<EOF
zfs_load="YES"

zpool_cache_load="YES"
zpool_cache_name="/boot/zfs/zpool.cache"
zpool_cache_type="/boot/zfs/zpool.cache"

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

# cat >> /etc/rc.conf<<EOF
zfs_enable="YES"
zfsd_enable="YES"
EOF

# cat >> /etc/fstab<<EOF
/dev/gpt/efi0 /boot/efi0 msdosfs rw,late 0 0
/dev/swap.eli none swap sw 0 0
EOF

# mount -t devfs devfs /dev
# rm /dev/null

Crear punto de montaje y montar ESP


# mkdir /boot/efi0 
# mount -t msdosfs /dev/gpt/efi0 /boot/efi0 

UEFI con nomenclatura de reserva:


mkdir -p /boot/efi0/efi/boot
cp /boot/loader.efi /boot/efi0/efi/boot/bootx64.efi

Llegados a este punto debería estar listo.


# exit

# Reboot


# zfs create zroot/usr/home/carlos

Enlace simbólico y permisos.


# ln -s /usr/home /home
# chmod 1777 /var/tmp
# chmod 1777 /tmp

Usar git para obtener el código fuente de FreeBSD 13.0

(Si necesita construir módulos del kernel)


# pkg install git
# git clone -b releng/13.0 https://git.freebsd.org/src.git /usr/src

Clonar colección de puertos con git


# git clone https://git.freebsd.org/ports.git /usr/ports

Crear Directorios de usuario


# pkg install xdg-user-dirs
$ xdg-user-dirs-update

# cat /etc/fstab
/dev/gpt/efi0 /boot/efi0 msdosfs rw,late 2 2
/dev/swap.eli none swap sw 0 0

# cat /boot/loader.conf
security.bsd.allow_destructive_dtrace=0
cryptodev_load="YES"
zfs_load="YES"
zpool_cache_load="YES"
zpool_cache_name="/boot/zfs/zpool.cache"
zpool_cache_type="/boot/zfs/zpool.cache"

vfs.root.mountfrom="zfs:zroot/ROOT/default"
# cat /etc/rc.conf
clear_tmp_enable="YES"
syslogd_flags="-ss"
sendmail_enable="NONE"
hostname="bsdzfs"
ifconfig_ue0="DHCP"
sshd_enable="YES"
ntpd_enable="YES"
# Set dumpdev to "AUTO" to enable crash dumps, "NO" to disable
dumpdev="NO"
zfs_enable="YES"
zfsd_enable="YES"
# gpart show
=>       40  976773088  ada0  GPT  (466G)
         40       1088     1  freebsd-boot  (544K)
       1128       2048     2  efi  (1.0M)
       3176        920        - free -  (460K)
       4096    4194304     3  freebsd-swap  (2.0G)
    4198400  972574720     4  freebsd-zfs  (464G)
  976773120          8        - free -  (4.0K)
# zfs list
NAME                        USED  AVAIL     REFER  MOUNTPOINT
zroot                      1.83G   444G       96K  /
zroot/ROOT                 1011M   444G       96K  none
zroot/ROOT/default         1011M   444G     1011M  /
zroot/tmp                   104K   444G      104K  /tmp
zroot/usr                   863M   444G       96K  /usr
zroot/usr/home               96K   444G       96K  /usr/home
zroot/usr/local             191M   444G      191M  /usr/local
zroot/usr/obj                96K   444G       96K  /usr/obj
zroot/usr/ports             192K   444G       96K  /usr/ports
zroot/usr/ports/distfiles    96K   444G       96K  /usr/ports/distfiles
zroot/usr/src               672M   444G      672M  /usr/src
zroot/var                   432K   444G       96K  /var
zroot/var/jail               96K   444G       96K  /var/jail
zroot/var/log               144K   444G      144K  /var/log
zroot/var/tmp                96K   444G       96K  /var/tmp

https://wiki.freebsd.org/MasonLoringBliss/ZFSandGELIbyHAND

FreeBSD es genial!.

domingo, 24 de octubre de 2021

Actualizar zpool en FreeBSD 13.0 UEFI partition

Después de actualizar el pool el código de inicio del disco duro también se debe actualizar, de manera que se pueda iniciar el sistema sin problemas.

El instalador de FreeBSD 13.0 con zfs elige una partición de arranque BIOS tradicional freebsd-boot y una partición UEFI efi .

gpart show
=>        40  1953525088  ada0  GPT  (932G)
          40      532480    1   efi  (260M)
      532520        1024    2   freebsd-boot  (512K)
      533544         984        - free -  (492K)
      534528     4194304    3   freebsd-swap  (2.0G)
     4728832  1948794880    4   freebsd-zfs  (929G)
  1953523712        1416        - free -  (708K)
# zpool upgrade -a
This system supports ZFS pool feature flags.

Enabled the following features on 'zroot':
  allocation_classes

If you boot from pool 'zroot', don't forget to update boot code.
Assuming you use GPT partitioning and da0 is your boot disk
the following command will do it:

        gpart bootcode -b /boot/pmbr -p /boot/gptzfsboot -i 2 da0

Si el arranque de su sistema es UEFI al ejecutar el código anterior y hacer un reboot el sistema no se iniciará.
    
Para actualizar una partición EFI:
# mount -t msdosfs /dev/ada0p1 /mnt
# mv /mnt/boot/efi0/efi/boot/bootx64.efi /mnt/efi/boot/bootx64.efi-old
# cp /boot/loader.efi /mnt/boot/efi0/efi/boot/bootx64.efi
# umount /mnt
# reboot

FreeBSD es genial!.

martes, 19 de octubre de 2021

ZFS Local Replication en FreeBSD

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


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

# geom disk list


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

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

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


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

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

# zpool create zbackups da0p1

Establecer el punto de montaje


# zfs set mountpoint=/mnt/zbackups zbackups

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


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

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

Listar snapshot

# zfs list -t snapshot

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

Primero crear la instantánea para después enviar


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

Enviar el conjunto de datos a zbackups/carlos


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

# zfs snapshot zroot/vm@snap_1910211203

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

# zfs snapshot zroot/vm/alpine@snap_1910211203

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

# zfs snapshot zroot/vm/arch@snap_1910211203

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

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

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

snapshot del pool completo zroot


# zfs snapshot -r zroot@snap1_021121

Crear dataset zbackups


# zfs create zbackups/snap1full

Enviar recursivamente las snpashots


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

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


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

Instantáneas incrementales

Crear las instantánea(s)


# zfs snapshot zroot/usr/home/carlos@snap_20102112020

Enviar instantáneas incrementales.


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

% smartctl -a /dev/ada0


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

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

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

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

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

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

FreeBSD es genial!.

lunes, 10 de junio de 2019

Instalar Arch Linux UEFI

Instalar Arch Linux 2019 modo UEFI (Unified Extensible Firmware Interface) y tabla de particiones GPT necesaria para arrancar en modo UEFI desde la BIOS.



Descargar Arch Linux y grabar la instantánea de Arch Linux en una unidad USB (unidad flash). Arrancar el sistema desde el dispositivo USB cambiando el orden de arranque desde la BIOS o utilizando la tecla F12 o F9 (dependiendo de su sistema).

Al finalizar el proceso de arranque lo primero es comprobar la conexión a Internet:
root@archiso ~ # ping -c3 www.freebsd.org

Si en lugar de conexión por cable nos conectarnos mediante wifi Arch Linux pone a su disposición la herramienta wifi-menu.
root@archiso ~ # wifi-menu

Comprobamos con fdisk -l los discos del sistema disponible y las particiones creadas.

El particionado del disco /dev/sda (SSD) puede realizarse con diferentes herramientas en este caso se utiliza cfdisk.

root@archiso ~ # cfdisk /dev/sda
En el cuadro de diálogo (Select label type) se selecciona el tipo gpt.
Luego se crea una nueva partición de 512M (Partition size) partición 1 del tipo EFI system.
A continuación una segunda partición de 30G del tipo ext4
Por último una cuarta partición con el resto del espacio libre del disco tipo ext4. Se desplaza hasta Write y sale con Quit. Tendremos este esquema de particionado:

root@archiso ~ # fdisk -l
Disposit.  Comienzo     Final Sectores Tamaño Tipo
/dev/sda1      2048   1050623  1048576   512M Sistema EFI
/dev/sda2   1050624  63965183 62914560    30G Sistema de ficheros de Linux
/dev/sda3  63965184 117231374 53266191  25,4G Sistema de ficheros de Linux

Crear los sistemas de ficheros
root@archiso ~ # mkfs.fat -F32 /dev/sda1
root@archiso ~ # mkfs.ext4 /dev/sda2
root@archiso ~ # mkfs.ext4 /dev/sda3

Montar las particiones

root@archiso ~ # mount /dev/sda2 /mnt
root@archiso ~ # mkdir /mnt/home
root@archiso ~ # mount /dev/sda3 /mnt/home
root@archiso ~ # 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 /home

Elegir lista de mirror

# pacman -Sy
# pacman -S reflector
# reflector --verbose -l 5 --sort rate --save /etc/pacman.d/mirrorlist

sda1 es nuestra partición UEFI, se usará más tarde. El comando pacstrap con la opción -i (ver la información) instala los paquetes base base-devel dentro de /mnt

root@archiso ~ # pacstrap -i /mnt base base-devel

El comando genfstab con las opciónes U (use UUIDs) y p (Excluye pseudofs montados)

root@archiso ~ # genfstab -U -p /mnt >> /mnt/etc/fstab

Se necesita chroot a mnt para entrar en el nuevo sistema instalado

root@archiso ~ # arch-chroot /mnt /bin/bash

Establecer la locale

root@archiso ~ # nano /etc/locale.gen descomentar la siguiente línea.
es_ES.UTF-8 UTF-8

Generar la locale
root@archiso ~ # locale-gen

Enlace a hora locale dentro de su zone

root@archiso ~ # ln -sf /usr/share/zoneinfo/Europe/Madrid /etc/localtime

Enlace a hora locale dentro de su time zone
root@archiso ~ # hwclock --systohc --utc

root@archiso ~ # echo archlinux > /etc/hostname

root@archiso ~ # nano /etc/hosts
127.0.0.1 localhost.localdomain archlinux.unix.bcn archlinux

Instalar networkmanager
root@archiso ~ # pacman -S networkmanager

Activar la conexión a Internet cableada
(wired) durante el arranque del sistema.
root@archiso ~ # systemctl enable NetworkManager

Establecer la contraseña de root
root@archiso ~ # passwd

Archivo /etc/pacman.conf descomentar:

 [multilib]
Include = /etc/pacman.d/mirrorlist

El siguiente paso donde se instala el group bootloader
es el más relevante  en el proceso de instalaciónn de UEFI:

1.- Instalar los paquetes necesarios

root@archiso ~ # pacman -S grub efibootmgr

2.- Crear el directorio efi y montar la partición efi sda1 a este directorio

root@archiso ~ # mkdir /boot/efi
root@archiso ~ # mount /dev/sda1 /boot/efi

Comprobar el punto de montaje con lsblk
root@archiso ~ # lsblk

3.- Iniciar la instalación de grub-install

root@archiso ~ # grub-install --target=x86_64-efi --bootloader-id=GRUB --efi-directory=/boot/efi

4.- Se necesita generar el archivo de configuración para el grub bootloader instalado.
root@archiso ~ # grub-mkconfig -o /boot/grub/grub.cfg

5.- Configuraión adicional.

root@archiso ~ # mkdir -p /boot/efi/EFI/BOOT
root@archiso ~ # cp /boot/efi/EFI/GRUB/grubx64.efi /boot/efi/EFI/BOOT/BOOTX64.EFI

BOOTX64.EFI es el bootloader reconocido por efi en caso de fallo durante el arranque del sistema.

6.- Crear script de inicio para efi /boot/efi/startup.nsh

root@archiso ~ # nano /boot/efi/startup.nsh
bcf boot add 1 fs0:\EFI\GRUB\grubx64.efi "Grub bootloader"
exit

Identificar los gráficos del sistema# lspci | grep VGA

Entorno gráfico
# pacman -S xorg-server xorg-xinit
# pacman -S xf86-video-intel
# pacman -S mesa mesa-demos

Para una computadora portátil o netbook necesita los controladores para el soporte de entrada del panel táctil
# pacman -S xf86-input-synaptics

Crear usuario
# useradd -m -g users -G audio,storage,optical,video,wheel -s /bin/bash carles

Montar las USB, Micro SD
# pacman -S gvfs

Montar iphone
# pacman -S gvfs-afc

Montar dispositivo android
# pacman -S gvfs-mtp

Crea las carpetas por defecto del usuario automáticamente
# pacman -S xdg-user-dirs

Instalar deepin
# pacman -S deepin-extra

Editar el archivo /etc/lightdm/lightdm.conf
# nano /etc/lightdm/lightdm.conf

Buscar la siguiente linea (Ctrl + W)
#greeter-session=example-gtk-gnome

Descomente y cambie como se muestra abajo
greeter-session=lightdm-deepin-greeter

Luego habilite el administrador de inicio de sesión de lightdm para que se inicie en el arranque.
# systemctl enable lightdm.service -f

El archivo .xinitrc se crea en el directorio del usuario sin privilegios
$ nano /home/carles/.xinitrc
exec startdde

Cambiar los permisos del archivo
# chown carles:users /home/carles/.xinitrc

Salir del entorno chroot
# exit

# exit

Desmontar las particiones
# umount /mnt/home
# umount /mnt/boot/efi
# umount /mnt

Reiniciar el sistema
#reboot

Instalar ifplugd. Un demonio que activa - desactiva las interfaces de red al insertar - quitar el cable.
# pacman -S ifplugd

Si hay algún problema como parpadeo o pantalla en blanco después de instalar Deepin, instalar lightdm-deepin-greeter usando el siguiente comando

# pacman -S lightdm-deepin-greeter

Y reinstalar deepin:

# pacman -Syu deepin

# reboot


Se prescinde de la partición Swap
Un portátil con 8 GB de memoria RAM y un diso duro SSD Intel de 60 GB. Los datos se guardan en el servidor de archivos de la LAN por lo que no se necesita mayor capacidad de almacenamiento.



OpenBSD es genial!.

viernes, 16 de febrero de 2018

Samba en un Servidor Centos Linux

Configuración de Samba en Centos

Protocolo SMB

SMB (Server Message Block), también llamado CIFS (Common Internet File System), es un protocolo del nivel de presentación del modelo OSI de TCP/IP creado por IBM en el año 1985.

Samba

SAMBA es un conjunto de programas originalmente creados por Andrew Tridgell y mantenidos por The Samba Team.

Instalar a través de yum

# yum -y install samba samba-client samba-common

Abrir los puertos 135 al 139 (TCP Y UDP) y el puerto 445 (TCP).

Utilizando desde la consola el mandato iptables


# ptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 135:139 -j ACCEPT

# iptables -A INPUT -m state --state NEW -m udp -p udp --dport 135:139 -j ACCEPT

# iptables -A INPUT -m state --state NEW -m tcp -p tcp --dport 445 -j ACCEPT

# service iptables save

O editar el archivo /etc/sysconfig/iptables y añadir lo siguiente

-A INPUT -m state --state NEW -m tcp -p tcp --dport 135:139 -j ACCEPT

-A INPUT -m state --state NEW -m udp -p udp --dport 135:139 -j ACCEPT

-A INPUT -m state --state NEW -m tcp -p tcp --dport 445 -j ACCEPT

# service iptables restart

SELinux y el servicio smb

Con la finalidad de que SELinux permita al servicio smb la escritura como usuario anónimo, ejecute:

# setsebool -P allow_smbd_anon_write 1

A fin de que SELinux permita al servicio smb funcionar como Controlador Primario de Dominio (PDC)

# setsebool -P samba_domain_controller 1

Para que SELinux perminta al servicio smb compartir los directorios de inicio de los usuarios locales del sistema, ejecute:

# setsebool -P samba_enable_home_dirs 1

A fin de que SELinux desactive la protección para los directorios de inicio de los usuarios a través de smb, ejecute:

# setsebool -P use_samba_home_dirs 1

Con la finalidad de que SELinux permita al servicio smb crear nuevos directorios de inicio para los usuarios a través de PAM (operación común en PDC, ejecute

# setsebool -P samba_create_home_dirs 1

Para que SELinux permita al servicio smb funcionar como un organizador de mapa de puertos (portmapper):

# setsebool -P samba_portmapper 1

Para que SELinux permita al servicio smb ejecutar guiones dentro del directorio /var/lib/samba/scripts sin confinamiento:

# setsebool -P samba_run_unconfined 1

Con el fin de que SELinux permita al servicio smb compartir todos los recursos en modo de sólo lectura:

# setsebool -P samba_export_all_rw 1

Para que SELinux perminta al servicio smb compartir todos los recursos en modo de lectura y escritura:

# setsebool -P samba_export_all_rw 1

Mandato chcon

Para definir que un directorio será compartido a través del servicio smb y que debe considerarse como contenido Samba, por ejemplo /var/samba/publico:

# chcon -t samba_share_t /var/samba/publico

Antes de configurarse en el el archivo /etc/samba/smb.conf, cada nuevo directorio que se vaya a compartir debe ser configurado como se ha descrito anteriormente.

Iniciar el servicio

# service nmb start
# service smb start

Añadir el servicio al arranque del sistema

# chkconfig nmb on
# chkconfig smb on

Después de aplicar cambios al archivo de configuración de Samba es necesario reiniciar el servicio smb

# service smb restart

El servicio nmb es el encargado de proveer el servidor de nombre para los clientes a través de NetBios sobre IP. Por tanto, debe reiniciar el servicio nmb si realiza cualquier cambio en la configuración de la opción netbios name

# service nmb restart

Alta de cuentas de usuario

Primero asigne una contraseña al usuario root (no tiene que ser la misma utilizada en el sistema).

# smbpasswd -a root

La sincronización de cuentas entre el servidor Samba y las estaciones Windows se realiza ingresando el mismo nombre de usuario y contraseña tanto en el servidor Samba como en la máquina Windows.

La mayoría de las cuentas de usuario que se utilizan para acceder a Samba no requieren acceso al intérprete de comandos del sistema, no hace falta asignar una contraseña con el mandato passwd. El intérprete de comandos quedará definido como /sbin/nologin o /bin/false para la cuenta de usuario. Esta cuenta en cuestión estará inactiva para el resto de servicios.

# useradd -s /sbin/nologin andrius
# smbpasswd -a andrius

Archivo lmhosts

Se utiliza para resolver de manera local los nombres NetBios, asociándolos con su dirección IP correspondiente. El nmbre NetBios no debe exceder los doce caracteres alfanuméricos. Como mínimo debe definirse el nombre del anfitrión del servidor Samba junto a su dirección IP.

# vi /etc/samba/lmhosts
127.0.0.1      localhost
192.168.0.1      servidor

Configuración básica del archivo smb.conf

# vi /etc/samba/smb.conf

La opción workgroup define el grupo de trabajo

workgroup = MYGROUP

Opción netbios name

Define un nombre de anfitrión distinto al detectado automáticamente. Debe ser el mismo que aparece en el archivo /etc/samba/lmhosts

netbios name = servidor

Opción server string

server string = Servidor Samba %v en %L

Opción hosts allow

En esta entrada del archivo smb.conf se pueden definir direcciones IP o redes que tendrán permiso de acceso hacia el servidor. Por tanto, una red con anfitriones con direcciones IP desde 192.168.0.1 hasta 192.168.0.254, el rango de direcciones IP definido en hosts allow será 192.168.0., (los tres primeros octetos).

Vamos a definir las redes 192.168.0.0/24, 102.168.1.0/24 y 192.168.3.0/24 como vimos con anterioridad utilizando los tres primeros octetos de la dirección IP de red, en el caso de cualquier dirección IP de la red 127.0.0.0/8 se define sólo el primer octeto de dicho segmento.

hosts allow = 127., 192.168.0., 192.168.1., 192.168.3.

Opción name resolve order

Define el orden en que se intenta de resolver los nombres NETBIOS. Primero con la información del archivo /etc/samba/lmhosts, luego el archivo /etc/hosts, a continuación de consultas en el servidor WINS y, si todo lo anterior falla, a través de la dirección IP de difusión de la red local.

name resolve order = lmhosts hosts wins bcast

Gestor de archivos Nautilus

Esta configuración es necesaria para el gestor de archivos predeterminado de Gnome, Nautilus y además que se especifique wins en el orden de resolución de nombres del archivo /etc/nsswitch.conf del anfitrión desde el cual se ejecute.

# vi /etc/nsswitch.conf

hosts:    files dns

al final agregje wins

hosts:    files dns wins

Opción remote announce

remote announce = 192.168.3.127, 192.168.1.255

Reinicie los servicios para aplicar los cambios.

# service smb restart
# service nmb restart

Compartir directorios

Crear el directorio /var/samba/publico

# mkdir -p /var/samba/publico

Cambiar el contexto de SELinux para que este directorio sea considerado como contenido Samba.

# chcon -t samba_share_t /var/samba/publico


[publico]

comment = Recurso compartido publico

path = /var/samba/publico

guest ok = yes

read only = yes

write list = andrius

directory mask = 0755

create mask = 0644

Listas de control de acceso ACL

setfacl se utiliza para cambiar los permisos en las listas de control de acceso de un archivo o directorio dado. Asignar cambiar permisos de lectura, escritura y ejecución al usuario andrius

Crear el usuario y agregarlo al grupo samba

# useradd -s /sbin/nologin andrius
# smbpasswd -a andrius
# passwd andrius

# setfacl -m u:andrius:rwX /var/samba/publico

Se utilizó X mayúscula para indicar que sólo se aplicará el bit de acceso a directorios evitando aplicar el bit de ejecución a los archivos.

getfal se utiliza para determinar los permisos establecidos en las listas de control de acceso de un archivo o directorio.

# getfacl /var/samba/publico/

getfacl: Eliminando '/' inicial en nombres de ruta absolutos

# file: var/samba/publico/

# owner: root

# group: root

user::rwx

user:andrius:rwx

group::r-x

mask::rwx

other::r-x


Estos permisos que se establecieron en la lista de control de acceso del directorio /var/samba/publico son exclusivamente para éste. Cualquier nuevo archivo o directorio creado carecerá de estos nuevos permisos. Si se desea que éstos permisos se vuelvan los predeterminados para los nuevos archivos y directorios que sean creados en lo sucesivo dentro del directorio /var/samba/publico, se ejecuta el mismo mandato setfacl, pero añadiendo la opción -d para definir que serán los permisos  predeterminados  para nuevos archivos  y directorios.

Lo anterior muestra que sólo el propietario del directorio tiene permisos de lectura, escritura y acceso. Para lograr que un usuario en particular pueda acceder también a este directorio, se ejecuta el mandato setfacl, con la opción -m para modificar la lista de control de acceso, [u,g,o]:[usuario,grupo]:[r,w,x] y la ruta del directorio como argumentos. Ejemplo:

setfacl -m u:usuario:rX /var/samba/publico

En el ejemplo anterior se utilizó X mayúscula para indicar que sólo se aplicará el bit de acceso de a directorios evitando aplicar el bit de ejecución a los archivos.

Lo mismo en notación octal

# setfacl -m u:usuario:5 /var/samba/publico

Editar el archivo /etc/samba/smb.conf y al final añada el siguiente contenido


[publico]

comment = Recurso compartido publico 

path = /var/samba/publico

guest ok = yes

read only = yes

write list = andrius

directory mask = 0755

create mask = 0644


# service smb restart

Ocultando archivos que empiezan por punto.

Los archivos cuyo nombre comienza con un punto (archivos de configuración, normalmente), como es el caso del directorio de inicio del usuario en el servidor Samba (.bash_profile, .bashrc, .bash_history entre otros) pueden ocultarse con la opción hide dot files y el valor Yes.

[homes]
    comment = Home Directories
    browseable = no
    writable = yes
    valid users = %S
    inherit acls = yes
    hide dot files = yes

Reinicie el servidor smb para que los cambios tengan efecto

# service smb restart


Montar recursos compartidos desde un cliente Linux

$ cat /etc/hosts
127.0.0.1        localhost.localdomain localhost
::1        localhost6.localdomain6 localhost6
192.168.0.1    servidor

# mkdir /mnt/publico

# mount.cifs -o username=andrius //servidor/publico /mnt/publico

Solicitará la contraseña del usuario utilizado en el servidor Samba

Password for andrius@//servidor/publico:

# mount | grep publico
//servidor/publico on /mnt/publico type cifs (rw)

Cree el archivo /etc/acreditar para hacer permanente lo anterior.

# vim /etc/acreditar

Especifique el nombre de usuario y contraseña utilizados con el recurso compartido.

username=andrius
password=password

Cambiando los permisos de acceso al archivo para que sólo el usuario root pueda ver y modificar el contenido.

# chmod 600 /etc/acreditar

# vim /etc/fstab

Este recurso será montado automáticamente en el siguiente reinicio del sistema. Agregue la siguiente línea incluyendo las opciones uid y gid

//servidor/publico /mnt/publico cifs credentials=/etc/acreditar,uid=501,gid=501 0 0

Utilizar smbclient desde Linux

Lo más práctivo y sencillo para hacer pruebas es el mandato smbclient. Permite acceder hacia cualquier servidor Samba y Windows.

# smbclient -U andrius -L servidor


Conectar un cliente Windows al servior Samba

Esta máquina está en la red 192.168.3.0/25 detrás de un firewall router Soekris y OpenBSD.






https://access.redhat.com/documentation/en-us/red_hat_enterprise_linux/7/pdf/system_administrators_guide/Red_Hat_Enterprise_Linux-7-System_Administrators_Guide-en-US.pdf

Centos es genial!.

martes, 7 de julio de 2015

Particiones gpart FreeBSD bsdtar

FreeBSD y gpart para reparticionar la particion de 364GB destinada a datos y crear dos particiones, la primera dedicada a guardar un archivo tar.gz del sistema root y la segunda de datos.

Como crear una imagen del sistema raiz completo archivo.tar.gz con bsdtar
Como restaurar el sistema raiz con bsdtar.

Enumerar las particiónes del disco para ver la configuracion actual:
# gpart show ada0


El esquema de partición actual.

/dev/ada0p1 freebsd-boot - 512G
/dev/ada0p2 freebsd-ufs - 98G
/dev/ada0p3 freebsd-swap - 4G
/dev/ada0p4 freebsd-ufs - 364G

/dev/ada0p4 es la partición a modificar.

Lo primero es hacer copia de seguridad de todos los datos al servidor con rsync.

$ rsync -avz --stats /mnt/datos/* root@192.168.1.254:/volume1/NetBackup/datos-HD-500-dell/
...
Number of files: 33,909 (reg: 24,404, dir: 9,505)
Number of created files: 33,848 (reg: 24,360, dir: 9,488)
Number of regular files transferred: 24,360
Total file size: 94,221,107,499 bytes
Total transferred file size: 94,055,122,224 bytes
Literal data: 94,055,122,224 bytes
Matched data: 0 bytes
File list size: 1,260,226
File list generation time: 0.003 seconds
File list transfer time: 0.000 seconds
Total bytes sent: 91,464,319,664
Total bytes received: 577,095

sent 91,464,319,664 bytes  received 577,095 bytes  4,876,437.33 bytes/sec
total size is 94,221,107,499  speedup is 1.03

Eliminar la partición de datos (364G):
# gpart delete -i 4 ada0

Tengo 364G libres

Crear una partición de 100G:
# gpart add -s 100G -t freebsd-ufs ada0
ada0p4 added


La siguiente partición ocupa el resto de espacio libre:
# gpart add -t freebsd-ufs ada0
ada0p5 added

/dev/ada0p5 (264G) es la partición de datos.
/dev/ada0p4 (100G) la partición donde se guardarán las imagenes de copia de seguridad del sistema raiz (tar.gz).

Por ultimo crear los sistemas de ficheros:
# newfs -U /dev/ada0p4


# newfs -U /dev/ada0p5


Poner etiquetas (label):

$ glabel label systemtar /dev/ada0p4
$ glabel label datos /dev/ada0p5

# ls /dev/label/
datos  systemtar

Montar la partición de datos:

# mkdir /mnt/datos

Cambiar los permisos del directorio /mnt/datos a un usuario sin privilegios
# chown carles /mnt/datos

# mount -t -o rw /dev/ada0p5 /mnt/datos
# chown carles /mnt/datos

 Copiar los datos con rsync desde el servidor al directorio local:
$ rsync -avz --stats root@192.168.1.254:/volume1/NetBackup/datos-HD-500-dell/ /mnt/datos/

Number of files: 33,910 (reg: 24,404, dir: 9,506)
Number of created files: 2,637 (reg: 2,560, dir: 77)
Number of regular files transferred: 2,560
Total file size: 94,221,107,499 bytes
Total transferred file size: 7,147,728,070 bytes
Literal data: 7,147,728,070 bytes
Matched data: 0 bytes
File list size: 365,294
File list generation time: 0.014 seconds
File list transfer time: 0.000 seconds
Total bytes sent: 58,503
Total bytes received: 7,151,528,689
...

Copia de seguridad con bsdtar del sistema raiz:

Iniciar el sistema en modo single user:

Pulsar la barra espaciadora para detener la cuenta atrás y luego la tecla 2 (single user)

Presionar Intro para la shell por defecto y teclee la contraseña de root si la ha implementado en su servidor.

Copia de seguridad del sistema:

En el símbolo del sistema teclear:

# fsck -p
# mount -u /
# swapon -a
# adjkerntz -i

Crear el directorio donde se guarda el archivo tar.gz
# mkdir /mnt/sysbsdtar

Montar la particion  (100G), a la que volcaremos la copia bsdtar del
sistema raiz freebsd, para recuperarlo en caso de querer volver a un estado
anterior:

# mount -t ufs -o rw /dev/ada0p4 /mnt/sysbsdtar

Cambiar al directorio raiz (particion a respaldar):
# cd /

Realizar la copia de respaldo:
# bsdtar cvfz /mnt/sysbsdtar/ada0p2-7-7-2015.tar.gz --exclude=home *

Despues de finalizar la copia desmontamos la particion:
# umount /mnt/sysbsdtar
# reboot


Restaurar la copia del sistema:

Iniciar en modo single user

Presionar Intro para la shell por defecto.

En el símbolo del sistema teclear:

# fsck -p
# mount -u /
# swapon -a
# adjkerntz -i

Formatear el sistema de ficheros a restaurar (Perdera todos los datos)
# newfs -U /dev/ada0p2

Crear el directorio
# mkdir /mnt/raiz
# mkdir /mnt/copia

Montar particiones
# mount -t ufs -o rw /dev/ada0p2 /mnt/raiz
# mount -t ufs -o ro /dev/ada0p4 /mnt/copia

# cd /mnt/raiz

Restaurar particion raiz
# bsdtar xvzf /mnt/copia/ada0p2-7-7-2015.tar.gz .

# cd /
Desmontar particion:
# umount /mnt/copia
# reboot

Unix es genial!.

viernes, 28 de febrero de 2014

Alinear particiones SSD con Gpart

Alinear particiones SSD con Gpart para optimizar el rendimiento de un disco SSD.

La utilidad gpart se utiliza para dividir los proveedores GEOM, normalmente discos


Este proceso de particinado y agregar soporte TRIM puede realizarse en el entorno gráfico durante durante la instalación de FreeBSD eligiendo particionado manual.

Tabla de partición GUID (GPT) es un estándar para la colocación de la tabla de particiones en un disco duro. Es parte del estándar EFI y Permite un tamaño de partición de 9.4 ZB y 128 slices.

Listar particiones:

$ ls /dev/da0*
/dev/da0   /dev/da0p2 /dev/da0p4 /dev/da0p6
/dev/da0p1 /dev/da0p3 /dev/da0p5

Listar la tabla de particiones:

$ gpart show da0

# gpart delete -i 1 da0
da0p1 deleted
# gpart delete -i 2 da0
da0p2 deleted
# gpart delete -i 3 da0
da0p3 deleted
# gpart delete -i 4 da0
da0p4 deleted
# gpart delete -i 5 da0
da0p5 deleted
# gpart delete -i 6 da0
da0p6 deleted

# gpart create -s gpt da0

# gpart show da0
=>  34  234441577  da0  GPT  (111G)
34  234441577 - free -  (111G)

Vamos a crear las particiones, si usted utiilza particiones separadas para usr, var y tmp deberá crearlas utilizando el mismo método:
# gpart add -s 64k -t freebsd-boot -l boot0 da0
# gpart add -s 8G -t freebsd-swap -l swap0 da0
# gpart add -t freebsd-ufs -a 4k -l root0 da0

# -- Install boot code
gpart bootcode -b /boot/pmbr -p /boot/gptboot -i 1 da0

Crear sistema de ficheros:
# newfs -U -L root /dev/da0p3
/dev/da0p3: 110377.4MB (226052832 sectors) block size 32768, fragment size 4096
using 177 cylinder groups of 626.09MB, 20035 blks, 80256 inodes.
with soft updates
super-block backups (for fsck_ffs -b #) at:
 192, 1282432, 2564672, 3846912, 5129152, 6411392, 7693632,
....

No hara falta alinear las particiones de arranque o de intercambio, ya que no cuentan con sistemas de archivos "reales". Si está utilizando particiones separadas para /var /usr /tmp deberá crearlas siguiendo el mismo método:

# gpart show da0
=>   34  234441577  da0  GPT  (111G)
34 128 1  freebsd-boot  (64k)
162  8388608  2  freebsd-swap  (4.0G)
8388770  6   - free -  (3.0k)
8388776  226052832    3  freebsd-ufs  (107G)
234441608  3  - free -  (1.5k)

Eliminar index, slice, particiones:

Eliminar particiones
$ gpart delete -i 1 da0s1

Destruir slices
$ gpart destroy da0s1

Eliminar GEOM label,
$ gpart delete -i 1 da0

Destruir GEOM label,
$ gpart destroy da0

Comprobar tabla de particioines:
$ gpart show da0

y
$ gpart list


Unix es genial!.