Páginas

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

martes, 26 de agosto de 2025

Poudriere en FreeBSD ZFS 14.2

Instalación y configuración de poudriere FreeBSD 14.2 ZFS


Referencias bibliográficas:

https://freebsdfoundation.org/wp-content/uploads/2023/11/reushling_poudrier.pdf
https://www.digitalocean.com/community/tutorials/how-to-set-up-a-poudriere-build-system-to-create-packages-for-your-freebsd-servers


Intel core i5-8350U 1.7 GHz
Procesador 4 cores
Procesador 8 hilos
RAM 16 GB
SWAP 16 GB
NVMe Pcie 4.0

ZPOOL=zroot
ZROOTFS=/poudriere
BASEFS=/usr/local/poudriere

FreeBSD 14.2-RELEASE (amd64) instalado El dataset raíz de poudriere estará en zroot/poudriere y se montará en /usr/local/poudriere

Paquetes mínimos

pkg install -y poudriere \
	       git-lite
	       vim
	       screen
	       curl
	       ca_root_nss

Crear datasets ZFS.

Ventajas: posibilidad de hacer snapshots, rollback y compression por separado

zfs create -o mountpoint=/usr/local/poudriere -o compression=lz4 zroot/poudriere
zfs create zroot/poudriere/jails
zfs create zroot/poudriere/ports
zfs create zroot/poudriere/data
zfs create zroot/poudriere/data/packages
zfs create zroot/poudriere/data/logs

Archivo /usr/local/etc/poudriere.conf

ZPOOL=zroot
ZROOTFS=/poudriere
FREEBSD_HOST=ftp://ftp.freebsd.org
RESOLV_CONF=/etc/resolv.conf
BASEFS=/usr/local/poudriere
POUDRIERE_DATA=${BASEFS}/data
USE_TMPFS=all # usa RAM + swap para las builds
DISTFILES_CACHE=/usr/ports/distfiles
CHECK_CHANGED_OPTIONS=verbose
CHECK_CHANGED_DEPS=yes
CCACHE_DIR=/var/cache/ccache
ALLOW_MAKE_JOBS_PACKAGES="pkg ccache py* rust llvm*"
PARALLEL_JOBS=8 # 8 hilos logicos

Descargar y crear la jail base (14.2-RELEASE)

poudriere jail -c -j 142amd64 -v 14.2-RELEASE -a amd64

Esto descarga sets.txz y crea un dataset zroot/poudriere/jails/142amd64

Git -

poudriere ports -c -p default -m git -U https://git.FreeBSD.org/ports.git     

poudriere ports -l

PORTSTREE METHOD    TIMESTAMP           PATH
default   git+https 2025-08-24 18:50:19 /usr/local/poudriere/ports/default
local     null      2025-08-24 16:41:27 /usr/local/poudriere/ports/default

poudriere jails -l

JAILNAME VERSION         ARCH  METHOD TIMESTAMP           PATH
142amd64 14.2-RELEASE-p5 amd64 http   2025-08-24 18:42:25 /usr/local/poudriere/jails/142amd64

Ajustes globales

Archivo /usr/local/etc/poudriere.d/make.conf

# general
DEFAULT_VERSIONS+=ssh=openssl
OPTIONS_UNSET+=DOCS NLS EXAMPLES X11 IPV6
WITH_PKGNG=yes
DISABLE_LICENSES=yes

Crear listas de paquetes

Archivo /usr/local/etc/poudriere.d/port-list.txt

security/sudo
ports-mgmt/pkg

Primer bulk build

poudriere bulk -j 142amd64 -p default -f /usr/local/etc/poudriere.d/port-list.txt

Servidor de paquetes local (nginx)

pkg install nginx
sysrc nginx_enable=YES

Archivo de configuración de nginx

$ sed -e '/^[ ]*#/d' -e '/^$/d' /usr/local/etc/nginx/nginx.conf
    
    server {
        listen       80 default;
        server_name  localhost;
	    root /usr/local/share/poudriere/html;
        
        location /data {
            alias  /usr/local/poudriere/data/logs/bulk;
            autoindex on;
        }
	
	location /packages {
		root /usr/local/poudriere/data;
		autoindex on;
	}
}

Configurar pkg en la máquina anfitriona

mkdir /usr/local/etc/pkg/repos

Archivo /usr/local/etc/pkg/repos/poudriere.conf

poudriere {
  url: "http://127.0.0.1/packages/142amd64-default/",
  enabled = yes,
  mirror_type: "http",
  signature_type: "pubkey",
  pubkey: "/usr/local/etc/poudriere/poudriere.pub",
}

Generar clave (una sola vez)

Crear el directorio donde se guardarán las claves

mkdir -p /usr/local/etc/poudriere

Generar la clave privada (4096 bits)

openssl genrsa -out /usr/local/etc/poudriere/poudriere.key 4096
chmod 600 /usr/local/etc/poudriere/poudriere.key

Extraer la clave pública

openssl rsa -in /usr/local/etc/poudriere/poudriere.key -pubout -out \
/usr/local/etc/poudriere/poudriere.pub
chmod 644 /usr/local/etc/poudriere/poudriere.pub

Asegúrarse de que poudiere la use al firmar.

Añadir esta línea al archivo /usr/local/etc/poudriere.conf

PKG_REPO_SIGNING_KEY=/usr/local/etc/poudriere/poudriere.key

El archivo /usr/local/etc/poudriere.conf queda así:

ZPOOL=zroot
ZROOTFS=/poudriere
FREEBSD_HOST=ftp://ftp.freebsd.org
RESOLV_CONF=/etc/resolv.conf
BASEFS=/usr/local/poudriere
POUDRIERE_DATA=${BASEFS}/data
USE_TMPFS=all # usa RAM + swap para las builds
DISTFILES_CACHE=/usr/ports/distfiles
CHECK_CHANGED_OPTIONS=verbose
CHECK_CHANGED_DEPS=yes
ALLOW_MAKE_JOBS_PACKAGES="pkg ccache py* rust llvm*"
PARALLEL_JOBS=8 # 8 hilos logicos
PKG_REPO_SIGNING_KEY=/usr/local/etc/poudriere/poudriere.key

Firmar el repositorio con la clave nueva

poudriere bulk -j 142amd64 -p default -f /usr/local/etc/poudriere.d/port-list.txt

Monitorear durante la compilación


poudriere status

SET PORTS JAIL BUILD STATUS  QUEUE BUILT FAIL SKIP IGNORE FETCH REMAIN TIME     LOGS
- default 142amd64 2025-08-26_08h57m21s parallel_build  3  0  0  0 0 0  3 00:00:22 \
/usr/local/poudriere/data/logs/bulk/142amd64-default/2025-08-26_08h57m21s

poudriere jail -l

JAILNAME VERSION         ARCH  METHOD TIMESTAMP           PATH
142amd64 14.2-RELEASE-p5 amd64 http   2025-08-25 23:10:54 /usr/local/poudriere/jails/142amd64

poudriere ports -l

