Docker Swarm: NFS cifrado con WireGuard y snapshots automáticos
La persistencia de datos en un clúster de Docker Swarm es, sin lugar a dudas, uno de los desafíos más críticos que enfrenta cualquier administrador de sistemas. Si bien Docker Swarm ofrece volúmenes locales y plugins de terceros, la solución más flexible y económica para entornos on-premise suele ser un servidor NFS. Sin embargo, el tráfico NFS viaja en claro por la red, y un clúster multi-nodo sin cifrado es un riesgo de seguridad difícil de justificar. En este artículo, exploraremos una arquitectura robusta que combina la potencia de Docker Swarm con un sistema de archivos NFS montado a través de una red privada cifrada con WireGuard, y añadiremos una capa de protección mediante respaldos snapshot automáticos.
Arquitectura de referencia: el nodo de almacenamiento
Imaginemos un escenario típico: tres nodos trabajadores ejecutan servicios, y un cuarto nodo dedicado actúa como servidor de almacenamiento. Este servidor exporta un directorio vía NFS. Para evitar que el tráfico NFS sea interceptado, utilizaremos WireGuard para crear una red mesh privada entre todos los nodos. WireGuard es increíblemente rápido, con una huella de código mínima comparado con IPsec u OpenVPN, y su integración con el kernel Linux lo hace ideal para producción.
La clave aquí es que el volumen NFS se montará sobre la interfaz wg0, no sobre la interfaz física. De esta manera, todo el tráfico de bloqueo de archivos y lectura/escritura viaja dentro de un túnel cifrado con criptografía moderna (ChaCha20Poly1305).
Configuración del túnel WireGuard en el nodo de almacenamiento
Primero, instalamos WireGuard y generamos las claves. En Debian/Ubuntu:
sudo apt update && sudo apt install wireguard -y
cd /etc/wireguard
umask 077
wg genkey | tee privatekey | wg pubkey > publickey
El archivo de configuración /etc/wireguard/wg0.conf del servidor de almacenamiento se vería así (el nodo de almacenamiento tendrá la IP privada 10.10.0.1/24):
[Interface] Address = 10.10.0.1/24 ListenPort = 51820 PrivateKey = (tu_clave_privada)Nodo trabajador 1
[Peer] PublicKey = (clave_publica_nodo1) AllowedIPs = 10.10.0.2/32
Nodo trabajador 2
[Peer] PublicKey = (clave_publica_nodo2) AllowedIPs = 10.10.0.3/32
Activamos el túnel con sudo systemctl enable wg-quick@wg0 && sudo systemctl start wg-quick@wg0. Repetimos el proceso en cada nodo trabajador, asignando IPs 10.10.0.2, .3, etc., y añadiendo al servidor de almacenamiento como peer con AllowedIPs = 10.10.0.1/32.
Exportando NFS sobre la interfaz cifrada
Con el túnel operativo, configuramos NFS. Instalamos el paquete nfs-kernel-server en el nodo de almacenamiento y creamos el directorio a compartir:
sudo mkdir -p /srv/docker-volumes
sudo chown nobody:nogroup /srv/docker-volumes
sudo chmod 777 /srv/docker-volumes
Editamos /etc/exports para restringir el acceso solo a la subred de WireGuard:
/srv/docker-volumes 10.10.0.0/24(rw,sync,no_subtree_check,no_root_squash)
Nótese el uso de no_root_squash. En un entorno Docker Swarm, los contenedores a menudo ejecutan procesos como root, y sin esta opción, los archivos creados por los contenedores pertenecerían a nobody, causando errores de permisos. Es un compromiso de seguridad a asumir solo dentro de la red privada cifrada. Aplicamos la configuración con sudo exportfs -ra y reiniciamos el servicio NFS.
Creando el volumen NFS en Docker Swarm
En cada nodo trabajador, debemos asegurarnos de que el cliente NFS está instalado (sudo apt install nfs-common). Luego, en cualquier nodo manager, definimos el volumen de tipo NFS. Docker Swarm no permite crear volúmenes NFS directamente con docker volume create de forma declarativa en un stack, pero sí podemos crearlo manualmente en cada nodo o usar un plugin. La vía más rápida es crear el volumen en cada nodo trabajador:
docker volume create --driver local \
--opt type=nfs \
--opt o=addr=10.10.0.1,rw,nfsvers=4,hard,intr \
--opt device=:/srv/docker-volumes \
nfs_cifrado_vol
Sin embargo, para que sea gestionable en un stack, es mejor definirlo en el docker-compose.yml. Docker Swarm se encarga de crear el volumen en cada nodo que lo necesite:
volumes:
datos_app:
driver: local
driver_opts:
type: nfs
o: "addr=10.10.0.1,nfsvers=4,rw"
device: ":/srv/docker-volumes"
Al desplegar el stack con docker stack deploy -c docker-compose.yml mi_app, los contenedores que monten datos_app lo harán automáticamente a través del túnel WireGuard.
Automatización de respaldos snapshot con ZFS
Ahora, la parte de respaldo. Un simple rsync sería insuficiente si queremos consistencia y velocidad. La opción más fiable es utilizar ZFS en el nodo de almacenamiento. ZFS ofrece snapshots casi instantáneos y no requieren detener el servicio. Si el directorio /srv/docker-volumes reside en un pool ZFS (por ejemplo, tank/docker), podemos crear snapshots programados.
Instalamos ZFS y creamos el pool:
sudo apt install zfsutils-linux -y
sudo zpool create tank /dev/sdb
sudo zfs create tank/docker
sudo zfs set mountpoint=/srv/docker-volumes tank/docker
Con ZFS activo, escribimos un script de respaldo que se ejecute vía cron. El script toma un snapshot y lo retiene durante N días, y además envía el snapshot a un disco externo o a un servidor remoto vía zfs send. Veamos el script base:
#!/bin/bash # /usr/local/bin/backup_zfs.sh FECHA=$(date +%Y%m%d_%H%M%S) ZFS_POOL="tank/docker" SNAPSHOT="${ZFS_POOL}@snap_${FECHA}"Crear snapshot
zfs snapshot “$SNAPSHOT”
Retener solo los ultimos 7 snapshots
ls -1t /srv/docker-volumes/.zfs/snapshot | tail -n +8 | while read snap; do zfs destroy ”${ZFS_POOL}@${snap}” done
Enviar a un respaldo externo (ej. disco USB montado en /mnt/backup)
zfs send “$SNAPSHOT” > /mnt/backup/snap_${FECHA}.zfs echo “Backup completado: $SNAPSHOT” >> /var/log/zfs_backup.log
Agregamos el cron para que se ejecute cada noche a las 2:00 AM:
0 2 * * * /usr/local/bin/backup_zfs.sh
La belleza de los snapshots ZFS es que son atómicos: el sistema de archivos está en un estado consistente, perfecto para bases de datos o aplicaciones que escriben continuamente. Además, el comando zfs send crea una copia exacta que puede ser restaurada en otro nodo en caso de desastre.
Restauración y consideraciones operativas
Para restaurar un snapshot, solo necesitamos encontrar el punto de restauración en /srv/docker-volumes/.zfs/snapshot/ y copiarlo de vuelta al directorio activo:
sudo cp -a /srv/docker-volumes/.zfs/snapshot/snap_20231025_020000/* /srv/docker-volumes/
Si el clúster entero se pierde, podemos desplegar un nuevo nodo de almacenamiento, importar el pool ZFS desde el backup externo con zpool import tank, y volver a levantar los stacks de Docker. La combinación de WireGuard y NFS sobre ZFS ofrece una solución de persistencia de datos de nivel empresarial, sin depender de soluciones cloud propietarias.
Es crucial mencionar que el rendimiento será ligeramente inferior al de un volumen local, pero la seguridad y la facilidad de backup compensan con creces. Además, WireGuard añade apenas 1-2% de sobrecarga en redes
comentarios(0)
$ dejar comentario