XFS+LVM thin: Snapshots y QoS por LV en KVM
Introducción: La combinación que no falla
En el mundo de la virtualización con KVM, el almacenamiento es el cuello de botella más común. Cuando hablamos de máquinas virtuales que requieren alto rendimiento y flexibilidad operativa, la pareja XFS + LVM thin provisioning se destaca. XFS ofrece una escalabilidad y robustez excelentes para metadatos grandes, mientras que LVM thin permite crear snapshots casi instantáneos y aprovisionamiento ligero. Pero la joya de la corona es el QoS por LV, que nos permite limitar o priorizar el I/O de cada máquina virtual de forma granular, sin necesidad de tocar la configuración del hypervisor.
Este artículo no es un tutorial paso a paso al uso, sino un análisis técnico profundo, con comandos reales y explicaciones de *por qué* funcionan. Al final, tendrás el criterio para diseñar tu propio pool de almacenamiento.
Arquitectura del pool: XFS sobre thin pool
Por qué XFS y no ext4 o btrfs
XFS es un sistema de archivos con journaling que maneja archivos grandes y muchos archivos concurrentes de forma excelente. En un host KVM con docenas de imágenes qcow2 o discos raw, la asignación de bloques de XFS reduce la fragmentación. Además, XFS soporta discard (TRIM) de forma nativa, esencial para que los bloques liberados en un thin pool se reutilicen. A diferencia de ext4, XFS no tiene límites prácticos de tamaño de archivo, lo que da tranquilidad.
La estructura típica es:
PV (disco físico o RAID)
└── VG (grupo de volúmenes)
└── Thin pool (LV)
├── Thin volume 1 (lv_guest1) → montado como XFS, usado por KVM
├── Thin volume 2 (lv_guest2)
└── Snapshots (temporales, con su propio LV)
La ventaja de LVM thin sobre los snapshots de qcow2 es el rendimiento. Los snapshots de qcow2 crean una cadena de copias en escritura (COW) que degrada el rendimiento con cada snapshot. LVM thin usa un modelo de datos espaciales (pool de bloques) donde el snapshot es un metadato que apunta a bloques compartidos. Las lecturas de bloques no modificados son tan rápidas como el original.
Creación del entorno: Comandos esenciales
Crear el VG y el thin pool
Asumimos que tienes un disco /dev/sdb con al menos 500GB. Primero, creamos el PV y el VG:
pvcreate /dev/sdb
vgcreate vg_kvm /dev/sdb
Ahora, creamos el thin pool, especificando un tamaño del 95% del VG, dejando espacio para metadatos (el 1% extra es para los metadatos del thin pool). El tamaño de chunk (bloque) es crítico: usa 128K para workloads de VM mixtos.
lvcreate --type thin-pool --thinpool tp_kvm --size 450G --chunksize 128K vg_kvm
Este comando crea dos LVs: tp_kvm (datos) y tp_kvm_tmeta (metadatos). El thin pool está listo.
Crear thin volumes y formatear con XFS
Cada VM tendrá su propio LV. Por ejemplo, para una VM de base de datos:
lvcreate --type thin --thinpool tp_kvm --virtualsize 100G -n lv_db01 vg_kvm
mkfs.xfs /dev/vg_kvm/lv_db01
En lugar de montar directamente el LV en el host, lo pasamos como disco virtual a KVM. Lo añadimos al XML de la VM:
<disk type='block' device='disk'>
<driver name='qemu' type='raw' cache='none' io='native' discard='unmap'/>
<source dev='/dev/vg_kvm/lv_db01'/>
<target dev='vda' bus='virtio'/>
</disk>
El atributo discard='unmap' es esencial. Permite que cuando la VM borre archivos, el thin pool reutilice esos bloques. Sin esto, el thin pool crecerá hasta su límite virtual sin recuperar espacio.
Snapshots eficientes con LVM thin
Crear un snapshot sin degradación de rendimiento
Los snapshots de LVM thin son una operación de O(1). No copian datos, solo crean nuevos metadatos. Para un backup consistente de una BD, primero hacemos flush en la VM (con sync o usando herramientas de quiescing de KVM), luego creamos el snapshot:
lvcreate --type thin --thinpool tp_kvm --name snap_db01 --snapshot /dev/vg_kvm/lv_db01 --virtualsize 100G
Nota: El --virtualsize debe ser al menos tan grande como el LV original. El snapshot no consume espacio real hasta que se escriben datos nuevos en el origen o en el snapshot. La sobrecarga de rendimiento al leer bloques compartidos es mínima (un puntero extra en la tabla de metadatos).
Para montar el snapshot en el host (solo lectura para backup):
mkdir /mnt/backup
mount -o nouuid,ro /dev/vg_kvm/snap_db01 /mnt/backup
La opción nouuid es crítica porque XFS almacena un UUID en el superbloque. Al montar el snapshot (que comparte el mismo UUID que el original) junto con el original, XFS se quejaría. nouuid ignora esa comprobación.
Para eliminar el snapshot y liberar metadatos:
umount /mnt/backup
lvremove /dev/vg_kvm/snap_db01
QoS por LV: Controlando el I/O de cada VM
Los límites de cgroup y cómo aplicarlos
KVM usa cgroups para el control de recursos. Para el I/O, existen dos niveles: throttling (límite duro) y proportional weight (peso relativo). LVM thin no tiene QoS nativo, pero podemos aplicar políticas mediante lvchange y el mapeador de dispositivos dm-cgroup. La forma más robusta es configurar el límite en el propio LV que pasa a la VM.
Primero, identificamos el major:minor del LV:
ls -l /dev/vg_kvm/lv_db01
brw-rw---- 1 root disk 253, 6 may 5 10:00 /dev/vg_kvm/lv_db01
Aquí, major=253, minor=6. Ahora, creamos una regla de cgroup para este dispositivo. Los límites se definen en /sys/fs/cgroup/blkio/. Para un límite de 200 MB/s de lectura y 100 MB/s de escritura:
mkdir -p /sys/fs/cgroup/blkio/kvm_db01
echo "253:6 209715200" > /sys/fs/cgroup/blkio/kvm_db01/blkio.throttle.read_bps_device
echo "253:6 104857600" > /sys/fs/cgroup/blkio/kvm_db01/blkio.throttle.write_bps_device
echo "253:6 1000" > /sys/fs/cgroup/blkio/kvm_db01/blkio.throttle.read_iops_device
echo "253:6 500" > /sys/fs/cgroup/blkio/kvm_db01/blkio.throttle.write_iops_device
Estos límites son en bytes por segundo para bps y operaciones por segundo para iops. Para aplicar el cgroup a la VM, debemos añadir el PID del proceso qemu a este grupo:
echo $PID_QEMU > /sys/fs/cgroup/blkio/kvm_db01/tasks
Para automatizarlo, usa la configuración de systemd o scripts de hook en libvirt. El problema de este método es que es manual. La alternativa es usar el controlador de I/O de libvirt con <iothread> y <blkio>, pero la granularidad es menor (a nivel de grupo de discos, no por LV individual si compartes el mismo VG).
QoS proporcional: dando prioridad
En lugar de límites duros, podemos usar pesos. Si la VM de BD necesita más I/O que una VM de prueba, asignamos pesos:
echo "253:6 800" > /sys/fs/cgroup/blkio/kvm_db01/blkio.weight_device
echo "253:7 200" > /sys/fs/cgroup/blkio/kvm_test/blkio.weight_device
El peso es un valor entre 10 y 1000. El scheduler de I/O (cfq o bfq) reparte el ancho de banda proporcionalmente. Para que funcione, el scheduler del dispositivo físico