Virtualización anidada con KVM para entornos de prueba aislados

Introducción: El paradigma de la virtualización anidada

En entornos de infraestructura modernos, la necesidad de emular hardware virtual dentro de una máquina virtual (VM) se ha convertido en un requisito crítico para casos de uso como laboratorios de pruebas, desarrollo de hipervisores, evaluaciones de seguridad y despliegues de contenedores anidados. La virtualización anidada con KVM (Kernel-based Virtual Machine) permite que una VM actúe como un host físico, ejecutando su propio hipervisor y máquinas virtuales hijas. Este artículo desglosa la configuración, optimización y resolución de problemas de esta técnica, proporcionando un flujo de trabajo completo para entornos de prueba aislados.

Nota importante: La virtualización anidada introduce una penalización de rendimiento significativa. Según benchmarks de la comunidad KVM, la sobrecarga puede alcanzar un 15-30% en cargas intensivas de CPU y E/S. Se recomienda solo para entornos de laboratorio o pruebas no productivas.

Fundamentos técnicos: Cómo funciona KVM anidado

KVM aprovecha las extensiones de virtualización por hardware (Intel VT-x/AMD-V) del procesador físico. En un escenario anidado, el hipervisor L0 (host físico) expone estas capacidades a la VM L1 (guest), que a su vez las utiliza para ejecutar sus propias VMs L2.

Arquitectura de niveles

Nivel	Rol	Ejemplo de software
L0	Hypervisor físico	KVM + QEMU (host)
L1	VM con virtualización anidada	Ubuntu Server 22.04 con KVM
L2	VM dentro de L1	Máquina virtual de prueba

Requisitos de hardware

Procesador con Intel VT-x o AMD-V (verificar con grep -E 'svm|vmx' /proc/cpuinfo)
Mínimo 16 GB RAM en el host (recomendado 32 GB para cargas moderadas)
Almacenamiento SSD con suficiente espacio (mínimo 100 GB para imágenes base)
Soporte de EPT (Extended Page Tables) para Intel o NPT (Nested Page Tables) para AMD

Configuración del host L0 para virtualización anidada

1. Verificar capacidades del kernel

# Comprobar que el módulo kvm_intel o kvm_amd esté cargado con soporte anidado
cat /sys/module/kvm_intel/parameters/nested
# Debería devolver "1" o "Y". Si es "0" o "N", proceder a habilitarlo.

Si el parámetro está deshabilitado, debemos configurarlo en el arranque:

# Para Intel
echo "options kvm_intel nested=1" | sudo tee /etc/modprobe.d/kvm_intel.conf

# Para AMD
echo "options kvm_amd nested=1" | sudo tee /etc/modprobe.d/kvm_amd.conf

# Recargar módulo (requiere reinicio o descarga segura)
sudo modprobe -r kvm_intel
sudo modprobe kvm_intel nested=1

¿Por qué esta configuración? El parámetro nested=1 permite que las VMs utilicen las instrucciones VMX (Intel) o SVM (AMD) para ejecutar sus propios hipervisores. Sin esto, cualquier intento de ejecutar KVM dentro de una VM fallará con errores de "invalid opcode".

2. Configurar la red para conectividad entre niveles

Para entornos aislados, recomendamos usar bridges de red Linux en lugar de NAT. Esto permite que las VMs L2 tengan direcciones IP en la misma subred que el host L0.

# Crear un bridge persistente (ejemplo con netplan en Ubuntu)
sudo cat > /etc/netplan/01-netcfg.yaml << EOF
network:
  version: 2
  renderer: networkd
  ethernets:
    enp3s0:
      dhcp4: no
  bridges:
    br0:
      interfaces: [enp3s0]
      dhcp4: yes
      parameters:
        stp: false

EOF

sudo netplan apply

Creación de la VM L1 con soporte anidado

1. Instalación de QEMU/KVM con características extendidas

# Instalar paquetes necesarios (Debian/Ubuntu)
sudo apt update && sudo apt install -y qemu-kvm libvirt-daemon-system libvirt-clients bridge-utils virt-manager

