Admin-Sistemas ·

ZFS en producción: snapshots, réplicas incrementales y ajuste de ARC

ZFS no es un sistema de archivos al uso: es un gestor de volúmenes y un sistema de archivos con integridad de datos verificada, copy-on-write y un modelo de caché muy distinto al de ext4 o XFS. En producción, esa diferencia se traduce en ventajas enormes (snapshots instantáneos, replicación a nivel de bloque, checksums end-to-end) y también en trampas específicas si no se ajustan bien los parámetros. Esta guía actualizada a 2026 repasa los pilares que marcan la diferencia en un servidor real: la creación del pool, los snapshots y el rollback, la replicación incremental con zfs send/zfs recv, la compresión zstd, la planificación de scrubs y el ajuste fino del ARC.

Creación del pool: la base de todo

El pool (zpool) es la unidad de redundancia de ZFS: si el pool muere, muere todo lo que hay dentro. Por eso la topología se decide antes de crear nada, y no se puede cambiar después sin destruir el pool. En 2026, con OpenZFS 2.2/2.3, el flujo recomendado es:

# Mirror de 2 NVMe (máximo rendimiento + redundancia simple)
# ashift=12 = sectores de 4K; usa siempre /dev/disk/by-id/ en producción
zpool create -f -o ashift=12 \
  -O compression=zstd -O atime=off -O xattr=sa \
  tank mirror \
  /dev/disk/by-id/nvme-Samsung_970_EVO_1TB_A \
  /dev/disk/by-id/nvme-Samsung_970_EVO_1TB_B

# RAIDZ2 con 6 discos HDD: tolera 2 fallos de disco
zpool create -f -o ashift=12 \
  -O compression=zstd -O atime=off \
  tank raidz2 \
  /dev/disk/by-id/ata-WD_Red_4TB_{A,B,C,D,E,F}

# Pool de desarrollo sin redundancia (¡los datos NO están protegidos!)
zpool create devpool /dev/disk/by-id/ata-SSD_500GB_X
  • mirror: la opción más segura y predecible para pocos discos. Añade pares con zpool add tank mirror ....
  • raidz2: el mínimo razonable para arrays de HDD a partir de 4-6 discos. Evita raidz1 con discos grandes: el resilver de un disco de 12 TB tarda días y el riesgo de un segundo fallo no es despreciable.
  • ashift=12: obligatorio con discos de sectores de 4K (prácticamente todos los actuales). Un ashift incorrecto no se puede corregir después.
  • Usa /dev/disk/by-id/: los nombres /dev/sdX cambian entre reinicios; los by-id no.
# Comprobar estado y salud del pool
zpool status tank
zpool list -v tank

Snapshots y rollback: baratos, pero no gratis

Un snapshot es una referencia inmutable al estado de un dataset en un instante concreto. Como ZFS es copy-on-write, crearlo no copia datos: solo fija los bloques actuales para que no se liberen hasta que el snapshot desaparezca. La creación es prácticamente instantánea, incluso en datasets de varios TB.

# Snapshot con nombre basado en fecha (recursivo con -r)
zfs snapshot -r tank/datos@2026-10-03-1200

# Listar snapshots y su espacio referenciado
zfs list -t snapshot -o name,used,refer,creation tank/datos

# Acceder al contenido de un snapshot (ruta oculta .zfs)
ls /tank/datos/.zfs/snapshot/2026-10-03-1200/

# Restaurar un fichero concreto desde un snapshot
cp /tank/datos/.zfs/snapshot/2026-10-03-1200/config.yml /tank/datos/config.yml

El peligro no está en crearlos, sino en olvidarlos: un snapshot que se mantiene meses impide liberar bloques antiguos y eso se nota en el USED del dataset padre. La política habitual en producción es una rotación escalonada (cada 15 min con retención de 24 h, horarios con 7 días, diarios con 30 días, mensuales con 1 año). Herramientas como sanoid, zfs-auto-snapshot o pyznap la automatizan sin reinventar la rueda.

Rollback y clonado