PORTSTREE METHOD    TIMESTAMP           PATH
default   git+https 2025-08-26 08:55:04 /usr/local/poudriere/ports/default
local     null      2025-08-24 16:41:27 /usr/local/poudriere/ports/default
root@solaris:/usr/local/etc/pkg/repos# poudriere 
FreeBSD.conf        packagesite.yaml    
poudriere.conf     

Logs en tiempo real

poudriere log -f -j 142amd64 -p default 

Configurar pkg en los clientes, (o en la misma máquina), para que use la clave pública

mkdir -p /usr/local/etc/pkg/repos/
$ cat /usr/local/etc/pkg/repos/poudriere.conf
poudriere {
  url: "http://127.0.0.1/packages/142amd64-default/",
  enabled = yes,
  mirror_type: "http",
  signature_type: "pubkey",
  pubkey: "/usr/local/etc/poudriere/poudriere.pub",
}

Tras esto, pkg install validará las firmas sin errores.

Comandos útiles de rescate. Limpiar paquetes obsoletos

poudriere pkgclean -j 142amd64 -p default -f port-list.txt

Destruir jail y volver a crear (por ejemplo, tras nueva RELEASE)

poudriere jail -d -j 142amd64
poudriere jail -c -j 142amd64 -v 14.3-RELEASE -a amd64

Actualizar paquetes

pkg update -f
Updating FreeBSD repository catalogue...
Fetching meta.conf: 100%    179 B   0.2kB/s    00:01    
Fetching data.pkg: 100%   10 MiB  10.4MB/s    00:01    
Processing entries: 100%
FreeBSD repository update completed. 35669 packages processed.
Updating poudriere repository catalogue...
Fetching meta.conf: 100%    179 B   0.2kB/s    00:01    
Fetching data.pkg: 100%    2 KiB   2.0kB/s    00:01    
Processing entries: 100%
poudriere repository update completed. 3 packages processed.
All repositories are up to date.
pkg upgrade
curl -I http://127.0.0.1/
HTTP/1.1 200 OK
Server: nginx/1.28.0
Date: Tue, 26 Aug 2025 12:07:38 GMT
Content-Type: text/html
Content-Length: 13036
Last-Modified: Sat, 09 Aug 2025 09:58:45 GMT
Connection: keep-alive
ETag: "68971bd5-32ec"
Accept-Ranges: bytes

Actualizar el árbol existente (lo mantiene, solo descarga nuevos commits)

poudriere ports -u -p default

Listo para compilar y servir paquetes locales con poudriere en FreeBSD 14.2


Opciones

Poudriere no guarda automáticamente las elecciones que se hacen al ejecutar poudriere options, pero le indicamos con la bandera -z myset que lo guarde.

Ejecutar una vez poudriere options para el port que quiera

Las opciones seleccionadas se guardan en /usr/local/etc/poudriere.d/myset-options

poudriere options -z myset -c security/sudo

el flag -c fuerza que aparezca el menú incluso si ya existen opciones guardadas.


Un directorio "myset-options" es generado automaticamente por make config

/usr/local/etc/poudriere.d/myset-options/

y dentro del directorio los directorios categoria_paquete

ls /usr/local/etc/poudriere.d/myset-options
converters_libiconv/ devel_autoconf/      devel_m4/            lang_tcl86/
databases_sqlite3/   devel_kyua/          lang_lua54/          security_sudo/
devel_atf/           devel_lutok/         lang_perl5.42/

y dentro de esos directorio un archivo llamado options contiene las opciones de configuración.


cat /usr/local/etc/poudriere.d/myset-options/security_sudo/options
# This file is auto-generated by 'make config'.
# Options for sudo-1.9.17p2
_OPTIONS_READ=sudo-1.9.17p2
_FILE_COMPLETE_OPTIONS_LIST=AUDIT DISABLE_AUTH DISABLE_ROOT_SUDO DOCS EXAMPLES \
INSULTS LDAP NLS NOARGS_SHELL OPIE PAM PYTHON SSL GSSAPI_BASE GSSAPI_HEIMDAL \
GSSAPI_MIT
OPTIONS_FILE_SET+=AUDIT
OPTIONS_FILE_UNSET+=DISABLE_AUTH
OPTIONS_FILE_UNSET+=DISABLE_ROOT_SUDO
OPTIONS_FILE_UNSET+=DOCS
OPTIONS_FILE_UNSET+=EXAMPLES
OPTIONS_FILE_SET+=INSULTS
OPTIONS_FILE_UNSET+=LDAP
OPTIONS_FILE_UNSET+=NLS
OPTIONS_FILE_UNSET+=NOARGS_SHELL
OPTIONS_FILE_UNSET+=OPIE
OPTIONS_FILE_SET+=PAM
OPTIONS_FILE_UNSET+=PYTHON
OPTIONS_FILE_SET+=SSL
OPTIONS_FILE_UNSET+=GSSAPI_BASE
OPTIONS_FILE_UNSET+=GSSAPI_HEIMDAL
OPTIONS_FILE_UNSET+=GSSAPI_MIT

...

Compilar paquetes

poudriere bulk -j 142amd64 -p default -z myset -f /usr/local/etc/poudriere.d/port-list.txt

Para que pkg use los paquetes que acaba de compilar poudriere necesitas:
- Que poudriere haya terminado de firmar y publicar los paquetes.
- Un repositorio local servido por nginx (u otro)
- Un fichero /usr/local/etc/pkg/repos/poudriere.conf correctamente escrito

fichero /usr/local/etc/pkg/repos/poudriere.conf

poudriere {
  url: "http://127.0.0.1/packages/142amd64-default/",
  # url = "file:///usr/local/poudriere/data/packages/142amd64-default",
  enabled = yes,
  mirror_type: "http",
  signature_type: "pubkey",
  pubkey: "/usr/local/etc/poudriere/poudriere.pub",
}
root@solaris:/usr/local/poudriere/data/packages/142amd64-default/All# pkg repo .
Creating repository in .: 100%
Packing files for repository: 100%
root@solaris:/usr/local/poudriere/data/packages/142amd64-default/All# ls
data.pkg            meta.conf           pkg-2.2.2.pkg
data.tzst           packagesite.pkg     pkgconf-2.4.3,1.pkg
meta                packagesite.tzst    sudo-1.9.17p2.pkg

Desactivar el repositorio oficial (opcional)

#
# To disable this repository, instead of modifying or removing this file,
# create a /usr/local/etc/pkg/repos/FreeBSD.conf file:
#
#   mkdir -p /usr/local/etc/pkg/repos
#   echo "FreeBSD: { enabled: no }" > /usr/local/etc/pkg/repos/FreeBSD.conf
#

FreeBSD: {
 url: "pkg+https://pkg.FreeBSD.org/${ABI}/quarterly",
# url: "pkg+https://pkg.FreeBSD.org/${ABI}/latest",
 mirror_type: "srv",
 signature_type: "fingerprints",
 fingerprints: "/usr/share/keys/pkg",
 enabled: no
}

Otra opción. La prioridad define el orden en que se utilizan estos repositorios

Por defecto, se utiliza el repositorio upstream de FreeBSD.org. Pero como queremos que nuestros propios paquetes tengan precedencia, le daremos una prioridad más alta que cero para que use nuestro repositorio de paquetes primero.

Quedaría así:

#
# To disable this repository, instead of modifying or removing this file,
# create a /usr/local/etc/pkg/repos/FreeBSD.conf file:
#
#   mkdir -p /usr/local/etc/pkg/repos
#   echo "FreeBSD: { enabled: no }" > /usr/local/etc/pkg/repos/FreeBSD.conf
#

FreeBSD: {
 url: "pkg+https://pkg.FreeBSD.org/${ABI}/quarterly",
# url: "pkg+https://pkg.FreeBSD.org/${ABI}/latest",
 mirror_type: "srv",
 signature_type: "fingerprints",
 fingerprints: "/usr/share/keys/pkg",
 enabled: yes
}

Archivo /usr/local/etc/pkg/repos/poudriere.conf

poudriere {
  url: "http://127.0.0.1/packages/142amd64-default/",
  # url = "file:///usr/local/poudriere/data/packages/142amd64-default",
  enabled = yes,
  priority: 23,
  mirror_type: "http",
  signature_type: "pubkey",
  pubkey: "/usr/local/etc/poudriere/poudriere.pub",
}

Veamos en acción

 pkg update
Updating FreeBSD repository catalogue...
FreeBSD repository is up to date.
Updating poudriere repository catalogue...
Fetching meta.conf: 100%    179 B   0.2kB/s    00:01    
Fetching data.pkg: 100%    2 KiB   2.0kB/s    00:01    
Processing entries: 100%
poudriere repository update completed. 3 packages processed.
All repositories are up to date.
root@solaris:/usr/local/etc/pkg/repos# pkg upgrade
Updating FreeBSD repository catalogue...
FreeBSD repository is up to date.
Updating poudriere repository catalogue...
poudriere repository is up to date.
All repositories are up to date.
Checking for upgrades (206 candidates): 100%
Processing candidates (206 candidates): 100%
The following 4 package(s) will be affected (of 0 checked):

New packages to be INSTALLED:
	p5-Crypt-URandom: 0.54 [FreeBSD]

Installed packages to be UPGRADED:
	nss: 3.115 -> 3.115.1 [FreeBSD]
	p5-Authen-SASL: 2.18 -> 2.1900 [FreeBSD]
	perl5: 5.40.2_2 -> 5.40.3_2 [FreeBSD]

Number of packages to be installed: 1
Number of packages to be upgraded: 3

18 MiB to be downloaded.

Proceed with this action? [y/N]: y
[1/4] Fetching nss-3.115.1.pkg: 100%    2 MiB   2.3MB/s    00:01    
[2/4] Fetching p5-Crypt-URandom-0.54.pkg: 100%   17 KiB  17.6kB/s    00:01    
[3/4] Fetching perl5-5.40.3_2.pkg: 100%   16 MiB  16.4MB/s    00:01    
[4/4] Fetching p5-Authen-SASL-2.1900.pkg: 100%   44 KiB  44.7kB/s    00:01    
Checking integrity... done (0 conflicting)
[1/6] Deinstalling p5-Authen-SASL-2.18...
[1/6] Deleting files for p5-Authen-SASL-2.18: 100%
[2/6] Deinstalling perl5-5.40.2_2...
[2/6] Deleting files for perl5-5.40.2_2: 100%
[3/6] Upgrading nss from 3.115 to 3.115.1...
[3/6] Extracting nss-3.115.1: 100%
[4/6] Installing perl5-5.40.3_2...
[4/6] Extracting perl5-5.40.3_2: 100%
[5/6] Installing p5-Crypt-URandom-0.54...
[5/6] Extracting p5-Crypt-URandom-0.54: 100%
[6/6] Installing p5-Authen-SASL-2.1900...
[6/6] Extracting p5-Authen-SASL-2.1900: 100%
tree /usr/local/poudriere/data/packages/
/usr/local/poudriere/data/packages/
└── 142amd64-default
    ├── All -> .latest/All
    ├── Latest -> .latest/Latest
    ├── data
    ├── data.pkg -> .latest/data.pkg
    ├── data.tzst -> .latest/data.tzst
    ├── logs -> .latest/logs
    ├── meta -> .latest/meta
    ├── meta.conf -> .latest/meta.conf
    ├── packagesite.pkg -> .latest/packagesite.pkg
    ├── packagesite.tzst -> .latest/packagesite.tzst
    └── packagesite.yaml

5 directories, 8 files

Instalar paquete desde repositorio local

pkg install sudo
Updating FreeBSD repository catalogue...
FreeBSD repository is up to date.
Updating poudriere repository catalogue...
poudriere repository is up to date.
All repositories are up to date.
Checking integrity... done (0 conflicting)
The following 1 package(s) will be affected (of 0 checked):

New packages to be INSTALLED:
	sudo: 1.9.17p2 [poudriere]

Number of packages to be installed: 1

The process will require 2 MiB more space.

Proceed with this action? [y/N]: y
[1/1] Installing sudo-1.9.17p2...
[1/1] Extracting sudo-1.9.17p2: 100%
Comprobar security con INSULTS activado:
sudo vim /etc/rc.conf                 
Password:
Quizás si usaras más de dos dedos...
Password:
¡Este hombre no sabe cuándo está vencido! Tampoco sabe cuándo está ganando. 
No tiene... una especie de... aparato sensorial...
Password:
FreeBSD es genial!.

viernes, 26 de julio de 2024

Recursos Compartidos con Samba FreeBSD

Samba FreeBSD

SAMBA es un conjunto de programas originalmente creados por Andrew Tridgell y mantenidos en la actualizad por The SAMBA Team, bajo licencia Pública General GNU e implementado por sistemas basados en UNIX.

En el servidor

pkg install samba416
sysrc samba_server_enable="YES"

Crear conjunto de datos


zfs create zroot/usr/backup/dellhome
zfs create zroot/usr/backup/poolrecovery
zfs create zroot/usr/backup/publico
zfs create zroot/usr/backup/docs
zfs create zroot/usr/backup/codigo

El directorio público será propiedad del usuario y grupo nobody


chown nobody:nobody /usr/backup/publico

Archivo de configuracion

[global]
	unix charset 		= UTF-8
	workgroup 		= CORP
    	client min protocol 	= SMB3
    	server string 		= Samba Server Version %v en %L
	hosts allow 		= 127., 192.168.88., 10.10.10.
	netbios name 		= servidor
	security 		= user
    	passdb backend          = tdbsam
	load printers 		= no
    	domain master 		= yes
	guest account		= nobody
	printable		= no
	hide dot files		= yes
	log level		= 1 auth:5
	log file		= /var/log/samba/%m.log
	max log size 		= 10000
	deadtime 		= 60
	create mask 		= 0644
	directory mask 		= 0755
	map to guest 		= never
	wins support 		= yes 	 	 	
	interfaces 		= re0, 127.0.0.1, 192.168.88.160/24, 10.10.10.1/24
    bind interfaces only 	= yes 
	
[dellhome]
	comment		= FreeBSD
	path 		= /samba/dellhome
	public 		= no
	browseable 	= yes
	writeable 	= yes
	write list 	= carlos

