KVM (Español)

KVM, la Maquina virtual basada en el kernel (Kernel-based Virtual Machine) es un hipervisor integrado al kernel de Linux. Es parecido en propósito a Xen pero es mucho mas fácil de hacer andar. A diferencia QEMU, el cual ocupa emulación, KVM es un modo de operación especial de QEMU que usa extensiones de CPU (Virtualización asistida por hardware HVM) para la virtualización con el modulo del kernel.

Esta traducción de KVM fue revisada el 2021-01-01. Si existen cambios puede actualizarla o avisar al equipo de traducción.

Al usar KVM, se pueden ejecutar varias maquinas virtuales ejecutando GNU/Linux, Windows o cualquier otro sistema operativo sin ser modificado. (véase el Estatus de Soporte de Sistema Operativo Invitado para mas información). Cada maquina virtual tiene su propio hardware virtualizado: una tarjeta de red, disco, tarjeta grafica, etc.

Puede encontrar las diferencias entre KVM y Xen, VMware o QEMU en la pagina de preguntas y respuestas frecuentes de KVM.

Este articulo no cubre las características de distintos emuladores usando KVM como base. Usted debe ver los artículos relacionados para esa información.

Comprobar soporte para KVM

Soporte de hardware

KVM requiere que el procesador del host tenga soporte para virtualización (llamado Vt-x en los procesadores Intel y AMD-V para los AMD). Puede ver su si procesador tiene soporte para virtualización por hardware con el siguiente comando:

$ LC_ALL=C lscpu | grep Virtualization

Y, alternativamente:

$ grep -E --color=auto 'vmx|svm|0xc0f' /proc/cpuinfo

Si al ejecutar cualquiera de los dos comandos no obtiene alguna salida, su procesador no soporta virtualización por hardware , y no podrá usar KVM.

Nota: Puede que tenga que habilitar el soporte para virtualizado en su BIOS. Todos los procesadores x86_64 manufacturador por AMD y Intel en los últimos 10 años soportas virtualización. Si pareciera como que su procesador no soporta virtualización, es casi seguro que esta deshabilitado en el BIOS.

Soporte en el kernel

Arch Linux provee los módulos para el kernel necesarios para soportar KVM.

• Usted puede comprobar si los módulos necesarios (kvm y/o kvm_amd o kvm_intel) están disponibles en el kernel con el siguiente comando:

$ zgrep CONFIG_KVM /proc/config.gz

• Entonces, asegúrese que los módulos sean cargados automáticamente con el comando:

$ lsmod | grep kvm

kvm_intel             245760  0
kvmgt                  28672  0
mdev                   20480  2 kvmgt,vfio_mdev
vfio                   32768  3 kvmgt,vfio_mdev,vfio_iommu_type1
kvm                   737280  2 kvmgt,kvm_intel
irqbypass              16384  1 kvm

Si el comando no devuelve nada, el modulo necesita ser cargado manualmente, vea Kernel module (Español)#Manejo manual de módulos.

Paravirtualización con Virtio

La paravirtualización provee un medio de comunicación rápido y eficiente para los sistemas huésped (guests) para usar los dispositivos de la maquina anfitriona (host). KVM provee dispositivos paravirtualizados a las maquinas virtuales usando la API (Application Programming Interfase: Interfaz de Programación de aplicaciones) de Virtio como una capa entre el hipervisor y el invitado.

Todos los dispositivos Virtio tienen dos partes: el dispositivo anfitrión y el controlador huésped.

Soporte en el kernel

Use el siguiente comando para ver si los módulos VIRTIO están disponibles en el kernel dentro de la maquina virtual:

$ zgrep VIRTIO /proc/config.gz

Y, revise si los módulos del kernel son cargados automáticamente con el comando:

$ lsmod | grep virtio

El en caso de que los comandos anteriores no devuelvan nada, tiene que cargar los módulos manualmente.

Lista de dispositivos paravirtualizados

