KVM (Español) - ArchWiki

Jump to content

# KVM (Español)

From ArchWiki
Estado de la traducción: esta traducción de KVM fue revisada el 2021-01-01. Si existen cambios puede actualizarla o avisar al equipo de traducción.

Artículos relacionados

- Category:Hypervisors (Español)
- 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. (Vea 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 modules (Español)#Manejar módulos manualmente.

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, vea la configuración del BIOS. Algunos fabricantes, especialmente los de laptops, deshabilitan estas extensiones del procesador por defecto. Para determinar si es que no hay soporte hardware o su las extensiones están deshabilitadas en el 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

Vea el articulo principal: QEMU (Español).

## Consejos y trucos

Nota: Vea 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`:

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 (vea Kernel module (Español)#Configurar opciones de los módulos):

    /etc/modprobe.d/kvm_intel.conf

    options kvm_intel nested=1

Verifique que la función este activada:

    $ systool -m kvm_intel -v | grep nested

    nested              = "Y"

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 `host-passthrough` (no va a estar en la lista, solo escribalo en el cuadro).
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 propiedad vmx este presente:

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

### Habilitando hugepages

This article or section is a candidate for merging with QEMU (Español).

Notes: qemu-kvm ya no existe como tal, ya que toda su funcionalidad ha sido integrada con qemu. Después de que este asunto este resuelto, se sugiere que se combine esta sección con QEMU. (Discusión en la pagina del articulo en inglés). (Discuss in Talk:KVM#Merge KVM article into QEMU)

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 `/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`:

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

Obviamente, 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. Vea 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 habilitar las hugepages por defecto. Añada a su `/etc/sysctl.d/40-hugepage.conf`:

    vm.nr_hugepages = 550

Vea 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)

Categories:

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

Hidden category:

- Pages or sections flagged with Template:Merge