[codigo]
	comment 	= Scripts
	path 		= /samba/codigo
	public 		= no
	read only 	= yes
	browseable 	= yes  	
	valid users 	= carlos
	write list 	= carlos

[poolrecovery]
	path 		= /samba/poolrecovery
	public 		= no
	writeable 	= yes
    	browseable	= yes
	guest ok 	= no
	valid users 	= carlos

[docs]
	comment		= Documentos
	path 		= /samba/docs
	public 		= no
	writeable 	= yes
	browseable 	= yes
    	valid users 	= @administradores

[public]
	comment		= Publico
	path		= /samba/publico
	public 		= yes
	writeable	= yes
	browseable	= yes
	guest ok	= yes

Que los permisos del sistema de archivos en /samba/publico sean seguros

chown -R nobody:nobody /samba/publico 

guest ok

Permite o no el acceso como usuario invitado, el valor puede ser Yes o No.

public

Define si se permite el acceso como usuario invitado, el valor puede ser Yes o No.

browseable

Permite o no mostrar este recurso en las listas de recursos compartidos, el valor puede ser Yes o No.

writable

Permite o no la escritura, es la opción opuesta a read only. El valor puede ser Yes o No. writable = Yes es lo mismo que read only = No y viceversa.

valid users

Define los usuarios o grupos, que podrán acceder al recurso compartido. Los valores pueden ser nombres de usuarios separados por comas o nombre de grupos precedido de @. Ejemplo: user1, user2, @contabilidad @administradores.

write list

Define que usuarios o grupos pueden acceder con permiso de escritura. Los valores pueden ser nombres de usuarios separados por comas o bien nombre de grupos precedidos de @. Ejemplo: user1, user2 , @contabilidad, @administradores.

admin users

Define usuarios o grupos que pueden acceder con permisos administrativos para el recurso. Pueden acceder realizando todas las operaciones como super-usuario. Los valores pueden ser nombres de usuarios separados por comas o bien nombre de grupos precedidos por una @. Ejemplo: user1, user2, @finanzas, @administradores.

directory mask

Define qué permisos en el sistema tendrán los subdirectorios creados dentro del recurso.

create mask

Define que permisos en el sistema tendrán los nuevos archivos creados dentro del recurso.

Iniciar el servicio SAMBA

service samba_server start

Reglas cortafuegos PF permitir tráfico samba

Como servidor es necesario abrir los puertos 137/udp, 138/udp, 139/tcp y 445/tcp

# /etc/pf.conf
...
pass in on $int_if proto { tcp, udp } from { 10.10.10.0/24, 192.168.88.0/24 } \
to $samba_ip port { 139, 445 }
pass in on $int_if proto udp from { 10.10.10.0/24, 192.168.88.0/24 } \
to $samba_ip port { 137, 138 }
...

Agregar usuario carlos a Samba

pdbedit -a carlos
new password:
retype new password

Activar acceso al usuario carlos

smbpasswd -e carlos
New SMB password:
Retype new SMB passwd:
Added user carlos

Reiniciar SAMBA

service samba_server restart

Conectar a un recurso compartido desde un cliente FreeBSD


Podemos usar indistintamente tanto la dirección IP del servidor FreeBSD como su nombre

cat /etc/hosts | grep tormenta
---
192.168.88.160   	tormenta
---

smbclient es parte de Samba, por tanto, es necesario instalar Samba

pkg install samba416

Debe existir el archivo smb4.conf de lo contrario smbclient falla:

smbclient: Can't load /usr/local/etc/smb4.conf - run testparm to debug it

touch /usr/local/etc/smb4.conf
echo "workgroup = CORP">/usr/local/etc/smb4.conf
echo "client min protocol = NT1">>/usr/local/etc/smb4.conf

Listar recursos compartidos por el servidor Samba

» smbclient -L tormenta
Password for [CORP\carlos]:

	Sharename       Type      Comment
	---------       ----      -------
	dellhome        Disk	  FreeBSD
	codigo          Disk      Scripts
	poolrecovery    Disk
	docs            Disk
	public          Disk      Permitido
	IPC$            IPC       IPC Service (Samba Server Version 4.16.11 en SERVIDOR)
Reconnecting with SMB1 for workgroup listing.

	Server               Comment
	---------            -------
	servidor	     Samba Server Version 4.16.11 en SERVIDOR
                         
	Workgroup            Master
	---------            -------
	CORP                 SERVIDOR

Conectar a un recurso compartido


$ smbclient -U carlos //192.168.88.160/dellhome
smb: \>

Las conexiones Samba actuales

root@tormenta: # smbstatus

Samba version 4.16.11
PID     Username   Group        Machine     Protocol Version  Encryption     Signing
--------------------------------------------------------------------------------------------------------
22653   carlos  carlos  192.168.88.51 (ipv4:192.168.88.51:39769)  SMB3_11  partial(AES-128-GMAC)
22472   nobody  nobody  192.168.88.51 (ipv4:192.168.88.51:21993)  SMB3_11      -         -

Service      pid     Machine       Connected at                   Encryption Signing
---------------------------------------------------------------------------------------------
IPC$         25576   solaris        Sun Jul 28 21:04:52 2024 CEST    -            -
public       22472   192.168.88.51  Sun Jul 28 10:48:09 2024 CEST    -            -
docs         22653   192.168.88.51  Sun Jul 28 11:17:03 2024 CEST    -            -
dellhome     61262   macbook-pro    Mon Jul 29 08:39:57 2024 CEST    -            -

No locked files

Listar sockets abiertos IPv4

root@tormenta: # sockstat -4
USER     COMMAND    PID   FD PROTO  LOCAL ADDRESS         FOREIGN ADDRESS
root     smbd       22653 34 tcp4   192.168.88.160:445    192.168.88.51:39769
carlos   sshd       22630 4  tcp4   192.168.88.160:22     192.168.88.51:42658
root     sshd       22628 4  tcp4   192.168.88.160:22     192.168.88.51:42658
root     smbd       22472 34 tcp4   192.168.88.160:445    192.168.88.51:21993
root     smbd       22478 34 tcp4   192.168.88.160:445    192.168.88.135:21996
root     smbd       13189 29 tcp4   127.0.0.1:445         *:*
root     smbd       13189 30 tcp4   127.0.0.1:139         *:*
root     smbd       13189 31 tcp4   192.168.88.160:445    *:*
root     smbd       13189 32 tcp4   192.168.88.160:139    *:*
root     nmbd       13182 16 udp4   *:137                 *:*
root     nmbd       13182 17 udp4   *:138                 *:*
root     nmbd       13182 18 udp4   192.168.88.160:137    *:*
root     nmbd       13182 19 udp4   192.168.88.255:137    *:*
root     nmbd       13182 20 udp4   192.168.88.160:138    *:*
root     nmbd       13182 21 udp4   192.168.88.255:138    *:*
root     sshd       92484 5  tcp4   *:22                  *:*
...

Conectar a un recurso compartido desde un cliente FreeBSD

Conectar a un recurso compartido desde un cliente MacOS

FreeBSD es genial!.

jueves, 26 de octubre de 2023

NFSv4 FreeBSD 14.2

NFSv4 - NFS Version 4 Protocol FreeBSD 14.2