• dispositivo de red (virtio-net)
• dispositivo de bloque (virtio-blk)
• dispositivo controlador (virtio-scsi)
• dispositivo serial (virtio-serial)
• dispositivo balón (balloon device) (virtio-balloon)

Como usar KVM

Véase el articulo principal: QEMU (Español).

Consejos y trucos

Nota: Véase QEMU (Español)#Consejos y trucos y QEMU (Español)#Solución de problemas para consejos y trucos generales.

Virtualización anidada

La virtualización anidada permite que maquinas virtuales existentes puedan ser ejecutadas en hipervisores de terceros y en otra nubes sin alguna modificación a la maquina virtual original o su funcionamiento de red.

Habilite la función de virtualización anidada en el anfitrión para kvm_intel:

# modprobe -r kvm_intel
# modprobe kvm_intel nested=1

Para hacerlo permanente (Véase Kernel module (Español)#Configurar las opciones del módulo):

Verifique que la función este activada:

Habilite el modo de "host passthrough" (paso sobre el anfitrión) para enviar todas las características de la CPU al sistema anfitrión:

1. Si esta usando QEMU, ejecute la maquina virtual con el siguiente comando: qemu-system-x86_64 -enable-kvm -cpu host.
2. Si usa virt-manager, cambie el modelo de la CPU a (no va a estar en la lista, solo escribalo en el cuadro).
3. Si esta usando virsh, use y cambie la linea de CPU a

Inicie la maquina virtual y compruebe que propiedad vmx este presente:

$ grep -E --color=auto 'vmx|svm' /proc/cpuinfo

Habilitando hugepages

Puede habilitar las hugepages para mejorar el rendimiento de su maquina virtual. Con una maquina con Arch Linux actualizado y KVM funcional probablemente ya tiene todo lo que necesita. Compruebe su tiene el directorio . Si no lo tiene, creelo. Ahora necesita establecer los permisos apropiados para usar ese directorio. Los permisos por defecto son el uid (User Identifier: Identificador de Usuario) y el gid (Group Identifier: Identificador del Grupo) del usuario root con 0755, pero queremos que cualquiera en el grupo kvm tenga acceso a las hugepages.

Añada a su :

hugetlbfs       /dev/hugepages  hugetlbfs       mode=01770,gid=78        0 0

Obviamente, el gid debe ser igual al del grupo kvm. El modo permite que cualquiera en el grupo crear archivos, pero no desenlazar o renombrar los archivos de otros. Asegúrese que este correctamente montado:

# umount /dev/hugepages
# mount /dev/hugepages
$ mount | grep huge

hugetlbfs on /dev/hugepages type hugetlbfs (rw,relatime,mode=1770,gid=78)

Ahora puede calcular cuantas hugepages va a necesitar. Véase que tan grandes son sus hugepages:

$ grep Hugepagesize /proc/meminfo

Normalmente, el tamaño debería ser de 2048 kB (que corresponde a 2 MB). Digamos que quiere ejecutar su maquina virtual con 1024 MB, así que divide 1024 / 2 = 512 y lo aumenta un poco para redondearlo a 550. Ahora establezca la cantidad de hugepages que quiere:

echo 550 > /proc/sys/vm/nr_hugepages

Si tiene suficiente espacio libre debería ver lo siguiente:

Si obtiene un numero menor, cierre algunas aplicaciones o inicie su maquina virtual con menos memoria (numero_de_hugepages x 2):

$ qemu-system-x86_64 -enable-kvm -m 1024 -mem-path /dev/hugepages -hda <disk_image> [...]

Fíjese en el parámetro . Este hará uso de las hugepages.

Mientras que su maquina virtual se esta ejecutando, puede comprobar cuantas hugepages están siendo usadas:

Ahora que todo parece funcionar, puede habilitar las hugepages por defecto. Añada a su :

vm.nr_hugepages = 550

Véase tambien:

• Sumario de soporte de hugetlbpage en el kernel de Linux (en inglés)
• Debian Wiki - Hugepages (en inglés)

Véase también

• Indice de tutoriales de KVM (en inglés)
• Preguntas y respuestas frecuentes de KVM (en inglés)