# Volver un dataset completo a un snapshot anterior
# -r destruye los snapshots y clones posteriores: úsalo con cabeza
zfs rollback -r tank/datos@2026-10-03-1200

# Clonar un snapshot para inspeccionarlo sin tocar el original
zfs clone tank/datos@2026-10-03-1200 tank/datos-recuperacion
zfs destroy tank/datos-recuperacion   # cuando termines, elimínalo

Si solo necesitas recuperar unos ficheros, copia desde .zfs/snapshot/: es más rápido y no destruye nada. Reserva el rollback para desastres de verdad.

Replicación incremental con zfs send / zfs recv

La replicación nativa de ZFS envía streams binarios entre pools, locales o remotos, con integridad garantizada por los checksums. El flujo de trabajo en producción es: un envío completo inicial y después incrementales programados.

# 1. Snapshot base y envío COMPLETO inicial vía SSH
zfs snapshot tank/datos@base
zfs send tank/datos@base | \
  ssh backup@10.0.0.20 'zfs recv -F backup/datos'

# 2. Al día siguiente: snapshot nuevo y envío INCREMENTAL (-i)
zfs snapshot tank/datos@dia2
zfs send -i tank/datos@dia2-base tank/datos@dia2 | \
  ssh backup@10.0.0.20 'zfs recv -F backup/datos'

# 3. Variante con progreso visible y compresión en tránsito
zfs send -i tank/datos@dia2 tank/datos@dia3 | pv | \
  ssh -C backup@10.0.0.20 'zfs recv -F backup/datos'
  • -i snapA snapB: envía solo los bloques que cambiaron entre los dos snapshots. En datasets grandes con cambios pequeños reduce el ancho de banda de forma drástica.
  • -I (mayúscula): envía además todos los snapshots intermedios. Útil cuando el destino lleva varios días de retraso.
  • -F en recv: fuerza la sincronización del destino con el stream. Cuidado: elimina del destino los snapshots que no existen en el origen.
  • Reanudar envíos interrumpidos: añade -s al send para que genere un token de reanudación, y recupéralo con zfs send -t <token>. Imprescindible en réplicas de varios TB por WAN.
  • Datasets cifrados: usa zfs send -w (raw) para replicar sin descifrar en el origen: el destino recibe los datos cifrados tal cual.
# Verificar que origen y destino están sincronizados (GUID iguales)
zfs list -t snapshot -o name,guid tank/datos
ssh backup@10.0.0.20 'zfs list -t snapshot -o name,guid backup/datos'

# Proteger un snapshot crítico para que la rotación no lo borre
zfs hold keep tank/datos@base
zfs holds tank/datos@base
zfs release keep tank/datos@base   # liberar cuando ya no haga falta

Ajuste del ARC: el corazón del rendimiento

El ARC (Adaptive Replacement Cache) es la caché en RAM de ZFS. Gestiona de forma adaptativa bloques usados recientemente (MRU) y frecuentemente (MFU). En producción suele ocupar la mayor parte de la RAM libre, y eso es deseable: ZFS la libera cuando una aplicación la necesita. El problema aparece cuando el servidor ya tiene la memoria comprometida (bases de datos, JVM): entonces hay que acotar el ARC.

# Límite del ARC a 32 GB en caliente (bytes)
echo 34359738368 > /sys/module/zfs/parameters/zfs_arc_max

# Persistente: parámetros del módulo (sobrevive reinicios)
echo "options zfs zfs_arc_max=34359738368" > /etc/modprobe.d/zfs.conf
update-initramfs -u -k all   # Debian/Ubuntu
# dracut --regenerate-all --force   # RHEL/Rocky/Alma

# Alternativa: parámetro en la línea de arranque del kernel
# zfs.zfs_arc_max=34359738368

Regla práctica: reserva para el ARC entre el 50% y el 75% de la RAM en servidores dedicados a almacenamiento, y mucho menos (16-25%) si la máquina corre bases de datos o aplicaciones con heap propio. zfs_arc_min evita que el ARC se encoja hasta cero bajo presión de memoria.