# Verificar que libvirtd esté activo
sudo systemctl enable --now libvirtd

2. Definir la VM con flags de CPU anidados

La clave está en la configuración de la CPU. Debe exponer las extensiones de virtualización a la VM L1.

# Usando virt-install (CLI)
sudo virt-install \
  --name vm-nested \
  --ram 8192 \
  --vcpus 4 \
  --cpu host-passthrough \
  --os-type linux \
  --os-variant ubuntu22.04 \
  --disk path=/var/lib/libvirt/images/vm-nested.qcow2,size=50 \
  --network bridge=br0,model=virtio \
  --graphics vnc,listen=0.0.0.0 \
  --cdrom /path/to/ubuntu-22.04-server.iso

¿Por qué --cpu host-passthrough? Esta opción pasa todas las características de la CPU del host a la VM, incluyendo VMX/SVM. Alternativas como --cpu host-model solo pasan un subconjunto, lo que puede romper la virtualización anidada.

3. Configuración XML avanzada para rendimiento

Para entornos de prueba exigentes, edita la definición XML de la VM:

virsh edit vm-nested

Añade o modifica las siguientes secciones:

<domain type='kvm'>
  <cpu mode='host-passthrough' check='none'>
    <topology sockets='1' cores='2' threads='2'/>
    <cache level='3' mode='emulate'/>
    <feature policy='require' name='vmx'/>
  </cpu>
  <features>
    <acpi/>
    <apic/>
    <hyperv>
      <relaxed state='on'/>
      <vapic state='on'/>
      <spinlocks state='on' retries='8191'/>
    </hyperv>
    <kvm>
      <hidden state='on'/>
    </kvm>
  </features>
  <clock offset='utc'>
    <timer name='hypervclock' present='yes'/>
  </clock>
</domain>

Explicación de parámetros clave:

<feature policy='require' name='vmx'/>: Fuerza la exposición de VMX incluso si el host no lo reporta explícitamente.
<hidden state='on'/>: Oculta la presencia de KVM al sistema operativo invitado, necesario para algunos hipervisores L2 como VMware.
<cache level='3' mode='emulate'/>: Emula la caché L3 para mejorar la coherencia de memoria en cargas anidadas.

Configuración de la VM L1 como hipervisor

Una vez instalado el sistema operativo en L1, dentro de ella debemos configurar KVM para soportar VMs L2.

1. Instalar KVM dentro de L1

# Dentro de la VM L1
sudo apt update && sudo apt install -y qemu-kvm libvirt-daemon-system bridge-utils

2. Verificar capacidades anidadas dentro de L1

# Comprobar que el módulo kvm_intel esté cargado con nested=1
cat /sys/module/kvm_intel/parameters/nested

# Si es 0, configurar como en el host
echo "options kvm_intel nested=1" | sudo tee /etc/modprobe.d/kvm_intel.conf
sudo modprobe -r kvm_intel && sudo modprobe kvm_intel nested=1

3. Crear una VM L2 de prueba

# Dentro de L1, crear una VM mínima
sudo virt-install \
  --name vm-l2-test \
  --ram 1024 \
  --vcpus 2 \
  --cpu host-passthrough \
  --disk size=10 \
  --network default \
  --graphics none \
  --location 'http://archive.ubuntu.com/ubuntu/dists/jammy/main/installer-amd64/' \
  --extra-args 'console=ttyS0,115200n8 serial'

Optimización de rendimiento para entornos anidados

1. Asignación de recursos y limitaciones

Componente	Recomendación para L1	Razón
vCPUs	2-4 (con overcommit 1:1)	El scheduler de L0 debe gestionar la contención de VMX
RAM	Al menos 4 GB + overhead por VM L2	Cada VM L2 requiere ~512 MB adicionales para estructuras de virtualización
Almacenamiento	Usar discos QCOW2 con preasignación	Reduce la fragmentación y mejora E/S en operaciones anidadas
Red	VirtIO con multiqueue	Mejora el throughput en tráfico de red anidado