Como administrador de un servidor NFS, puede configurarlo para que sólo admita NFSv4, lo que minimiza el número de puertos abiertos y servicios en ejecución en el sistema.

Opcionalmente, también puede deshabilitar la escucha de las llamadas de protocolo RPCBIND, MOUNT, y NSM, que no son necesarias en el caso de sólo NFSv4.

En este momento, es posible habilitar NFSv3 y/o NFSv4 sobre TCP, pero no NFSv3 sobre UDP, de todas maneras, NFSv3 sobre UDP está en desuso. Esto significa que la opción "-u" No se puede especificar para nfs_server_flags en el archivo /etc/rc.conf.

sharenfs=off|on Controla si el sistema de archivos se comparte a través de NFS y que acciones van a ser utilzadas. Un sistema de archivos con una sharenfs=off es administrado con el comando exportfs y entradas en el archivo /etc/exports. Por ejemplo

zfs get sharenfs zroot/usr/backup/dellhome
NAME                       PROPERTY  VALUE     SOURCE
zroot/usr/backup/dellhome  sharenfs  off       local

El archivo exports especifica puntos de montaje remotos para el protocolo NFS. Cada linea especifica el punto de montaje e indicadores de exportacion dentro de un sistema de archivos del servidor local o la raiz del arbol NFSv4 para uno o mas hosts.

En el servidor NFSv4 archivo /etc/rc.conf

sysrc nfs_server_enable="YES"
sysrc nfsv4_server_enable="YES"
sysrc nfs_server_flags="-u -t -n 24"
sysrc hostid_enable="YES"
sysrc hostid_file="/etc/hostid"
sysrc rpcbind_enable="YES"
sysrc rpcbind_flags="-h 192.168.88.160"
sysrc mountd_enable="YES"
sysrc mountd_flags="-r -p 892"
sysrc statd_flags="-p 32766"
sysrc lockd_flags="-p 32767"

Iniciar servicio hostid

service hostid start

Parametros des sysctl (/etc/sysctl.conf)

sysctl vfs.nfs.enable_uidtostring="1"      # Hacer que NFS siempre envíe nombres de propietario numéricos
sysctl vfs.nfsd.enable_stringtouid="1"     # Habilitar nfsd para aceptar nombres de propietario numéricos
sysctl vfs.nfsd.server_max_nfsvers="4"     # Fuerza NFSv4 max
sysctl vfs.nfsd.server_min_nfsvers="4"     # Fuerza NFSv4 min
sysctl vfs.nfsd.issue_delegations="1"      # Habilita delegaciones (mejora rendimiento)
sysctl vfs.nfsd.enable_locallocks="1"      # Bloqueos locales (compatible con ZFS)
sysctl kern.ipc.somaxconn="1024"           # Max conexciones pendientes (por defecto 128)
sysctl net.inet.tcp.delayed_ack="0"        # Mejora rendimiento TCP

Hacer que los cambios sean permanentes

echo vfs.nfs.enable_uidtostring="1" >> /etc/sysctl.conf
echo vfs.nfsd.enable_stringtouid="1" >> /etc/sysctl.conf
echo vfs.nfsd.server_max_nfsvers="4" >> /etc/sysctl.conf
echo vfs.nfsd.server_min_nfsvers="4" >> /etc/sysctl.conf
echo vfs.nfsd.issue_delegations="1" >> /etc/sysctl.conf
echo vfs.nfsd.enable_locallocks="1" >> /etc/sysctl.conf
echo kern.ipc.somaxconn="1024" >> /etc/sysctl.conf
echo net.inet.tcp.delayed_ack="0" >> /etc/sysctl.conf

Usamos el archivo /etc/hosts como resolución de nombres en la red local

...
192.168.88.160		tormenta
192.168.88.51		solaris
...

Configurar PF para permitir el tráfico NFS

...
lan_net ="{ 192.168.88.0/24 10.10.10.0/24 }"
nfs_puertos="{ 111, 892, 2049 }"
statd_lockd_puertos="{ 32766, 32767 }"

pass in proto { tcp } from $lan_net to any port ssh
pass in proto { tcp udp } from $lan_net to any port $statd_lockd_puertos
pass in proto { tcp udp } from $lan_net to any port $samba_puertos
pass in quick proto { tcp udp } from $lan_net to any port $nfs_puertos
...

Reiniciar servicios

tormenta: # service nfsd restart
Stopping nfsd.
Waiting for PIDS: 1391 1394.
Starting nfsd.

tormenta: # service rpcbind restart
Stopping rpcbind.
Waiting for PIDS: 1285.
Starting rpcbind.

tormenta: # service mountd restart
Stopping mountd.
Waiting for PIDS: 1382.
Starting mountd.

Crear los conjunto de datos en el servidor

zfs create -o mountpoint=/nfsv4/dellhome -p zroot/nfsv4/dellhome
zfs create -o mountpoint=/nfsv4/poolrecovery -p zroot/nfsv4/poolrecovery
zfs create -o mountpoint=/nfsv4/docs -p zroot/nfsv4/docs
zfs create -o mountpoint=/nfsv4/desarrollo -p zroot/nfsv4/desarrollo
zfs create -o mountpoint=/nfsv4/confsolaris -p zroot/nfsv4/confsolaris
zfs create -o mountpoint=/nfsv4/conftormenta -p zroot/nfsv4/conftormenta

Archivo de ejemplo /etc/exports, directorios compartidos en redes LAN

tormenta: # cat /etc/exports
V4: /nfsv4 # Define /nfsv4 como raiz global
/nfsv4/dellhome -alldirs -network 192.168.88.0/24,10.10.10.0/24
/nfsv4/poolrecovery -alldirs -maproot=root -network 192.168.88.0/24
/nfsv4/docs -alldirs -maproot=root -network 192.168.88.0/24,10.10.10.0/24
/nfsv4/desarrollo -alldirs -maproot=root -network 192.168.88.0/24
/nfsv4/confsolaris -alldirs -maproot=root -network 192.168.88.0/24
/nfsv4/conftormenta -alldirs -maproot=root -network 192.168.88.0/24

Puertos a la escucha (en el servidor)

root@tormenta:~ # netstat -an | grep -i listen     
tcp6       0      0 *.2049                 *.*                    LISTEN     
tcp4       0      0 *.2049                 *.*                    LISTEN     
tcp4       0      0 *.892                  *.*                    LISTEN     
tcp6       0      0 *.892                  *.*                    LISTEN          
tcp4       0      0 *.111                  *.*                    LISTEN     
tcp6       0      0 *.111                  *.*                    LISTEN 
carlos@tormenta:~ % sockstat -l4 | grep -E 'nfsd|rpcbind|mountd'
root     nfsd        1391 5   tcp4   *:2049                *:*
root     mountd      1382 8   udp4   *:892                 *:*
root     mountd      1382 9   tcp4   *:892                 *:*
root     rpcbind     1285 9   udp4   *:111                 *:*
root     rpcbind     1285 10  udp4   *:898                 *:*
root     rpcbind     1285 11  tcp4   *:111                 *:*

Programar mantenimiento

# crontab -e
@daily /sbin/service mountd reload
@daily /sbin/service nfsd restart

