Jump to content

# KVM (Español)

4 languages

- English
- 日本語
- Русский
- 中文（简体）

From ArchWiki
Esta traducción de KVM fue revisada el 2024-02-19. Si existen cambios puede actualizarla o avisar al equipo de traducción.

Artículos relacionados

- Categoría:Hipervisores
- Libvirt

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.

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 activar 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 desactivado en la 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; véase Kernel module (Español)#Manejo manual de módulos.

Sugerencia: Si falla al intentar cargar (modprobe) `kvm_intel` o `kvm_amd`, pero no con `kvm`, y `lscpu` dice que la aceleración por hardware si esta soportada, véase la configuración del BIOS. Algunos fabricantes, especialmente los de laptops, desactivan estas extensiones del procesador por defecto. Para determinar si es que no hay soporte hardware o su las extensiones están desactivadas en la BIOS, la salida de dmesg después de haberlas cargado lo va a confirmar.

## 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.

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

Nota: Se puede hacer lo mismo para AMD, solo reemplace `intel` con `amd` donde sea necesario.

    # modprobe -r kvm_intel
    # modprobe kvm_intel nested=1

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

    /etc/modprobe.d/kvm_intel.conf

    options kvm_intel nested=1

Verifique que la función este activada:

    $ cat /sys/module/kvm_intel/parameters/nested

    Y

Active 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 `host-passthrough`.
3. Si esta usando virsh, use `virsh edit vm-name` y cambie la linea de CPU a `<cpu mode='host-passthrough' check='partial'/>`

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

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

### Activando páginas enormes

Puede activar 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 `/dev/hugepages`. 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 `/etc/fstab`:

    /etc/fstab

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

En lugar de especificar el nombre del grupo directamente, con `gid=kvm`, puede especificar el gid como un número, pero el gid debe ser igual al del grupo `kvm`. El modo `1770` permite que cualquiera en el grupo crear archivos, pero no desenlazar o renombrar los archivos de otros. Asegúrese que `/dev/hugepages` 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:

    $ grep HugePages_Total /proc/meminfo

    HugesPages_Total:  550

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 `-mem-path`. Este hará uso de las hugepages.

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

    $ grep HugePages /proc/meminfo

    HugePages_Total:     550
    HugePages_Free:       48
    HugePages_Rsvd:        6
    HugePages_Surp:        0

Ahora que todo parece funcionar, puede activar las hugepages por defecto. Añada a su `/etc/sysctl.d/40-hugepage.conf`:

    /etc/sysctl.d/40-hugepage.conf

    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)

### Secure Boot

KVM Secure boot tiene algunos requisitos antes de poder activarse:

1. Debe utilizar una UEFI con soporte de arranque seguro compilado.
2. La UEFI debe tener claves registradas.

Nota: Actualmente, Arch Linux no tiene una clave de inicio segura a diferencia de distribuciones como Fedora. Si tiene la intención de iniciar de forma segura Arch Linux, debe crear su propia clave de firma y firmar su kernel después de seguir los pasos a continuación. Véase Unified Extensible Firmware Interface/Secure Boot para más información.

Para activar UEFI con soporte de arranque seguro, instale edk2-ovmf y configure su máquina virtual para utilizar UEFI activado para arranque seguro. Si está utilizando libvirt, puede hacerlo añadiendo lo siguiente a la configuración XML de su máquina virtual.

    <os firmware="efi">
      <loader readonly="yes" secure="yes" type="pflash">/usr/share/edk2/x64/OVMF_CODE.secboot.4m.fd</loader>
    </os>

A continuación, debe registrar algunas claves. En este ejemplo registraremos las claves de inicio seguras de Microsoft y Redhat. Instale virt-firmware y ejecute lo siguiente. Reemplace `vm_name` con el nombre de su máquina virtual.

    $ virt-fw-vars --input /var/lib/libvirt/qemu/nvram/vm_name_VARS.fd --output /var/lib/libvirt/qemu/nvram/vm_name_SECURE_VARS.fd --secure-boot --enroll-redhat

Luego edite la configuración XML de libvirt de su máquina virtual para que apunte al nuevo archivo VARS.

    <os firmware="efi">
      <loader readonly="yes" secure="yes" type="pflash">/usr/share/edk2/x64/OVMF_CODE.secboot.4m.fd</loader>
      <nvram template="/usr/share/edk2/x64/OVMF_VARS.4m.fd">/var/lib/libvirt/qemu/nvram/{vm-name}_SECURE_VARS.fd</nvram>
    </os>

Después de este arranque seguro debería activarse automáticamente. Puede volver a comprobarlo entrando al BIOS de la máquina virtual presionando `F2` cuando vea el logotipo de inicio UEFI.

## Véase también

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

Categories:

- Hypervisors (Español)
- Kernel (Español)