2. Configuración de CPU pinning y aislamiento

Para minimizar la contención de caché en L0:

# En el host L0, identificar CPUs físicas
lscpu -e

# Asignar vCPUs de L1 a CPUs físicas específicas
virsh vcpupin vm-nested 0 2
virsh vcpupin vm-nested 1 3
virsh vcpupin vm-nested 2 4
virsh vcpupin vm-nested 3 5

3. Ajustes de memoria transparente (THP)

# En el host L0, habilitar THP para reducir TLB misses en L1
echo always | sudo tee /sys/kernel/mm/transparent_hugepage/enabled

# Verificar estado
cat /sys/kernel/mm/transparent_hugepage/enabled

Escenarios de prueba avanzados

1. Laboratorio de seguridad con múltiples hipervisores

Crear una topología donde L1 ejecute KVM y VirtualBox simultáneamente:

# Dentro de L1, instalar VirtualBox
sudo apt install -y virtualbox virtualbox-ext-pack

# Crear una VM en VirtualBox con Windows XP (aislada de la red)

VBoxManage createvm --name "winxp-airgap" --register

VBoxManage modifyvm "winxp-airgap" --memory 512 --acpi on --boot1 dvd

VBoxManage createhd --filename ~/VirtualBox\ VMs/winxp-airgap/disk.vdi --size 10000

VBoxManage storagectl "winxp-airgap" --name "IDE Controller" --add ide

VBoxManage storageattach "winxp-airgap" --storagectl "IDE Controller" --port 0 --device 0 --type hdd --medium ~/VirtualBox\ VMs/winxp-airgap/disk.vdi

2. Pruebas de migración en vivo entre L1 y L2

Configurar almacenamiento compartido NFS:

# En L0, exportar directorio para almacenamiento compartido
sudo apt install nfs-kernel-server
sudo mkdir -p /srv/nfs/shared
echo "/srv/nfs/shared *(rw,sync,no_subtree_check,no_root_squash)" | sudo tee -a /etc/exports
sudo exportfs -a

# En L1, montar NFS y crear imágenes de VM L2
sudo mount -t nfs 192.168.1.100:/srv/nfs/shared /mnt/shared
sudo virt-install ... --disk path=/mnt/shared/vm-l2.qcow2,size=20

Resolución de problemas comunes

1. Error "KVM: disabled by BIOS"

# Verificar estado de VT-x en el host
dmesg | grep -i kvm

# Solución: Habilitar virtualización en BIOS/UEFI del host físico

2. VM L1 no detecta VMX

# Dentro de L1
grep -E 'vmx|svm' /proc/cpuinfo

# Si no hay salida, verificar configuración de CPU en virsh
virsh dumpxml vm-nested | grep -A10 cpu

3. Rendimiento extremadamente bajo en L2

# Verificar uso excesivo de interrupciones
cat /proc/interrupts | grep -E 'LOC|RES'

# Solución: Reducir número de vCPUs en L1 y L2, habilitar paravirtualización
# Agregar <driver name='vhost'/> en interfaces de red L1

Conclusiones y mejores prácticas

La virtualización anidada con KVM es una herramienta poderosa para entornos de prueba, pero requiere una configuración meticulosa. Recomendamos:

Documentar cada capa: Mantener un registro de las configuraciones de CPU, red y almacenamiento en cada nivel.
Monitorear el overhead: Usar perf y virt-top para identificar cuellos de botella.
Limitar el anidamiento: No más de 2 niveles de anidamiento (L0 → L1 → L2) para mantener la estabilidad.
Aislar la red: Usar bridges separados o VLANs para evitar fugas de tráfico entre entornos de prueba.

Para entornos de producción, considere alternativas como contenedores Docker anidados o hipervisores tipo 2 ligeros, pero para laboratorios educativos y pruebas de seguridad, KVM anidado sigue siendo la opción más flexible y completa disponible en el ecosistema Linux.