Logs de errorres:

 tail /var/log/messages | grep nfs

Capturar tráfico NFS:

 tcpdump -i re0 port 2049 -w nfs-captura.pcap

Leer paquetes capturados del archivo nfs-captura.pcap

root@tormenta:~ # tcpdump -r nfs-captura.pcap
...
21:14:42.658371 IP solaris.960 > tormenta.nfsd: Flags [P.], seq 976297794:976297922, \
ack 2292617495, win 4352, options [nop,nop,TS val 2858673986 ecr 2537679775], length 128: \
NFS request xid 755722369 124 getattr fh 0,5/2
21:14:42.658440 IP tormenta.nfsd > solaris.960: Flags [.], ack 128, win 29128, options \
[nop,nop,TS val 2537739395 ecr 2858673986], length 0
21:14:42.658497 IP tormenta.nfsd > solaris.960: Flags [P.], seq 1:93, ack 128, win 29128, \
options [nop,nop,TS val 2537739395 ecr 2858673986], length 92: NFS reply xid 755722369 \
reply ok 88 getattr LNK 12231267145 ids 1/53 sz 0
21:14:42.658797 IP solaris.960 > tormenta.nfsd: Flags [.], ack 93, win 4352, options \
[nop,nop,TS val 2858673987 ecr 2537739395], length 0
...

Configurar cliente FreeBSD

cat /etc/hosts...
192.168.88.160		tormenta
192.168.88.51		solaris
...

Para que el servicion nfs client se inicie con el sistema

solaris:~ # sysrc nfs_client_enable=YES
solaris:~ # sysrc nfsv4_client_enable="YES"
solaris:~ # sysrc hostid_enable="YES"
solaris:~ # sysrc hostid_file="/etc/hostid"
solaris:~ # sysrc rpc_statd_enable="YES"
solaris:~ # sysrc rpc_lockd_enable="YES"

Iniciar servicio hostid

service hostid start

Iniciar el servicio nfsclient

solaris:~ # service nfsclient start
NFS access cache time=60
solaris:~ nc -v tormenta 2049
  Connection to tormenta 2049 port [tcp/nfsd] succeeded!
solaris:~ nc -v tormenta 111
Connection to tormenta 111 port [tcp/sunrpc] succeeded!

Montar manualmente un directorio compartido (en el cliente)

solaris:~ # mkdir /mids4
# mount -t nfs -o nfsv4 tormenta:/docs /mids4

Archivo /etc/fstab para un montaje permanente y automático

# Device	Mountpoint	FStype	Options		Dump	Pass#
/dev/gpt/efiboot0	/boot/efi	msdosfs	rw		2	2
/dev/nvd0p3	 none	  	swap	sw			0	0
# 
fdesc		/dev/fd			fdescfs	rw		0	0
#
proc			/proc		procfs	rw		0	0
# nfsv4 shared
tormenta:/poolrecovery     /nisc4    nfs     rw,nfsv4,noatime,bg    0  0
tormenta:/development      /nixs4    nfs     rw,nfsv4,noatime,bg    0  0
tormenta:/docs             /nids4    nfs     rw,nfsv4,noatime,bg    0  0
tormenta:/dellhome 	   /nihs4    nfs     ro,nfsv4,noatime,bg    0  0

Archivo /etc/auto_master

cat /etc/auto_master
#
# Automounter master map, see auto_master(5) for details.
#
/net		-hosts		-nobrowse,nosuid,intr

Configurar el montaje automatico para montar dinámicamente cuando alguien acceda al recurso compartido NFS.

echo 'autofs_enable="YES"' >> /etc/rc.conf
service automountd start

Vamos a comprobar que podemos escribir en el directorio

 cd /nids4
 vim script-while-files.sh 
#!/bin/sh
i=0
while [ $i -le 10 ]
do
	 echo 'creando archivos con contenido'
	i=$(($i+1))
	echo Hola > "file$i.txt"
done
:wq

 chmod +x script-while-files.sh
 ./script-while-files.sh
 ls
 file3.txt             file8.txt
file1.txt             file4.txt             file9.txt
file10.txt            file5.txt             script-while-files.sh
file11.txt            file6.txt
file2.txt             file7.txt

solaris:~ % mount

...
map -hosts on /net (autofs)
tormenta:/poolrecovery on /nisc4 (nfs, nfsv4acls)
tormenta:/dellhome on /nihs4 (nfs, read-only, nfsv4acls)
tormenta:/docs on /nids4 (nfs, nfsv4acls)
tormenta:/development on /nics4 (nfs, nfsv4acls)
...

Verificar PF y reglas en tiempo real

 pfctl -f /etc/pf.conf
 pfctl -s rules
FreeBSD es genial!.

lunes, 20 de febrero de 2023

Gestión de Jails con Bastille FreeBSD

Jails con Bastille FreeBSD

https://docs.freebsd.org/en/books/handbook/jails/
https://bastille.readthedocs.io/en/latest/

1.- Creación de la Jail www con Bastille

2.- Instalar Apache MySQL PHP

3.- Instalar Wordpress. Activar rdr en Firewall PF

Información sobre el sistema


% uname -mrs
FreeBSD 13.1-RELEASE-p6 amd64

La virtualización es algo así como un entorno cliente-servidor. El hardware y su instancia central del sistema operativo es el host, mientras que los clientes son instancias virtualizadas del sistema operativo. Una jail contiene una zona de usuario completa del sistema operativo que se ejecuta sobre un sistema FreeBSD existente. La jail no tiene su propio kernel, en cambio, se ejecuta en una porción restringida del kernel del host.

Un sistema enjaulado sólo puede acceder a una parte limitada del sistema de archivos y no puede ver procesos fuera de la jaula. A cada jaula se le asigna una dirección IP dedicada, y la jaula sólo puede ver el tráfico a esa IP en particular. Cada jaula necesita un directorio raíz dedicado

La cuenta root en una jaula controla completamente esa jaula pero no tiene acceso a nada más allá de la jaula, está confinado. El usuario puede instalar el software que desee sin interferir con el sistema anfitrión ni con otras jaulas.



Bastille es un gestor de jails escrito en Bourne Shell.


Soporta ZFS
VNET
Automatización de jails por medio de templates
Control de recursos (rctl)
Firewall dinámico - redirección dinámica de puertos, etc.
La red interna de la jail hará nat a través de PF

El comando ping está deshabilitado dentro de los contenedores, porque el acceso sin procesar al socket es un agujero de seguridad. En su lugar, se puede instalar y probar con wget.


 pkg install bastille

Habilitar las opciones para utilizar ZFS en bastille


 sysrc -f /usr/local/etc/bastille/bastille.conf bastille_zfs_enable=YES
 sysrc -f /usr/local/etc/bastille/bastille.conf bastille_zfs_zpool=zroot

Activar bastille


 sysrc bastille_enable=YES

Iniciar bastille


service bastille start

Descargar los ficheros base de la última versión de FreeBSD que vamos a utilizar y aplicar parches de seguridad.


# bastille bootstrap 13.1-RELEASE update

Bucle invertido bastille0

loopback (bastille0)