Observabilidad del ARC

# Hit ratio global
awk '/^hits/ {h=$3} /^misses/ {m=$3} END {print "hit%:", 100*h/(h+m)}' \
  /proc/spl/kstat/zfs/arcstats

# Tamaño actual y máximo del ARC
grep -E "^(size|c_max) " /proc/spl/kstat/zfs/arcstats

# Resumen legible y monitor en vivo (paquete zfsutils-linux)
arc_summary
arcstat 1

Un hit ratio por debajo del 90% en producción suele indicar que el ARC es demasiado pequeño para el working set. Si el working set supera la RAM, un L2ARC sobre NVMe puede ayudar, pero cada bloque en L2ARC consume RAM del ARC para sus índices: no lo añadas hasta tener el hit ratio por encima del 90% con misses persistentes. Y recuerda que el SLOG (ZIL separado) solo importa para escrituras síncronas: con NVMe con protección de energía marca una diferencia brutal en bases de datos y NFS con sync.

Compresión zstd: actívala y olvídate

Desde OpenZFS 2.0, zstd es la compresión recomendada: mejor ratio que lz4 con un coste de CPU similar, y se aplica solo a los datos nuevos (o reescritos). Activarla es una de las victorias más baratas en ZFS:

# Activar zstd en un dataset (nivel 3 por defecto)
zfs set compression=zstd tank/datos

# Nivel más agresivo si la CPU va sobrada (1-19, por defecto 3)
zfs set compression=zstd-10 tank/backups

# Comprobar el ratio real conseguido
zfs get compressratio tank/datos

# Heredado por los datasets hijos salvo que lo sobreescribas
zfs get -r compression tank

En datos típicos de servidor (logs, código, bases de datos, backups) es habitual ver ratios de 1.5x a 3x. Solo hay un caso donde conviene pensárselo dos veces: datasets que ya guardan datos comprimidos o cifrados (vídeo, JPEG, backups cifrados), donde la compresión solo consume CPU sin ahorrar espacio.

Planificación del scrub: tu seguro de integridad

El scrub lee todos los datos del pool y verifica los checksums, reparando errores con la redundancia cuando existen. Sin scrubs periódicos, la corrupción silenciosa (bit rot) puede acumularse hasta que un disco falla y descubres que la paridad también está dañada. Es una operación online: el pool sigue sirviendo datos mientras se ejecuta.

# Lanzar un scrub manual
zpool scrub tank

# Ver el progreso y el último resultado
zpool status tank

# Pausar / reanudar (útil en horas de carga alta)
zpool scrub -p tank

# Detener un scrub en curso
zpool scrub -s tank

Automatízalo: un scrub mensual en arrays HDD y semanal o quincenal en pools NVMe pequeños es un buen punto de partida. En sistemas con systemd, un timer es más limpio que cron:

# /etc/systemd/system/zpool-scrub@.service
[Unit]
Description=Scrub del pool ZFS %i

[Service]
Type=oneshot
ExecStart=/usr/sbin/zpool scrub %i

# /etc/systemd/system/zpool-scrub@.timer  (primer domingo de mes, 03:00)
[Unit]
Description=Scrub mensual del pool ZFS %i

[Timer]
OnCalendar=Sun *-*-1..7 03:00:00
Persistent=true

[Install]
WantedBy=timers.target
systemctl enable --now zpool-scrub@tank.timer
systemctl list-timers zpool-scrub@tank.timer

Conclusión

ZFS en producción recompensa al que entiende sus piezas: un pool bien dimensionado desde el primer día, snapshots con rotación automatizada, réplicas incrementales que viajan por SSH cada noche, zstd ahorrando espacio sin que lo notes, scrubs programados que vigilan la integridad y un ARC ajustado al working set real. Ninguna de estas piezas es complicada por separado; la diferencia la marca tenerlas todas funcionando juntas, verificadas y automatizadas. Empieza por el pool y los snapshots hoy: el resto se añade por capas, sin downtime.