Crear una interfaz loopback clonada (bastille0) y asignar direcciones privadas (rfc1918) a todos las jails en esa interfaz. Se puede usar cualquier dirección dentro de ese rango porque hemos creado nuestra propia red privada.

Desde el sistema host el cortafuegos (PF), permite y deniega tráfico. Con esta configuración los contenedores se mantienen fuera de la red, hasta que se permita el acceso.

El NAT del cortafuegos del sistema saca el tráfico de los contenedores y puede redirigir selectivamente el tráfico a los contenedores en función de los puertos de conexión (es decir, 80, 443, etc.)

Crear la interfaz loopback


 sysrc cloned_interfaces+=lo1
 sysrc ifconfig_lo1_name="bastille0"

Aplicar la configuración


 service netif cloneup

PF es una herramienta de manipulacion TCP/IP

Permitir conexiones SSH


$ cat /etc/pf.conf
#
ext_if="em0"

set skip on lo
set block-policy return
scrub in on $ext_if all fragment reassemble

table <jails> persist
nat on $ext_if from <jails> to any -> ($ext_if:0)
rdr-anchor "rdr/*"

block in all
pass out quick keep state
antispoof for $ext_if inet

pass in inet proto tcp from any to any port ssh flags S/SA keep state

Habilitar PF


# sysrc pf_enable=YES

Iniciar PF


 service pf start

Consultar las reglas de PF

pfctl -sr

scrub in on em0 all fragment reassemble
block return in all
pass out quick all flags S/SA keep state
block drop in on ! em0 inet from 192.168.88.0/24 to any
block drop in inet from 192.168.88.51 to any
pass in inet proto tcp from any to any port = ssh flags S/SA keep state

Crear la jail www y asignarle la dirección IP 10.10.10.2


bastille create www 13.1-RELEASE 10.10.10.2
Valid: (10.10.10.2).
...
Creating a thinjail...

Listar las jails


solaris: # bastille list
 JID             IP Address      Hostname       Path
 www             10.10.10.2      www            /usr/local/bastille/jails/www/root

Entrar en la jail www para ver su dirección IP


 bastille console www
[www]:
root@www:~ #
root@www:~ # uname -mrs
FreeBSD 13.1-RELEASE-p6 amd64

Ejecutar ifconfig



Crear un usuario no privilegiado para Habilitar conexiones SSH desde el host

Entrar en la jail


 bastille console www
 root@www:~ # adduser
 ...
SSH Secure Shell

Salir de la jail


root@www:~ # exit
logout

Habilitar e iniciar el servicio SSH en la jail


 bastille sysrc www sshd_enable=YES
 bastille service www sshd start

Establecer el Port 23 y la ListenAddress 10.10.10.2 en el archivo de configuración /etc/ssh/sshd_config


Port 23
ListenAddress 10.10.10.2

Reiniciar el servicio


 service sshd restart

Se puede saber si el socket está a la escucha ejecutando

bastille cmd www sockstat -4


[www]:
USER     COMMAND    PID   FD PROTO  LOCAL ADDRESS         FOREIGN ADDRESS
root     sshd       55610 3  tcp4   10.10.10.2:23         *:*
[www]: 0

También podemos entrar en la jail y lanzar el comando nc localhost 23


 bastille console www
root@www:~ # nc localhost 23 SSH-2.0-OpenSSH_8.8 FreeBSD-20211221

SSH le permite generar una huella digital de clave, que es una representación mucho más corta de una clave. No puedes encriptar el tráfico o negociar con la huella dactilar. Para generar una huella de clave pública, introduzca el comando ssh-keygen -lf keyfile.pub.


root@www:~ # ssh-keygen -lf /etc/ssh/ssh_host_rsa_key.pub

Salir de la jail


root@www:~ # exit
logout

En el host agregar al archivo .ssh/config los datos de conexión


carlos@solaris:~ cat .ssh/config
Host www
    HostName 10.10.10.2
    User carlos
    Port 23
    AddressFamily inet
    BindInterface em0
    IdentityFile ~/.ssh/id_rsa

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

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

    CheckHostIP yes

Entrar a la jail www a través de SSH


carlos@solaris:~/.ssh % ssh www
The authenticity of host '[10.10.10.2]:23 ([10.10.10.2]:23)' can't be established.
ED25519 key fingerprint is SHA256:KEnjnUTz7FPyq2c+ZcEzKvu+s5diszqxff+DmFJ+0sI.
No matching host key fingerprint found in DNS.
This host key is known by the following other names/addresses:
    ~/.ssh/known_hosts:45: www
Are you sure you want to continue connecting (yes/no/[fingerprint])? yes
Warning: Permanently added '[10.10.10.2]:23' (ED25519) to the list of known hosts.

Dentro de la jail www


carlos@www:~ $

Cambiar al usuario root


carlos@www:~ $ su
root@www: #

Instalar wget para comprobar que tenemos acceso a Internet


 pkg install wget
The package management tool is not yet installed on your system.
Do you want to fetch and install it now? [y/N]: y

En este punto tenemos la jail instalada y con conexion a Internet.

Detener la jail


bastille stop www

Iniciar la jail


bastille start www

[www]:
www: created

Archivos de configuracion de Bastille jails


ls /usr/local/bastille/jails/www
fstab     jail.conf root

Archivo jails.conf de bastille


# cat /usr/local/bastille/jails.conf
www {
  devfs_ruleset = 4;
  enforce_statfs = 2;
  exec.clean;
  exec.consolelog = /var/log/bastille/www_console.log;
  exec.start = '/bin/sh /etc/rc';
  exec.stop = '/bin/sh /etc/rc.shutdown';
  host.hostname = www;
  mount.devfs;
  mount.fstab = /usr/local/bastille/jails/www/fstab;
  path = /usr/local/bastille/jails/www/root;
  securelevel = 2;

  interface = bastille0;
  ip4.addr = 10.10.10.2;
  ip6 = disable;
}
FreeBSD es genial!.

martes, 17 de enero de 2023

Montar Directorios Usando SSHFS en FreeBSD 13.1

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

Envío y recepción de datos ZFS

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

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

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

solaris:~/bsdfetch-main % ./bsdfetch


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

Archivo config ssh (cliente)



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

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

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

        CheckHostIP yes

Entrar vía ssh al servidor.



tormenta % ./bsdfetch


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

tormenta:~ % uname -a


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

solaris:~ % uname -a


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

Red cableada


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

Crear un conjunto de datos en solaris (cliente)


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

Instalar sshfs (servidor)


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

 pkg install fusefs-sshfs

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


 sysrc ssh_enable=YES

Tener el mismo usuario en ambos sistemas

Crear conjunto de datos en el cliente


 solaris: # zfs create zroot/usr/tormentabck

Montar directorio en el servidor


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

Realizar comprobación


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

Crear una instantánea recursiva en el servidor


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

Enviar el conjunto de datos al cliente (solaris)


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

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


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

Desmontar el directorio


sudo umount /mnt/solaris/

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


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

FreeBSD es genial!.

lunes, 19 de diciembre de 2022

Tamaño de la fuente en el framebuffer de arranque FreeBSD

En partátiles con pantalla de 13 y 14 pulgadas se hace difícil leer los mensajes en el framebuffer de arranque en FreeBSD por la configuración predeterminada del tamaño de la fuente en FreeBSD.

Pero es posible cambiar a una fuente más pequeña modificando el parámetro screen.font en archivo /boot/loader.conf. Es cuestión de probar diferentes configuraciones para saber cual resulta más comoda. En mi caso he optado por 8x16.

$ cat /boot/loader.conf | grep screen.font


FreeBSD es genial!.

domingo, 18 de diciembre de 2022

Replicar, Recuperar Pool Root FreeBSD ZFS

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

Contruir o reconstruir un sistema a partir de instantáneas (snapshot)

Replicar instantáneas en otro sistema es una característica de OpenZFS que mejora la administración de datos, proporciona un mecanismo para manejar una falla de hardware con una pérdida de datos y un tiempo de inactividad mínimos. La replicación también es una forma conveniente de transferir una copia de un sistema existente a otro, por ejemplo, implementar un laboratorio completo de sistemas similares.

Escenario

Servidor: tormenta FreeBSD 13.1 NUC 11 Essential DDR4-2933 CPU 4 \
          32GB RAM M.2 NVMe PCIe 3.0
Cliente: solaris FreeBSD 13.1 Dell Latitude 7390 DDR4-2400 CPU 8 \
          16GB RAM M.2 NVMe PCIe 3.0

Enviar una copia de seguridad al servidor vía ssh utilizando zfs send receive

% cat /etc/hosts | grep tormenta
...
192.168.88.160          tormenta
...

Configurar acceso SSH

OpenZFS utiliza SSH para cifrar la replicación durante la transferencia de red.

Puede generar un par de claves con ssh-keygen y luego enviar una copia de la clave pública al servidor. Presione enter en todas las indicaciones para aceptar los valores predeterminados y no solicitar una frase de contraseña.

Dado que root enviará la replica, cambie esta línea en el archivo de configuración del demonio SSH /etc/ssh/sshd_config

#PermitRootLogin no

a

PermitRootLogin yes

Recargar la configuración del demonio SSH

service sshd reload

Enviar una copia de la clave pública al sistema recector (tormenta)

cat ~/.ssh/id_rsa.pub | ssh 192.168.88.160 'cat >>.ssh/authorized_keys' 
Password for root@192.168.88.160: 
exit

Crear un conjunto de datos para almacenar las instatáneas replicadas /usr/backup/poolrecovery.

tormenta # zfs create -p zroot/usr/backup/poolrecovery

Creamos la instantánea recursiva del conjunto de datos del pool zroot que incluye los sistemas de archivos secundarios

solaris # zfs snapshot -r zroot@zroot.snap1_dell

Comprobar los recursos compartidos por el servidor tormenta

solaris % showmount -e tormenta
Exports list on tormenta:
...
/usr/backup/poolrecovery        192.168.88.0 
...

Montar el recurso compartido

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

Enviar la instantánea de forma recursiva, redirigimos (como archivo comprimido .gz) a la ubicación compartida para poder acceder a esta ubicación al construir el cliente

# zfs send -Rv zroot@snap1_dell | gzip > /mnt/zroot.snap1.gz

Enviar a un sistema que se encuentra en otra ubicación geografica a través de una conexión ssh

zfs send -Rv zroot@snap-20241125 | ssh root@185.166.84.138 "gzip > \ 
/export/recovery/solaris/zroot@snap-solaris-20241125.gz"

Enviar al servidor de la red local a través de una conexión ssh

zfs send -Rv zroot@snap-20241125 | ssh root@192.168.88.160 "gzip > \ 
/export/recovery/solaris/zroot@snap-solaris-20241125.gz"

Proceso de recuperación

Asumimos que ha realizado una instalación limpia en el sistema a restaurar eligiendo el particionado auto ZFS en el instalador FreeBSD.

Iniciar con una memoria usb que contenga una img de FreeBSD 13.1 (misma RELEASE usada en la instalación del sistema a recuperar)

En la pantalla de instalacion

Install Shell Live cd

Elegir (live cd)

login: root

Intro (no necesita contrasena)

Iniciar la red con el comando

dhclient em0

Ver información de la conexión

# ifconfig

Comprobar conectividad

# ping freebsd.org

Configurar ssh

configurar un sshd único para esta sesión.

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

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

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

# passwd root

Importar el zpool

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

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

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

nfs_client_enable
# service nfsclient start
NFS access cache time=60

Montar recurso compartido NFS

# mount -o soft,intr,rw 192.168.88.51:/usr/backup/poolrecovery /mnt
ls /mnt/
zroot.snap1.gz 

Ya tenemos el archivo que utilizaremos

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

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

Establecer el sistema de archivos de arranque

zpool set bootfs=zroot/ROOT/default zroot

Exportar zroot

# zpool export zroot

Reiniciar el sistema

# reboot

Sí, ha funcionado

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

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

Permisos para el envío de instantáneas

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

Permisos para la recepción de instantáneas

 zfs allow -u carlos create,destroy,mount,mountpoint,quota,receive,send,\
 snapdir zroot
FreeBSD es genial!.

Beadm ZFS Boot Environments FreeBSD

Desarrollador: vermaden

https://vermaden.wordpress.com/2022/03/14/zfs-boot-environments-revolutions/comment-page-1/

Instalar beadm


pkg install -y beadm

Listar entornos de arranque


beadm list
BE                     Active Mountpoint  Space Created
default                -      -            2.0M 2022-12-15 12:19
pkg_update_171222      -      -            7.0G 2022-12-17 21:49

# beadm create pkg_upgrade_1712222335

Activar el be


# beadm activate pkg_upgrade_1712222335
Activated successfully

Listar boot environments


BE                     Active Mountpoint  Space Created
default                N      -            2.0M 2022-12-15 12:19
pkg_update_171222      -      -            7.0G 2022-12-17 21:49
pkg_upgrade_1712222335 R     /           34.2G 2022-12-17 23:35

N = activo ahora
R = estara activo el proximo reinicio

Reiniciar


# reboot

beadm list
BE                     Active Mountpoint  Space Created
default                -      -            2.0M 2022-12-15 12:19
pkg_update_171222      -      -            7.0G 2022-12-17 21:49
pkg_upgrade_1712222335 NR     /           34.2G 2022-12-17 23:35

mount
zroot/ROOT/pkg_upgrade_1712222335 on / (zfs, local, noatime, nfsv4acls)

Ya puede instalar los ultimos parches de FreeBSD sin estropear su sistema predeterminado.


pkg update
pkg upgrade
freebsd-update fetch
freebsd-update install

reroot reroot Utiliza la función 'reroot' del comando reboot(8) -r.

reroot sólo está presente en beadm, le dira a freebsd que vuelva a rootear su nucleo en ejecucion en el be especificado. Ahorra mucho tiempo en un un servidor o máquina física.


beadm reroot pkg_upgrade_1712202335

Genial

beadm


sage:
beadm activate <
  beadm create 
  beadm create 
  beadm destroy 
  beadm export 
  beadm import
  beadm list 
  beadm rename 
  beadm mount 
  beadm 
  beadm chroot 
  beadm 
  beadm version
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!