QEMU (Español)
De acuerdo con la wiki de QEMU, "QEMU es un emulador genérico y de código abierto de máquinas virtuales."
Cuando se utiliza como un emulador de máquina, QEMU puede correr sistemas operativos y programas hechos para una máquina en particular (por ej. una placa ARM) en una máquina diferente (e.j. tu PC x86). Usando la traducción dinámica, se consigue un rendimiento muy bueno.
QEMU puede usar hipervisores como Xen o KVM para utilizar las extensiones del procesador para la virtualización. Cuando se utiliza como virtualizador, QEMU alcanza un rendimiento cercano a el nativo ejecutando el código de invitado directamente en el CPU host.
Instalación
Instale el paquete qemu-full (ó qemu-base para la versión sin GUI y qemu-desktop para la versión con solo emulación x86_64 por defecto) y los paquetes opcionales para tus necesidades:
- qemu-block-gluster - Soporte para bloque Glusterfs
- qemu-block-iscsi - Soporte para bloque iSCSI
- samba - Soporte para servidor SMB/CIFS
Front-ends para QEMU
A diferencia de otros programas de virtualización como VirtualBox y VMware, QEMU no proporciona una interfaz gráfica de usuario para administrar máquinas virtuales (a parte de la ventana que aparece cuando se ejecuta una máquina virtual), tampoco proporciona una forma de crear una máquina virtual persistente con valores guardados. Todos los parámetros para ejecutar una máquina virtual deben especificarse en la línea de comandos en cada puesta en marcha, a menos que haga un script personalizadp para iniciar su máquina(s) virtual. Sin embargo, hay varios front-end GUI para QEMU:
- qemu-launcherAUR
- qtemuAUR
- aqemuAUR
front-ends con soporte para QEMU están disponibles por libvirt.
Creando un nuevo sistema virtualizado
Creando una imagen de disco duro
Para ejecutar QMEU necesitarás una imagen de disco duro, a menos que estés cargando un sistema en vivo desde el CD-ROM ó la red (y no para instalar un sistema operativo en una imagen de disco duro). Una imagen de disco es un archivo que almacena los contenidos del disco duro emulado.
Una imagen de disco puede ser en "crudo", de manera que, literalemte, byte por byte es lo mismo que el cliente ve, y siempre utilizará toda la capacidad del disco duro del disco duro invitado en el host. Este método proporciona la menor sobrecarga de Entrada / Salida, pero puede desperdiciar una gran cantidad de espacio, ya que el espacio no utilizado por el invitado no se puede utilizar en el host.
Por otra parte, la imagen de disco duro puede estar en un formato tal como el de qcow2 el cuál únicamente asigna espacio a el archivo de la imagen cuando el SO invitado está escribiendo en los sectores del disco virtual. La imagen aparece como el tamaño total del sistema operativo huésped, a pesar que puede tomar hasta una cantidad muy pequeña de espacio en el sistema host. El uso de este formato en lugar de el "crudo" probablemente afecte el rendimiento.
QEMU proporciona el qemu-img
comando para crear imagenes de disco.
Por ejemplo, para crear una imagen de 4GB en formato "crudo":
$ qemu-img create -f raw image_file 4G
Se puede uiltizar -f qcow2
para crear un disco qcow2 en su lugar.
dd
ó fallocate
.Superposición de imágenes de almacenamiento
Puede crear una imagen de almacenamiento una vez (la imagen de respaldo) y hacer que QEMU mantenga mutaciones a esta imagen en una imagen de superposición. Esto le permite volver a un estado anterior de esta imagen de almacenamiento. Puede volver a crear una nueva imagen de superposición en el momento en que desea revertir en función de la imagen de respaldo original.
Para crear una imagen de superposición, ingrese el comando:
$ qemu-img create -o backing_file=img1.raw,backing_fmt=raw -f qcow2 img1.cow
Después de eso, puede ejecutar su máquina virtual como de costumbre (ver #Ejecución del sistema virtualizado):
$ qemu-system-x86_64 img1.cow
La imagen de respaldo se dejará intacta y se registrarán mutaciones en este almacenamiento en el archivo de imagen de superposición.
Cuando cambia la ruta de acceso a la imagen de respaldo, se requiere reparación.
Asegúrese de que la ruta de la imagen de respaldo original sigue conduciendo a esta imagen. Si es necesario, haga un enlace simbólico en la ruta original a la nueva ruta. A continuación, emita un comando como:
$ qemu-img rebase -b /new/img1.raw /new/img1.cow
A su discreción, usted puede alternativamente realizar un rebase 'inseguro' donde no se comprueba la ruta anterior a la imagen de respaldo:
$ qemu-img rebase -u -b /new/img1.raw /new/img1.cow
Cambiar el tamaño de una imagen
El ejecutable qemu-img
tiene la opción resize
, que permite redimensionar fácilmente una imagen de disco duro. Funciona tanto para raw como para qcow2. Por ejemplo, para aumentar el espacio de imagen en 10GB, ingresa:
$ qemu-img resize disk_image +10G
Después de ampliar la imagen de disco, debe utilizar el sistema de archivos y las herramientas de particionamiento dentro de la máquina virtual para comenzar a utilizar el nuevo espacio. Al reducir una imagen de disco, primero debe reducir los sistemas de archivos y los tamaños de partición asignados usando el sistema de archivos y las herramientas de partición dentro de la máquina virtual y luego reducir la imagen del disco en consecuencia, de lo contrario reducir la imagen del disco resultará en ¡pérdida de datos!
Preparando el medio de instalación
Para instalar un sistema operativo en su imagen de disco, necesita el medio de instalación (por ejemplo, disco óptico, unidad USB o imagen ISO) para el sistema operativo. El soporte de instalación no debe montarse porque QEMU accede directamente al medio.
/dev/cdrom
, puede volcarlo a un archivo de comandos: $ dd if=/dev/cdrom of=Cd_image.iso
Instalando el sistema operativo
Esta es la primera vez que necesitará iniciar el emulador. Para instalar el sistema operativo en la imagen de disco, debe adjuntar la imagen de disco y el medio de instalación a la máquina virtual y hacer que arranque desde el soporte de instalación.
Por ejemplo, en invitados i386, para instalar desde un archivo ISO de arranque como CD-ROM y una imagen de disco sin formato:
$ qemu-system-x86_64 -cdrom iso_image -boot order=d -drive file=disk_image,format=raw
Consulte qemu (1)
para obtener más información sobre cómo cargar otros tipos de medios (como disquetes, imágenes de disco o unidades físicas) y #Ejecución del sistema virtualizado para otras opciones útiles.
Una vez que el sistema operativo haya finalizado de instalar, la imagen de QEMU se puede iniciar directamente (ver #Ejecución del sistema virtualizado).
-m
, por ejemplo -m 512M
o -m 2G
.- En lugar de especificar
-boot order = x
, algunos usuarios pueden sentirse más cómodos usando un menú de arranque:-boot menu = on
, al menos durante la configuración y la experimentación. - Si necesita reemplazar disquetes o CD como parte del proceso de instalación, puede usar el monitor de la máquina QEMU (presione
Ctrl + Alt + 2
en la ventana de la máquina virtual) para quitar y conectar dispositivos de almacenamiento a un máquina virtual. Escribainfo block
para ver los dispositivos de bloque y use el comandochange
para intercambiar un dispositivo. PulseCtrl + Alt + 1
para volver a la máquina virtual.
Ejecución del sistema virtualizado
Los binarios qemu-system-*
(por e.j. qemu-system-i386
ó qemu-system-x86_64
, dependiendo de la arquitectura del huésped) se usan para ejecutar el sistema virtualizado. El uso es:
$ qemu-system-x86_64 options disk_image
Las opciones son las mismas para todos los binarios qemu-system-*
, mira qemu(1)
para más información sobre todas las opciones.
Por defecto, QEMU mostrará la salida de video de la máquina virtual en una ventana. Una cosa a considerar: al hacer click dentro de la ventana de QMEU, el puntero del cursor será capturado. Para liberarlo presione Ctrl+Alt+g
.
-runas
para que QEMU utilice privilegios de root.Activar KVM
KVM debe ser soportado por su procesador y kernel, y necesariamente los módulos del kernel deben ser cargados. Mira KVM para más información.
Para iniciar QEMU en modo KVM, adjunta -enable-kvm
a las opciones de inicio adicionales. Para verificar si KVM está activado para ejecutar una máquina virtual, ingresa a la wiki de QEMU Monitor, usando Ctrl+Alt+Shift+2
, e ingresando info kvm
.
- Si inicia su máquina virtual con una herramienta GUI y experimenta un rendimiento muy malo, debe verificar el soporte adecuado de KVM.
- KVM necesita activarse en orden de iniciar adecuadamente Windows 7 y Windows 8 sin pantallazo azul.
Habilitar soporte IOMMU (Intel VT-d/AMD-Vi)
Usando IOMMU (unidad de gestión de memoria de entrada y salida) se abre a las caraterísticas como el paso del PCI y la protección de la memoria de dispositivos defectuosos o maliciosos, mira wikipedia:Input-output memory management unit#Advantages y Memory Management (computer programming): Could you explain IOMMU in plain English?.
Para habilitar IOMMU:
- Asegure que AMD-Vi/Intel VT-d es soportado por el CPU y es habilitado en la configuración de BIOS.
- Agregue
intel_iommu=on
si tienes un procesador Intel óamd_iommu=on
si tienes un procesador AMD en los parámetros del kernel (kernel parameters) - Reinicie y asegure que IOMMU está habilitado verificando
dmesg
paraDMAR
:[0.000000] DMAR: IOMMU enabled
- Añade
-device intel-iommu
para crear el dispositivo IOMMU:
$ qemu-system-x86_64 -enable-kvm -machine q35 -device intel-iommu -cpu host ..
Mover datos entre el host y el Sistema Operativo huésped
Red
Los datos pueden compartirse entre el host y el sistema operativo huésped usando cualquier protocolo de red que pueda transferir archivos, como NFS, SMB, NBD, HTTP, FTP, ó SSH, siempre que haya configurado la red apropiadamente y haya habilitado los servicios apropiados.
La red por defecto del modo de usuario permite al huésped acceder al sistema operativo host en la dirección IP 10.0.2.2. Todos los servidores que se estén ejecutando en el sistema operativo anfitrión, como un servidor SSH o un servidor SMB, estarán accesibles en esta dirección IP. Así que en los invitados, puede montar los directorios exportados en el host a través de SMB o NFS, o puede acceder al servidor HTTP del host, etc. No será posible que el sistema operativo anfitrión acceda a los servidores que se ejecutan en el sistema operativo invitado, pero esto puede hacerse con otras configuraciones de red (consulte #Tap de red con QEMU).
Servidor SMB incorporado de QEMU
La documentación de QEMU dice que tiene un servidor SMB "incorporado", pero en realidad acaba de iniciar Samba con un archivo smb.conf
generado automáticamente ubicado en /tmp/qemu- Smb.Pid-0/smb.conf
y lo hace accesible para el invitado en una dirección IP diferente (10.0.2.4 por defecto). Esto sólo funciona para la red de usuarios, y esto no es necesariamente muy útil ya que el invitado también puede acceder al servicio normal Samba en el host si ha configurado acciones en él.
Para habilitar esta característica, inicie QEMU con un comando como:
$ qemu-system-x86_64 -nic user,id=nic0,smb=shared_dir_path disk_image
donde shared_dir_path
es un directorio que quieres compartir entre huésped y el host.
Luego, en el invitado, podrá acceder al directorio compartido del host 10.0.2.4 con el nombre de recurso "qemu". Por ejemplo, en el Explorador de Windows iría a \\ 10.0.2.4 \ qemu
.
- Si estás usando opciones de compartir varias veces como
-net user, smb= shared_dir_path1 -net user, smb= shared_dir_path2
ó-net user , Smb = shared_dir_path1 , smb = shared_dir_path2
entonces solo compartirá el último definido. - Si no puede acceder a la carpeta compartida y el sistema invitado es Windows, compruebe que está habilitado el protocolo NetBIOS [enlace roto 2023-05-06] Y que un cortafuegos no bloquea los puertos [2] utilizados por el protocolo NetBIOS.
Montaje de una partición dentro de una imagen de disco raw
Cuando la máquina virtual no se está ejecutando, es posible montar las particiones que están dentro de un archivo de imagen de disco sin formato configurándolas como dispositivos de bucle invertido. Esto no funciona con imágenes de disco en formatos especiales, como qcow2, aunque se pueden montar usando qemu-nbd
.
Con la especificación manual del desplazamiento de bytes
Una forma de montar una partición de imagen de disco es montar la imagen de disco en un cierto desplazamiento usando un comando como el siguiente:
$ mount -o loop, offset = 32256 disk_image mountpoint
La opción offset = 32256
se pasa realmente al programa losetup
para configurar un dispositivo de bucle invertido que empieza en el desplazamiento de byte 32256 del archivo y continúa hasta el final. A continuación, se monta este dispositivo de bucle invertido. También puede utilizar la opción sizelimit
para especificar el tamaño exacto de la partición, pero esto normalmente no es necesario.
Dependiendo de la imagen del disco, la partición necesaria no se puede iniciar en el desplazamiento 32256. Ejecute fdisk -l disk_image
para ver las particiones de la imagen. Fdisk da las compensaciones de inicio y fin en sectores de 512 bytes, así que multiplique por 512 para obtener el desplazamiento correcto para pasar a mount
.
Con las particiones autodetecting del módulo de bucle (loop)
El controlador de bucle de Linux realmente admite particiones en dispositivos de bucle invertido, pero está desactivado de forma predeterminada. Para habilitarlo, haga lo siguiente:
- Deshacerse de todos los dispositivos de bucle invertido (desmontar todas las imágenes montadas, etc.).
- Descargar el módulo del kernel
loop
y cargarlo con el conjunto de parámetrosmax_part = 15
. Además, el número máximo de dispositivos de bucle puede controlarse con el parámetromax_loop
.
/etc/modprobe.d
para cargar el módulo de bucle con max_part=15
cada vez, o puede poner loop.max_part = 15
en la línea de comandos del kernel, dependiendo de si tiene o no el módulo loop.ko
integrado en su kernel.Configure su imagen como un dispositivo de bucle invertido:
$ losetup -f -P disk_image
Entonces, si el dispositivo creado fue /dev/loop0
, se habrán creado automáticamente dispositivos adicionales /dev/loop0pX
, donde X es el número de la partición. Estos dispositivos de loopback de partición se pueden montar directamente. Por ejemplo:
$ mount /dev/loop0p1 punto de montaje
Para montar la imagen de disco con udisksctl , vea Udisks#Mount loop devices.
Con kpartx
'Kpartx' del paquete multipath-tools puede leer una tabla de particiones en un dispositivo y crear un nuevo dispositivo para cada partición. Por ejemplo: # Kpartx -a disk_image
Esto configurará el dispositivo de bucle invertido y creará los dispositivos de partición necesarios en /dev/mapper/
.
Montar una partición dentro de una imagen qcow2
Puede montar una partición dentro de una imagen qcow2 usando qemu-nbd
. Mira Wikibooks.
Utilizar cualquier partición real como la única partición primaria de una imagen de disco duro
A veces, puede que desee utilizar una de las particiones del sistema desde dentro de QEMU. El uso de una partición sin procesar para una máquina virtual mejorará el rendimiento, ya que las operaciones de lectura y escritura no pasan por la capa del sistema de archivos del host físico. Esta partición también proporciona una forma de compartir datos entre el host y el invitado.
En Arch Linux, los archivos de dispositivo para las particiones sin procesar son, por defecto, propiedad de root y del grupo disk . Si desea que un usuario no root pueda leer y escribir en una partición en bruto, debe cambiar el propietario del archivo de dispositivo de la partición para ese usuario.
- Aunque es posible, no se recomienda permitir que las máquinas virtuales alteren los datos críticos en el sistema host, como la partición raíz.
- No debe montar un sistema de archivos en una partición de lectura-escritura en el host y el invitado al mismo tiempo. De lo contrario, se producirá corrupción de datos.
Después de hacerlo, puede adjuntar la partición a una máquina virtual QEMU como un disco virtual.
Sin embargo, las cosas son un poco más complicadas si desea tener la máquina virtual completa contenida en una partición. En ese caso, no habría ningún archivo de imagen de disco para arrancar realmente la máquina virtual, ya que no se puede instalar un cargador de arranque en una partición que está formateada como un sistema de archivos y no como un dispositivo particionado con un MBR. Una máquina virtual de este tipo se puede iniciar especificando el kernel y el initramfs manualmente o simulando un disco con un MBR usando RAID lineal.
Especificar el kernel y el initrd manualmente
QEMU es compatible con cargar Linux kernels e init ramdisks directamente, evitando así los cargadores de arranque como GRUB. A continuación, se puede iniciar con la partición física que contiene el sistema de archivos raíz como el disco virtual, que no parecen ser particionados. Esto se hace emitiendo un comando similar al siguiente:
/dev/sda3
de sólo lectura (para proteger el sistema de archivos del host) y especifique /full/path/to/images
ó usar algún truco kexec en el invitado para recargar el kernel del invitado (extiende el tiempo de arranque).$ Qemu-system-i386 -kernel /boot/vmlinuz-linux -initrd /boot/initramfs-linux.img -append root=/dev/sda/dev/sda3
En el ejemplo anterior, la partición física que se utiliza para el sistema de archivos raíz del huésped es /dev/sda3
en el host, pero aparece como /dev/sda
en el invitado.
Por supuesto, puede especificar cualquier kernel e initrd que desee, y no sólo los que vienen con Arch Linux.
Cuando hay varios kernel parameters que se pasan a la opción -append
, necesitan ser citados usando comillas simples o dobles. Por ejemplo:
$ ... -append 'root=/dev/sda1 console=ttyS0'
Simular disco virtual con MBR usando RAID lineal
Una forma más complicada de tener una máquina virtual usar una partición física, mientras que mantener esa partición formateada como un sistema de archivos y no sólo tener la partición invitado la partición como si fuera un disco, es simular un MBR para que pueda Arranque utilizando un gestor de arranque tal como GRUB.
Puede hacerlo utilizando el RAID del software en modo lineal (necesita el controlador de kernel linear.ko
) y un dispositivo de loopback: el truco consiste en añadir previamente un registro maestro de arranque (MBR) Real que desea incrustar en una imagen de disco RAEM QEMU.
Suponga que tiene una partición simple /
con algún sistema de archivos en la que desea formar parte de una imagen de disco QEMU. En primer lugar, crear un pequeño archivo para mantener el MBR:
$ dd if=/dev/zero of=/path/to/mbr count=32
Aquí, se crea un archivo de 16 KB (32 * 512 bytes). Es importante no hacerlo demasiado pequeño (incluso si el MBR sólo necesita un bloque de 512 bytes), ya que cuanto menor sea, menor será el tamaño del chasis del dispositivo RAID de software, lo que podría tener un impacto En el rendimiento. A continuación, configura un dispositivo de bucle invertido en el archivo MBR:
# losetup -f /path/to/mbr
Supongamos que el dispositivo resultante es /dev/loop0
, porque ya no habríamos estado usando otros bucle. El siguiente paso es crear la imagen de disco "fusionada" MBR + /dev/hdaN
utilizando RAID de software:
# modprobe lineal
# mdadm --build --verbose /dev/md0 --chunk=16 --level=linear --raid-devices=2 /dev/loop0/dev/hdaN
El resultante /dev/md0
es lo que utilizará como una imagen de disco cruda QEMU (no olvide establecer los permisos para que el emulador pueda acceder a él). El último paso (y algo complicado) es configurar la configuración del disco (geometría del disco y tabla de particiones) para que el punto de inicio de la partición primaria en el MBR coincida con el de /dev/hdaN
} Dentro /dev/md0
(un desplazamiento de exactamente 16 * 512 = 16384 bytes en este ejemplo). Hacer esto usando fdisk
en la máquina host, no en el emulador: la rutina de detección de disco crudo predeterminada de QEMU a menudo da lugar a offsets redondeados no kilobyte (como 31.5 KB, como en la sección anterior) que No puede ser administrado por el código RAID de software. Por lo tanto, desde el anfitrión:
$ fdisk /dev/md0
Pulse X
para entrar en el menú de expertos. Establezca el número de sectores por pista para que el tamaño de un cilindro coincida con el tamaño de su archivo MBR. Para dos cabezas y un tamaño de sector de 512, el número de sectores por pista debe ser 16, por lo que obtenemos cilindros de tamaño 2x16x512 = 16k.
Ahora, presione R
para regresar al menú principal.
Presione P
y compruebe que el tamaño del cilindro es ahora 16k.
Ahora, cree una única partición primaria correspondiente a /dev/hdaN
. Debe comenzar en el cilindro 2 y terminar en el extremo del disco (tenga en cuenta que el número de cilindros ahora difiere de lo que era cuando se introdujo fdisk.
Finalmente, escribe el resultado al archivo: ya está. Ahora tiene una partición que puede montar directamente desde su host, así como parte de una imagen de disco QEMU:
$ Qemu-system-i386 -hdc /dev/md0 [...]
Por supuesto, puede configurar con seguridad cualquier cargador de arranque en esta imagen de disco utilizando QEMU, siempre que la partición original /dev/hdaN
contenga las herramientas necesarias.
Redes
El rendimiento de la red virtual debería ser mejor con los dispositivos de derivación (tap) y puentes que con la red en modo de usuario o vde porque los dispositivos de derivación y los puentes se implementan en el kernel.
Además, el rendimiento de la red se puede mejorar asignando a las máquinas virtuales un dispositivo de red virtio en lugar de la emulación predeterminada de una NIC e1000. Consulte #Instalación de controladores virtio para obtener más información.
Advertencia de dirección a nivel de enlace
Al asignar el argumento -net nic
a QEMU, asignará por defecto a una máquina virtual una interfaz de red con la dirección de enlace 52:54:00:12:34:56
. Sin embargo, cuando se utiliza la creación de redes puenteadas con varias máquinas virtuales, es esencial que cada máquina virtual tenga una dirección única de nivel de enlace (MAC) en el lado de la máquina virtual del dispositivo de derivación. De lo contrario, el puente no funcionará correctamente, ya que recibirá paquetes de varias fuentes que tienen la misma dirección de nivel de enlace. Este problema se produce incluso si los propios dispositivos de derivación tienen direcciones de nivel de enlace únicas porque la dirección de nivel de enlace de origen no se vuelve a escribir a medida que los paquetes pasan a través del dispositivo de derivación.
Asegúrese de que cada máquina virtual tiene una dirección única de nivel de enlace, pero siempre debe comenzar con 52:54:
. Utilice la opción siguiente, reemplazar X por un dígito hexadecimal arbitrario:
$ qemu-system-i386 -net nic,macaddr=52:54:XX:XX:XX:XX -net vde disk_image
Generar direcciones únicas de nivel de enlace se puede realizar de varias maneras:
- Especificar manualmente la dirección única de nivel de enlace para cada NIC. El beneficio es que el servidor DHCP asignará la misma dirección IP cada vez que se ejecute la máquina virtual, pero es inutilizable para un gran número de máquinas virtuales.
- Generar dirección de nivel de enlace aleatoria cada vez que se ejecuta la máquina virtual. Prácticamente cero probabilidad de colisiones, pero la desventaja es que el servidor DHCP asignará una dirección IP diferente cada vez. Puede utilizar el siguiente comando en una secuencia de comandos para generar una dirección de nivel de enlace aleatoria en una variable
macaddr
:printf -v macaddr "52:54:%02x:%02x:%02x:%02x" $(( $RANDOM & 0xff)) $(( $RANDOM & 0xff )) $(( $RANDOM & 0xff)) $(( $RANDOM & 0xff )) qemu-system-i386 -net nic,macaddr="$macaddr" -net vde disk_image
- Utilice el siguiente script
qemu-mac-hasher.py
para generar la dirección de nivel de enlace desde el nombre de la máquina virtual mediante una función de hash. Dado que los nombres de las máquinas virtuales son únicos, este método combina los beneficios de los métodos antes mencionados: genera la misma dirección de nivel de enlace cada vez que se ejecuta el script, aunque preserva la probabilidad prácticamente nula de colisiones.qemu-mac-hasher.py
#!/usr/bin/env python import sys import zlib if len(sys.argv) != 2: print("usage: %s <VM Name>" % sys.argv[0]) sys.exit(1) crc = zlib.crc32(sys.argv[1].encode("utf-8")) & 0xffffffff crc = str(hex(crc))[2:] print("52:54:%s%s:%s%s:%s%s:%s%s" % tuple(crc))
En un script, puede utilizar por ejemplo:
vm_name="VM Name" qemu-system-i386 -name "$vm_name" -net nic,macaddr=$(qemu-mac-hasher.py "$vm_name") -net vde disk_image
Redes en modo de usuario
De forma predeterminada, sin ningún argumento -netdev
, QEMU utilizará la red en modo usuario con un servidor DHCP incorporado. A sus máquinas virtuales se les asignará una dirección IP cuando ejecuten su cliente DHCP, y podrán acceder a la red del host físico a través de la mascarada de IP realizada por QEMU.
ping
, no funcionará. No utilice ping
para probar la conectividad de red.Esta configuración predeterminada permite que sus máquinas virtuales accedan fácilmente a Internet, siempre que el host esté conectado a él, pero las máquinas virtuales no estarán directamente visibles en la red externa ni las máquinas virtuales podrán comunicarse entre sí si empieza Más de uno simultáneamente.
La red de usuario en modo QEMU puede ofrecer más capacidades, como servidores TFTP o SMB incorporados, redirigir los puertos del host al huésped (por ejemplo, para permitir conexiones SSH al invitado) o conectar invitados a las VLAN para que puedan hablar entre sí. Consulte la documentación de QEMU en el indicador -net user
para obtener más detalles.
Sin embargo, la conexión en red en modo usuario tiene limitaciones tanto en la utilidad como en el rendimiento. Las configuraciones de red más avanzadas requieren el uso de dispositivos de derivación u otros métodos.
Tap de red con QEMU
Los dispositivos tap Son una característica del kernel de Linux que le permite crear interfaces de red virtuales que aparecen como interfaces de red reales. Los paquetes enviados a una interfaz de derivación se entregan a un programa de espacio de usuario, tal como QEMU, que se ha enlazado a la interfaz.
QEMU puede utilizar la red de derivación para una máquina virtual de modo que los paquetes enviados a la interfaz de derivación se envíen a la máquina virtual y aparezcan como procedentes de una interfaz de red (normalmente una interfaz Ethernet) en la máquina virtual. Por el contrario, todo lo que la máquina virtual envía a través de su interfaz de red aparecerá en la interfaz de tap.
Los dispositivos de toque son soportados por los controladores de puente de Linux, por lo que es posible conectar entre sí los dispositivos entre sí y posiblemente con otras interfaces de host como eth0
. Esto es deseable si desea que sus máquinas virtuales puedan hablar entre sí, o si desea que otras máquinas en su LAN puedan hablar con las máquinas virtuales.
eth0
, las máquinas virtuales aparecerán directamente en la red externa, lo que los exponerá a posibles ataques. Dependiendo de los recursos a los que tengan acceso sus máquinas virtuales, es posible que tenga que tomar todas las precauciones que normalmente tomaría al asegurar una computadora para proteger sus máquinas virtuales. Si el riesgo es demasiado grande, las máquinas virtuales tienen pocos recursos o se configuran varias máquinas virtuales, una solución mejor podría ser utilizar #Red de host solamente y configurar NAT. En este caso sólo necesitará un firewall en el host en lugar de múltiples firewalls para cada huésped.Como se indica en la sección de conexión en red de modo de usuario, los dispositivos de derivación ofrecen un rendimiento de red más alto que el modo de usuario. Si el OS invitado admite el controlador de red virtio, el rendimiento de la red se incrementará considerablemente también. Suponiendo el uso del dispositivo tap0, que el controlador virtio se utiliza en el invitado, y que no se utilizan scripts para ayudar a iniciar / detener la creación de redes, a continuación es parte del comando qemu se debe ver:
-net nic, model=virtio -net tap, ifname=tap0, script=no, downscript=no
Pero si ya está utilizando un dispositivo de tap con virtio controlador de red, uno puede incluso aumentar el rendimiento de la red mediante la activación de vhost, como:
-net nic, model=virtio -net tap, ifname=tap0, script=no, downscript=no, vhost=on
Ver http://www.linux-kvm.com/content/how-maximize-virtio-net-performance-vhost-net para obtener más información.
Red de host solamente
Si al puente se le da una dirección IP y se permite el tráfico destinado a ello, pero no hay una interfaz real (por ejemplo, eth0
) conectada al puente, las máquinas virtuales podrán hablar entre sí y la Sistema anfitrión. Sin embargo, no podrán hablar con nada en la red externa, siempre y cuando no configure IP enmascarada en el host físico. Esta configuración se llama red de host solamente por otro software de virtualización como VirtualBox.
- Si desea configurar IP masquerading, ej. NAT para máquinas virtuales, consulte la página Internet sharing#Enable NAT.
- Es posible que desee tener un servidor DHCP que se ejecute en la interfaz de puente para dar servicio a la red virtual. Por ejemplo, para usar la subred
172.20.0.1/16
con dnsmasq como servidor DHCP:
# ip addr add 172.20.0.1/16 dev br0 # ip link set br0 up # dnsmasq --interface=br0 --bind-interfaces --dhcp-range=172.20.0.2,172.20.255.254
Red interna
Si no le da al puente una dirección IP y agrega una regla iptables para eliminar todo el tráfico al puente en la cadena INPUT, las máquinas virtuales podrán hablar entre sí, pero no con el host físico ó la red exterior. Esta configuración se llama "red interna" por otro software de virtualización como VirtualBox. Deberá asignar direcciones IP estáticas a las máquinas virtuales o ejecutar un servidor DHCP en una de ellas.
De forma predeterminada, iptables eliminaría los paquetes de la red de bridge. Es posible que necesite utilizar dicha regla iptables para permitir paquetes en una red puenteada:
# iptables -I FORWARD -m physdev --physdev-is-bridged -j ACCEPT
Redes puenteadas usando qemu-bridge-helper
Este método no requiere una secuencia de comandos de inicio y acepta fácilmente múltiples tomas y puentes múltiples. Utiliza el binario /usr/lib/qemu/qemu-bridge-helper
, que permite crear dispositivos de derivación en un puente existente.
En primer lugar, cree un archivo de configuración que contenga los nombres de todos los puentes que QEMU utilizará:
/etc/qemu/bridge.conf
allow bridge0 allow bridge1 ...
Ahora inicie la VM. El uso más básico sería:
$ qemu-system-i386 -net nic -net bridge,br=bridge0 [...]
Con múltiples taps, el uso más básico requiere especificar la VLAN para todos los NIC adicionales:
$ qemu-system-i386 -net nic -net bridge,br=bridge0 -net nic,vlan=1 -net bridge,vlan=1,br=bridge1 [...]
Creación manual del puente
A continuación se describe cómo conectar una máquina virtual con una interfaz de host como eth0
, que es probablemente la configuración más común. Esta configuración hace que parezca que la máquina virtual está ubicada directamente en la red externa, en el mismo segmento Ethernet que la máquina host física.
Vamos a reemplazar el adaptador Ethernet normal con un adaptador de puente y enlazar el adaptador Ethernet normal a él.
- Instale bridge-utils, que proporciona
brctl
para manipular puentes.
- Habilitar el reenvío IPv4:
# sysctl net.ipv4.ip_forward=1
Para hacer el cambio permanente, cambie net.ipv4.ip_forward = 0
a net.ipv4.ip_forward = 1
en /etc/sysctl.d/99-sysctl.conf
.
- Cargue el módulo
tun
y configurelo para cargarlo en el arranque. Véase Kernel modules (Español) para más detalles.
- Ahora cree el puente. Ver Bridge with netctl para más detalles. Recuerde nombrar su puente como
br0
, o modifique lo scripts a continuación del nombre del puente.
- Cree el script que QEMU utiliza para abrir el adaptador de toma con los permisos
root:kvm
750:
/etc/qemu-ifup
#!/bin/sh echo "Executing /etc/qemu-ifup" echo "Bringing up $1 for bridged mode..." sudo /usr/bin/ip link set $1 up promisc on echo "Adding $1 to br0..." sudo /usr/bin/brctl addif br0 $1 sleep 2
- Cree el guión que QEMU utiliza para derribar el adaptador de toma en
/etc/qemu-ifdown
con los permisosroot:kvm
750:
/etc/qemu-ifdown
#!/bin/sh echo "Executing /etc/qemu-ifdown" sudo /usr/bin/ip link set $1 down sudo /usr/bin/brctl delif br0 $1 sudo /usr/bin/ip link delete dev $1
- Use
visudo
para añadir lo siguiente a el archivosudoers
:
Cmnd_Alias QEMU=/usr/bin/ip,/usr/bin/modprobe,/usr/bin/brctl %kvm ALL=NOPASSWD: QEMU
- Se inicia QEMU con el siguiente script
run-qemu
:
run-qemu
#!/bin/bash USERID=$(whoami) # Get name of newly created TAP device; see https://bbs.archlinux.org/viewtopic.php?pid=1285079#p1285079 precreationg=$(/usr/bin/ip tuntap list | /usr/bin/cut -d: -f1 | /usr/bin/sort) sudo /usr/bin/ip tuntap add user $USERID mode tap postcreation=$(/usr/bin/ip tuntap list | /usr/bin/cut -d: -f1 | /usr/bin/sort) IFACE=$(comm -13 <(echo "$precreationg") <(echo "$postcreation")) # This line creates a random MAC address. The downside is the DHCP server will assign a different IP address each time printf -v macaddr "52:54:%02x:%02x:%02x:%02x" $(( $RANDOM & 0xff)) $(( $RANDOM & 0xff )) $(( $RANDOM & 0xff)) $(( $RANDOM & 0xff )) # Instead, uncomment and edit this line to set a static MAC address. The benefit is that the DHCP server will assign the same IP address. # macaddr='52:54:be:36:42:a9' qemu-system-i386 -net nic,macaddr=$macaddr -net tap,ifname="$IFACE" $* sudo ip link set dev $IFACE down &> /dev/null sudo ip tuntap del $IFACE mode tap &> /dev/null
Para ejecutar una VM, haz algo como esto:
$ run-qemu -hda myvm.img -m 512 -vga std
- Se recomienda, por motivos de rendimiento y seguridad, deshabilitar el firewall en el puente:
/etc/sysctl.d/10-disable-firewall-on-bridge.conf
net.bridge.bridge-nf-call-ip6tables = 0 net.bridge.bridge-nf-call-iptables = 0 net.bridge.bridge-nf-call-arptables = 0
Ejecute sysctl -p /etc/sysctl.d/10-disable-firewall-on-bridge.conf
para aplicar los cambios inmediatamente.
Ver libvirt wiki y Fedora bug 512206. Si obtiene errores de sysctl durante el inicio de archivos no existentes, haga que el módulo bridge
se cargue al arrancar. Véase Kernel module (Español)#systemd.
Como alternativa, puede configurar iptables para permitir que todo el tráfico se reenvíe a través del puente mediante la adición de una regla como esta:
-I FORWARD -m physdev --physdev-is-bridged -j ACCEPT
Compartición de red entre dispositivo físico y un dispositivo de toque a través de iptables
La conexión en puente funciona bien entre una interfaz cableada (por ejemplo, eth0), y es fácil de configurar. Sin embargo, si el host se conecta a la red a través de un dispositivo inalámbrico, el puente no es posible.
Consulte Network bridge#Wireless interface on a bridge como referencia.
Una forma de superar esto es configurar un dispositivo de derivación con una IP estática, haciendo que linux maneje automáticamente el enrutamiento para ella y, a continuación, reenvíe el tráfico entre la interfaz de derivación y el dispositivo conectado a la red a través de las reglas de iptables.
Consulte Internet sharing como referencia.
Allí puede encontrar lo que se necesita para compartir la red entre dispositivos, incluidos los de tap y tun. Lo siguiente sólo indica algunas de las configuraciones de host requeridas. Como se indica en la referencia anterior, el cliente debe configurarse para una IP estática, utilizando la IP asignada a la interfaz de derivación como puerta de enlace. La advertencia es que los servidores DNS del cliente pueden necesitar ser editados manualmente si cambian al cambiar de un dispositivo host conectado a la red a otro.
Para permitir el reenvío de IP en cada inicio, es necesario agregar las siguientes líneas al archivo de configuración de sysctl dentro de /etc/sysctl.d:
net.ipv4.ip_forward = 1 net.ipv6.conf.default.forwarding = 1 net.ipv6.conf.all.forwarding = 1
Las reglas de iptables pueden verse así:
# Forwarding from/to outside iptables -A FORWARD -i ${INT} -o ${EXT_0} -j ACCEPT iptables -A FORWARD -i ${INT} -o ${EXT_1} -j ACCEPT iptables -A FORWARD -i ${INT} -o ${EXT_2} -j ACCEPT iptables -A FORWARD -i ${EXT_0} -o ${INT} -j ACCEPT iptables -A FORWARD -i ${EXT_1} -o ${INT} -j ACCEPT iptables -A FORWARD -i ${EXT_2} -o ${INT} -j ACCEPT # NAT/Masquerade (network address translation) iptables -t nat -A POSTROUTING -o ${EXT_0} -j MASQUERADE iptables -t nat -A POSTROUTING -o ${EXT_1} -j MASQUERADE iptables -t nat -A POSTROUTING -o ${EXT_2} -j MASQUERADE
El anterior supone que hay 3 dispositivos conectados a la red compartiendo tráfico con un dispositivo interno, donde por ejemplo:
INT=tap0 EXT_0=eth0 EXT_1=wlan0 EXT_2=tun0
El anterior muestra un reenvío que permitiría compartir conexiones cableadas e inalámbricas con el dispositivo de derivación (tap).
Las reglas de reenvío que se muestran son apátridas y para el reenvío puro. Se podría pensar en restringir el tráfico específico, poniendo un cortafuegos en el lugar para proteger al huésped y otros. Sin embargo, esto reduciría el rendimiento de la red, mientras que un simple puente no incluye nada de eso.
Bonus: Si la conexión es cableada o inalámbrica, si se conecta a través de VPN a un sitio remoto con un dispositivo tun, suponiendo que el dispositivo tun abierto para esa conexión es tun0, y las reglas iptables anteriores se aplican, entonces la conexión remota se obtiene también Compartido con el huésped. Esto evita la necesidad de que el invitado también abra una conexión VPN. Una vez más, como la red de invitados debe ser estática, entonces si la conexión del host de forma remota de esta manera, uno probablemente tendrá que editar los servidores DNS en el invitado.
Trabajo en red con VDE2
¿Qué es VDE?
VDE significa Virtual Distributed Ethernet. Comenzó como una mejora del interruptor uml _. Es una caja de herramientas para administrar redes virtuales.
La idea es crear interruptores virtuales, que son básicamente sockets, y "conectar" tanto máquinas físicas como máquinas virtuales en ellas. La configuración que mostramos aquí es bastante simple; Sin embargo, VDE es mucho más potente que esto, puede conectar conmutadores virtuales juntos, ejecutarlos en diferentes hosts y supervisar el tráfico en los switches. Usted está invitado a leer la documentación del proyecto.
La ventaja de este método es que no tienes que agregar privilegios de sudo a tus usuarios. No se debe permitir que los usuarios regulares ejecuten modprobe.
Basics
El soporte de VDE puede ser instalado a través del paquete vde2 en los repositorios oficiales.
En nuestra configuración, usamos tun/tap para crear una interfaz virtual en el host. Cargue el módulo tun
(véase kernel modules (Español) para obtener más detalles):
# modprobe tun
Ahora crea el conmutador virtual:
# vde_switch -tap tap0 -daemon -mod 660 -group users
Esta línea crea el switch, crea tap0
, lo "enchufa" y permite a los usuarios del grupo users
usarlo.
La interfaz está conectada pero no está configurada todavía. Para configurarlo, ejecute este comando:
# ip addr add 192.168.100.254/24 dev tap0
Ahora, sólo tiene que ejecutar KVM con estas opciones -net
como usuario normal:
$ qemu-system-i386 -net nic -net vde -hda [...]
Configure la red para su invitado como lo haría en una red física.
Startup scripts
Ejemplo de script principal que inicia VDE:
/etc/systemd/scripts/qemu-network-env
#!/bin/sh # Preparación del entorno de red QEMU/VDE # La configuración IP del dispositivo de derivación que se utilizará para # La red de la máquina virtual: TAP_DEV=tap0 TAP_IP=192.168.100.254 TAP_MASK=24 TAP_NETWORK=192.168.100.0 # Host interface NIC=eth0 case "$1" in start) echo -n "Starting VDE network for QEMU: " # If you want tun kernel module to be loaded by script uncomment here #modprobe tun 2>/dev/null ## Wait for the module to be loaded #while ! lsmod | grep -q "^tun"; do echo "Waiting for tun device"; sleep 1; done # Start tap switch vde_switch -tap "$TAP_DEV" -daemon -mod 660 -group users # Bring tap interface up ip address add "$TAP_IP"/"$TAP_MASK" dev "$TAP_DEV" ip link set "$TAP_DEV" up # Start IP Forwarding echo "1" > /proc/sys/net/ipv4/ip_forward iptables -t nat -A POSTROUTING -s "$TAP_NETWORK"/"$TAP_MASK" -o "$NIC" -j MASQUERADE ;; stop) echo -n "Stopping VDE network for QEMU: " # Delete the NAT rules iptables -t nat -D POSTROUTING "$TAP_NETWORK"/"$TAP_MASK" -o "$NIC" -j MASQUERADE # Bring tap interface down ip link set "$TAP_DEV" down # Kill VDE switch pgrep -f vde_switch | xargs kill -TERM ;; restart|reload) $0 stop sleep 1 $0 start ;; *) echo "Usage: $0 {start|stop|restart|reload}" exit 1 esac exit 0
Ejemplo de servicio systemd utilizando el script anterior:
/etc/systemd/system/qemu-network-env.service
[Unit] Description=Manage VDE Switch [Service] Type=oneshot ExecStart=/etc/systemd/scripts/qemu-network-env start ExecStop=/etc/systemd/scripts/qemu-network-env stop RemainAfterExit=yes [Install] WantedBy=multi-user.target
Cambiar permisos de qemu-network-env
para ser ejecutable
# chmod u+x /etc/systemd/scripts/qemu-network-env
Puede iniciar qemu-network-env.service
como de costumbre.
Método alternativo
Si el método anterior no funciona o no quiere meterse con las configuraciones del kernel, TUN, dnsmasq e iptables, puede hacer lo siguiente para obtener el mismo resultado.
# vde_switch -daemon -mod 660 -group users # slirpvde --dhcp --daemon
A continuación, para iniciar la VM con una conexión a la red del host:
$ qemu-system-i386 -net nic,macaddr=52:54:00:00:EE:03 -net vde disk_image
Puente VDE2
Basado en quickhowto: qemu networking using vde, tun/tap, and bridge gráfico. Cualquier máquina virtual conectada a vde está expuesta externamente. Por ejemplo, cada máquina virtual puede recibir la configuración DHCP directamente desde su enrutador ADSL.
Conceptos básicos
Recuerde que necesita el módulo tun
y el paquete bridge-utils.
Cree el dispositivo vde2/tap:
# vde_switch -tap tap0 -daemon -mod 660 -group users # ip link set tap0 up
Cree el puente:
# brctl addbr br0
Agregue dispositivos:
# brctl addif br0 eth0 # brctl addif br0 tap0
Y configure la interfaz del puente:
# dhcpcd br0
Startup scripts
Todos los dispositivos deben estar configurados. Y sólo el puente necesita una dirección IP. Para dispositivos físicos en el puente (por ejemplo, eth0
), esto puede hacerse con netctl utilizando un perfil Ethernet personalizado con:
/etc/netctl/ethernet-noip
Description='A more versatile static Ethernet connection' Interface=eth0 Connection=ethernet IP=no
El siguiente servicio systemd personalizado puede utilizarse para crear y activar una interfaz de toma VDE2 para su uso en el grupo de usuarios users
.
/etc/systemd/system/vde2@.service
[Unit] Description=Network Connectivity for %i Wants=network.target Before=network.target [Service] Type=oneshot RemainAfterExit=yes ExecStart=/usr/bin/vde_switch -tap %i -daemon -mod 660 -group users ExecStart=/usr/bin/ip link set dev %i up ExecStop=/usr/bin/ip addr flush dev %i ExecStop=/usr/bin/ip link set dev %i down [Install] WantedBy=multi-user.target
Y, por último, puede crear el puente interfaz con netctl.
Gráficos
QEMU puede utilizar las siguientes salidas gráficas diferentes: std
, qxl
, vmware
, virtio
, cirrus
y none
.
std
Con -vga std
puede obtener una resolución de hasta 2560 x 1600 píxeles sin necesidad de controladores invitados. Este es el valor predeterminado desde QEMU 2.2.
qxl
QXL Es un controlador de gráficos paravirtual con soporte 2D. Para usarlo, pase la opción -vga qxl
e instale los controladores en el invitado. Es posible que desee utilizar SPICE para mejorar el rendimiento gráfico al utilizar QXL.
En los invitados de Linux, los módulos del kernel qxl
y bochs_drm
deben ser inicializados para poder tener un rendimiento decente.
SPICE
El proyecto SPICE tiene como objetivo proporcionar una solución completa de código abierto para el acceso remoto a máquinas virtuales de una manera transparente.
SPICE sólo se puede utilizar cuando se utiliza QXL como la salida gráfica.
El siguiente es un ejemplo de arranque con SPICE como protocolo de escritorio remoto:
$ qemu-system-i386 -vga qxl -spice port=5930,disable-ticketing -chardev spicevm
Conéctese al invitado utilizando un cliente SPICE. En este momento se recomienda spice-gtk, sin embargo otros clientes, incluyendo otras plataformas, están disponibles:
$ spicy -h 127.0.0.1 -p 5930
El uso de Unix sockets en lugar de los puertos TCP no implica el uso de pila de red en el sistema host, por lo que es Sockets-vs-tcp-ports según se informa mejor para el rendimiento. Ejemplo:
$ qemu-system-x86_64 -vga qxl -device virtio-serial-pci -device virtserialport,chardev=spicechannel0,name=com.redhat.spice.0 -chardev spicevmc,id=spicechannel0,name=vdagent -spice unix,addr=/tmp/vm_spice.socket,disable-ticketing $ spicy --uri="spice+unix:///tmp/vm_spice.socket"
Para una mejor compatibilidad con varios monitores, compartir el portapapeles, etc., los paquetes siguientes deben estar instalados en el invitado:
- spice-vdagent: Spice agent xorg cliente que permite copiar y pegar entre el cliente y X-session y más
- xf86-video-qxl xf86-video-qxl-gitAUR: Xorg X11 qxl controlador de vídeo
- Para otros sistemas operativos, mire la sección Guest de la página SPICE-Space download.
vmware
Aunque tiene pocos errores, tiene mejor rendimiento que std y cirrus. Instale los controladores de VMware xf86-video-vmware y xf86-input-vmmouse para los invitados de Arch Linux.
virtio
virtio-vga
/ virtio-gpu
Es un controlador de gráficos 3D paravirtual basado en virgl. Actualmente un trabajo en curso, que sólo admite a invitados Linux (>= 4.4) con mesa (>= 11.2) compilados con la opción --with-gallium-drivers=virgl
.
Para activar la aceleración 3D en el sistema invitado, seleccione vga con -vga virtio
y habilitar el contexto opengl en el dispositivo de visualización con -display sdl,gl=on
ó -display gtk,gl=on
Para la salida de pantalla sdl y gtk respectivamente. La configuración correcta se puede confirmar mirando el registro del kernel en el invitado:
# dmesg | grep drm
[drm] pci: virtio-vga detected [drm] virgl 3d acceleration enabled
A partir de septiembre de 2016, el soporte para el protocolo de especias está en desarrollo y se puede probar la instalación de la versión de desarrollo de spice (>= 0.13.2) y la recompilación de qemu.
Para más información visite blog de kraxel.
cirrus
El adaptador gráfico cirrus fue el predeterminado before 2.2. no debería utilizarse en sistemas modernos.
none
Esto es como un PC que no tiene tarjeta VGA en absoluto. Ni siquiera podrías acceder a ella con la opción -vnc
. Además, esto es diferente de la opción -nographic
que permite a QEMU emular una tarjeta VGA, pero deshabilita la visualización SDL.
vnc
Dado que usó la opción -nographic
, puede agregar la opción -vnc display
para que QEMU escuche en display
y redirigir la pantalla VGA a la sesión VNC . Hay un ejemplo de esto en las configuraciones de ejemplo de la sección #Inicio de las máquinas virtuales QEMU en el arranque.
$ qemu-system-i386 -vga std -nographic -vnc :0 $ gvncviewer :0
Al usar VNC, puede experimentar problemas de teclado descritos (en detalles gory) aquí. La solución es "no" usar la opción -k
en QEMU y usar gvncviewer
de gtk-vnc. Ver también este mensaje publicado en la lista de correo de libvirt.
Audio
Host
El controlador de audio utilizado por QEMU se establece con la variable de entorno QEMU_AUDIO_DRV
:
$ export QEMU_AUDIO_DRV=pa
Ejecute el siguiente comando para obtener las opciones de configuración de QEMU relacionadas con PulseAudio:
$ qemu-system-x86_64 -audio-help | awk '/Name: pa/' RS=
Las opciones listadas se pueden exportar como variables de entorno, por ejemplo:
$ export QEMU_PA_SINK=alsa_output.pci-0000_04_01.0.analog-stereo.monitor $ export QEMU_PA_SOURCE=input
Invitado
Para obtener la lista de los controladores de audio de emulación compatibles:
$ qemu-system-x86_64 -soundhw help
Para usar (ej. hda
) para el invitado utilice el comando -soundhw hda
con QEMU.
qemu-system-x86_64 -h
.VirtIO sound
VirtIO sound está disponible desde la versión 8.2.0 de QEMU. El uso es:
-device virtio-sound-pci,audiodev=my_audiodev -audiodev alsa,id=my_audiodev
Para más información, consulte la documentación de QEMU.
Instalación de controladores virtio
QEMU ofrece a los clientes la posibilidad de utilizar dispositivos bloqueados y de red paravirtualizados utilizando los controladores virtio, que proporcionan un mejor rendimiento y menores gastos generales.
Un dispositivo virtio bloque requiere la opción -drive
en lugar del simple -hd *
más if=virtio
:
$ qemu-system-i386 -boot order=c -drive file=disk_image,if=virtio
-boot order=c
es absolutamente necesario cuando se desea arrancar desde él. No hay detección automática como con -hd*
.- Casi de la misma manera para la red:
$ qemu-system-i386 -net nic,model=virtio
Preparando a Arch Linux como invitado
Para utilizar los dispositivos virtio después de instalar un invitado de Arch Linux, se deben cargar en el invitado los siguientes módulos: virtio
, virtio_pci
, virtio_blk
, Virtio_net
, y virtio_ring
. Para los huéspedes de 32 bits, no es necesario el módulo "virtio" específico.
Si desea arrancar desde un disco virtio, el disco ramd inicial debe contener los módulos necesarios. De forma predeterminada, esto es manejado por el gancho autodetect
de mkinitcpio. De lo contrario, utilice la matriz MODULES
en /etc/mkinitcpio.conf
para incluir los módulos necesarios y reconstruir el disco ramd inicial.
/etc/mkinitcpio.conf
MODULES="virtio virtio_blk virtio_pci virtio_net"
Los discos Virtio se reconocen con el prefijo v
(ej. v da
, v db
, etc.); Por lo tanto, los cambios deben realizarse al menos en /etc/fstab
y /boot/grub/grub.cfg
al arrancar desde un disco virtio.
/etc/fstab
y bootloader, no hay nada que hacer.Se puede encontrar más información sobre la paravirtualización con KVM aquí.
También puede instalar qemu-guest-agent para implementar la compatibilidad con los comandos QMP que mejorarán las capacidades de administración del hipervisor. Después de instalar el paquete, puedes habilitar e iniciar el qemu-ga.service
.
Preparar un invitado de Windows
Bloquear controladores de dispositivo
Nueva instalación de Windows
Windows no viene con los controladores virtio. Por lo tanto, tendrá que cargarlos durante la instalación. Hay básicamente dos maneras de hacer esto: vía disco blando o vía archivos de ISO. Ambas imágenes se pueden descargar desde el repositorio Fedora.
La opción del disquete es difícil porque necesitará presionar F6 (Shift-F6 en Windows más reciente) al inicio de la alimentación del QEMU. Esto es difícil ya que necesitas tiempo para conectar tu ventana de consola VNC. Puede intentar agregar un retardo a la secuencia de arranque. Consulte man qemu-system
para obtener más detalles sobre la aplicación de un retardo en el arranque.
La opción ISO para cargar los controladores es la forma preferida, pero está disponible sólo en Windows Vista y Windows Server 2008 y versiones posteriores. El procedimiento consiste en cargar la imagen con controladores virtio en un dispositivo de cdrom adicional junto con el dispositivo de disco principal y el instalador de Windows:
$ qemu-system-i386 ... \ -drive file=/path/to/primary/disk.img,index=0,media=disk,if=virtio \ -drive file=/path/to/installer.iso,index=2,media=cdrom \ -drive file=/path/to/virtio.iso,index=3,media=cdrom \ ...
Durante la instalación, el instalador de Windows le pedirá su clave de producto y realizará algunas comprobaciones adicionales. Cuando llegue a la "¿Dónde desea instalar Windows?" Pantalla, dará una advertencia de que no se encuentran discos. Siga las instrucciones de ejemplo siguientes (basadas en Windows Server 2012 R2 con Actualización).
- Seleccione la opción
Load Drivers
. - Desactive la casilla de "Ocultar los controladores que no son compatibles con el hardware de este equipo".
- Haga clic en el botón Examinar y abra el CDROM para la virtio iso, normalmente llamada "virtio-win-XX".
- Ahora vaya a
E:\viostor\[your-os]\amd64
, seleccione y pulse OK. - Click Next
Ahora debería ver sus discos virtio listados aquí, listos para ser seleccionados, formateados e instalados.
Cambiar la máquina virtual existente de Windows para utilizar virtio
Modificar un invitado de Windows existente para arrancar desde disco virtio es un poco difícil.
Puede descargar el controlador de disco virtio desde el repositorio de Fedora.
Ahora necesita crear una nueva imagen de disco, que llene la fuerza de Windows para buscar el controlador. Por ejemplo:
$ qemu-img create -f qcow2 fake.qcow2 1G
Ejecute el invitado original de Windows (con el disco de inicio todavía en modo IDE) con el disco falso (en modo virtio) y un CD-ROM con el controlador.
$ qemu-system-i386 -m 512 -vga std -drive file=windows_disk_image,if=ide -drive file=fake.qcow2,if=virtio -cdrom virtio-win-0.1-81.iso
Windows detectará el disco falso y tratará de encontrar un controlador para ello. Si falla, vaya al Administrador de dispositivos , busque la unidad SCSI con un icono de signo de exclamación (debe estar abierto), haga clic en Actualizar controlador y seleccione el CD-ROM virtual. No olvide seleccionar la casilla de verificación que dice que debe buscar directorios recursivamente.
Cuando la instalación se realiza correctamente, puede apagar la máquina virtual y volver a iniciarla, ahora con el disco de arranque conectado en modo virtio:
$ qemu-system-i386 -m 512 -vga std -drive file=windows_disk_image,if=virtio
-m
y de que no arranca con virtio en lugar de ide para la unidad del sistema antes de instalar los controladores.Controladores de red
La instalación de los controladores de red virtio es un poco más fácil, simplemente agregue el argumento -net
como se explicó anteriormente.
$ qemu-system-i386 -m 512 -vga std -drive file=windows_disk_image,if=virtio -net nic,model=virtio -cdrom virtio-win-0.1-74.iso
Windows detectará el adaptador de red y tratará de encontrar un controlador para ello. Si falla, vaya al Administrador de dispositivos, localice el adaptador de red con un icono de signo de exclamación (debe estar abierto), haga clic en Actualizar controlador y seleccione el CD-ROM virtual. No olvide seleccionar la casilla de verificación que dice que debe buscar directorios recursivamente.
Preparación de FreeBSD como invitado
Instale el puerto emulators/virtio-kmod
si está utilizando FreeBSD 8.3 o posterior hasta 10.0-CURRENT donde están incluidos en el kernel. Después de la instalación, añada lo siguiente a su archivo /boot/loader.conf
:
virtio_loader="YES" virtio_pci_load="YES" virtio_blk_load="YES" if_vtnet_load="YES" virtio_balloon_load="YES"
A continuación, modifique su /etc/fstab
haciendo lo siguiente:
sed -i bak "s/ada/vtbd/g" /etc/fstab
Y verificar que /etc/fstab
es consistente. Si algo sale mal, sólo arranque en un CD de rescate y copie /etc/fstab.bak
de vuelta a /etc/fstab
.
Consejos y trucos
Inicio de las máquinas virtuales QEMU en el arranque
Con libvirt
Si se configura una máquina virtual con libvirt, se puede configurar a través de la interfaz gráfica de usuario de virt-manager para iniciar en el arranque de host, accediendo a las Opciones de arranque de la máquina virtual y seleccionando "Inicio de la máquina virtual en el arranque del host".
Script personalizado
Para ejecutar QEMU VMs al arrancar, puede usar las siguientes unidades systemd y config.
/etc/systemd/system/qemu@.service
[Unit] Description=QEMU virtual machine [Service] Environment="type=system-x86_64" "haltcmd=kill -INT $MAINPID" EnvironmentFile=/etc/conf.d/qemu.d/%i ExecStart=/usr/bin/env qemu-${type} -name %i -nographic $args ExecStop=/bin/sh -c ${haltcmd} TimeoutStopSec=30 KillMode=none [Install] WantedBy=multi-user.target
systemd.service (5)
y systemd.kill (5)
man, es necesario utilizar KillMode=none
opción. De lo contrario, el proceso qemu principal se eliminará inmediatamente después de que se cierre el comando ExecStop
(simplemente hace eco de una cadena) y su sistema de búsqueda no podrá apagarse correctamente.A continuación, cree archivos de configuración por-VM, denominados /etc/conf.d/qemu.d/vm_name
, con las siguientes variables establecidas:
- type
- QEMU binary to call. If specified, will be prepended with
/usr/bin/qemu-
and that binary will be used to start the VM. I.e. you can boot e.g.qemu-system-arm
images withtype="system-arm"
. - args
- QEMU command line to start with. Will always be prepended with
-name ${vm} -nographic
. - haltcmd
- Command to shut down a VM safely. I am using
-monitor telnet:..
and power off my VMs via ACPI by sendingsystem_powerdown
to monitor. You can use SSH or some other ways.
Ejemplo de configuración:
/etc/conf.d/qemu.d/one
type="system-x86_64" args="-enable-kvm -m 512 -hda /dev/mapper/vg0-vm1 -net nic,macaddr=DE:AD:BE:EF:E0:00 \ -net tap,ifname=tap0 -serial telnet:localhost:7000,server,nowait,nodelay \ -monitor telnet:localhost:7100,server,nowait,nodelay -vnc :0" haltcmd="echo 'system_powerdown' | nc localhost 7100" # or netcat/ncat # You can use other ways to shut down your VM correctly #haltcmd="ssh powermanager@vm1 sudo poweroff"
/etc/conf.d/qemu.d/two
args="-enable-kvm -m 512 -hda /srv/kvm/vm2.img -net nic,macaddr=DE:AD:BE:EF:E0:01 \ -net tap,ifname=tap1 -serial telnet:localhost:7001,server,nowait,nodelay \ -monitor telnet:localhost:7101,server,nowait,nodelay -vnc :1" haltcmd="echo 'system_powerdown' | nc localhost 7101"
Para establecer qué máquinas virtuales se iniciarán al arrancar, habilite la unidad de systemd qemu@vm_name.service
.
Integración del ratón
Para evitar que el ratón sea agarrado al hacer clic en la ventana del sistema operativo invitado, agregue la opción -usbdevice tablet
. Esto significa que QEMU puede reportar la posición del ratón sin tener que agarrar el ratón. Esto también anula la emulación de ratón PS/2 cuando se activa. Por ejemplo:
$ qemu-system-i386 -hda disk_image -m 512 -vga std -usbdevice tablet
If that does not work, try the tip at #El cursor del ratón está nervioso o errático.
Dispositivo USB del host de paso
Para acceder al dispositivo físico USB conectado al host desde la VM, puede utilizar la opción: -usbdevice host:vendor_id:product_id
.
Puedes encontrar vendor_id
y product_id
de tu dispositivo con el comando lsusb
.
Puesto que el chipset I440FX por defecto emulado por qemu cuentan con un solo controlador UHCI (USB 1), la opción -usbdevice
intentará conectar su dispositivo físico a él. En algunos casos esto puede causar problemas con los dispositivos más nuevos. Una posible solución es emular el chipset ICH9, que ofrece un controlador EHCI que soporta hasta 12 dispositivos, usando la opción -machine type=q35
.
Una solución menos invasiva es emular un controlador EHCI (USB 2) o XHCI (USB 3) con la opción -device usb-ehci, id = ehci
o -device nec -usb-xhci, id=xhci
respectivamente y luego adjuntar su dispositivo físico con la opción -device usb-host,..
como sigue:
-device usb-host,bus=controller_id.0,vendorid=0xvendor_id,productid=0xproduct_id
También puede agregar la configuración ..., port =<n>
a la opción anterior para especificar en qué puerto físico del controlador virtual que desea conectar su dispositivo, útil en El caso que desea agregar varios dispositivos usb a la VM.
Habilitar KSM
Kernel Samepage Merging (KSM) es una característica del kernel de Linux que permite que una aplicación se registre con el kernel para que sus páginas se combinen con otros procesos que también se registren para que sus páginas se fusionen. El mecanismo KSM permite a las máquinas virtuales invitadas compartir páginas entre sí. En un entorno donde muchos de los sistemas operativos invitados son similares, esto puede resultar en ahorros significativos de memoria.
Para activar KSM, simplemente ejecute:
# echo 1 > /sys/kernel/mm/ksm/run
Para hacerlo permanente, puede utilizar archivos temporales de systemd:
/etc/tmpfiles.d/ksm.conf
w /sys/kernel/mm/ksm/run - - - - 1
Si KSM está en ejecución y hay páginas que se van a fusionar (es decir, al menos dos máquinas virtuales similares se están ejecutando), entonces /sys/kernel/mm/ksm/pages_shared
debería ser distinto de cero. Consulte https://docs.kernel.org/vm/ksm.html[enlace roto 2022-09-22] para obtener más información.
$ grep./Sys/kernel/mm/ksm/*
Multi-monitor support
El controlador QXL de Linux soporta cuatro cabezas (pantallas virtuales) de forma predeterminada. Esto se puede cambiar a través del parámetro kernel qxl.heads = N
.
El tamaño de memoria VGA predeterminado para los dispositivos QXL es de 16M (el tamaño de la VRAM es de 64M). Esto no es suficiente si desea habilitar dos monitores 1920x1200 ya que requiere 2 × 1920 × 4 (profundidad de color) × 1200 = 17.6 MiB memoria VGA. Esto se puede cambiar reemplazando -vga qxl
por -vga none -device qxl-vga, vgamem_mb=32
. Si alguna vez incrementas vgamem_mb más allá de 64M, también debes aumentar la opción vram_size_mb
.
Copiar y pegar
Para poder copiar y pegar entre el host y el invitado, debe habilitar el canal de comunicación del agente de especias. Requiere agregar un dispositivo virtio-serial al huésped, y abrir un puerto para el vdagent de la especia. También es necesario instalar el spice vdagent en invitado (spice-vdagent para invitados de Arch, Herramientas para invitados de Windows para invitados de Windows). Asegúrese de que el agente se está ejecutando (y para el futuro, se iniciará automáticamente).
Inicie QEMU con las siguientes opciones:
$ qemu-system-i386 -vga qxl -spice port=5930,disable-ticketing -device virtio-serial-pci -device virtserialport,chardev=spicechannel0,name=com.redhat.spice.0 -chardev spicevmc,id=spicechannel0,name=vdagent
La opción -device virtio-serial-pci
añade el dispositivo virtio-serial, -device virtserialport, chardev=spicechannel0, nombre=com.redhat.spice.0
abre un puerto Para spice vdagent en ese dispositivo y -chardev spicevmc, id=spicechannel0, nombre=vdagent
añade un spicevmc chardev para ese puerto.
Es importante que la opción chardev=
del dispositivo virtserialport
coincida con la opción id=
dada a la opción chardev
(spicechannel0
en este ejemplo). También es importante que el nombre del puerto sea com.redhat.spice.0
, ya que es el espacio de nombres donde vdagent está buscando en el invitado. Y finalmente, especifique name=vdagent
para que spice sepa para qué sirve este canal.
Notas específicas de Windows
QEMU puede ejecutar cualquier versión de Windows desde Windows 95 a través de Windows 10.
Es posible ejecutar Windows PE en QEMU.
Inicio rápido
Para invitados de Windows 8 (o posteriores), es mejor desactivar "Activar inicio rápido (recomendado)" en Opciones de energía del Panel de control, ya que hace que el invitado se bloquee durante cada arranque.
El inicio rápido también puede necesitar deshabilitarse para que los cambios en la opción -smp
se apliquen correctamente.
Protocolo de escritorio remoto
Si utiliza un invitado de MS Windows, puede utilizar RDP para conectarse a su VM invitada. Si está utilizando una VLAN o no está en la misma red que el invitado, utilice:
$ qemu-system-i386 -nographic -net user,hostfwd=tcp::5555-:3389
A continuación, conéctese con rdesktop ó freerdp al invitado. Por ejemplo:
$ xfreerdp -g 2048x1152 localhost:5555 -z -x lan
Solución de problemas
La máquina virtual virtual corre muy lento
Hay algunas técnicas que se pueden usar para implementar rendimiento en la máquina virtual, por ejemplo:
- Use la opción
-cpu host
para hacer que QEMU emule la CPU del host. Si no se hace esto, podría intentar emular un CPU más genérico. - Especialmente para los invitados de Windows, habilite Iluminaciones de Hyper-V:
-Host de la CPU, hv_relaxed, hv_spinlocks=0x1fff, hv_vapic, hv_time
. - Si la máquina host tiene varias CPUs, asigne al invitado más CPUs usando la opción
-smp
. - Asegúrese de haber asignado a la máquina virtual suficiente memoria. De forma predeterminada, QEMU sólo asigna 128 MiB de memoria a cada máquina virtual. Utilice la opción
-m
para asignar más memoria. Por ejemplo,-m 1024
ejecuta una máquina virtual con 1024 MiB de memoria. - Utilice KVM si es posible: agregue
-machine type=pc, accel=kvm
al comando de arranque QEMU que utilice. - Si es compatible con los controladores del sistema operativo invitado, utilice virtio para dispositivos de red y/o bloque. Por ejemplo:
$ qemu-system-i386 -net nic, model=virtio -net tap, if=tap0, script=no-drive file=disk_image,media=disco, if=virtio
- Utilizar dispositivos TAP en lugar de redes en modo usuario. Consulte #Tap de red con QEMU.
- Si el sistema operativo invitado está haciendo escritura pesada en su disco, puede beneficiarse de ciertas opciones de montaje en el sistema de archivos del host. Por ejemplo, puede montar un sistema de archivos ext4 con la opción
barrier=0
. Debe leer la documentación de las opciones que cambie porque a veces las opciones de mejora de rendimiento para los sistemas de archivos tienen el costo de integridad de los datos. - Si tiene una imagen de disco sin procesar, puede deshabilitar la caché:
$ qemu-system-i386 -drive file=disk_image, if=virtio, cache=none
- Utilice el nativo Linux AIO:
$ qemu-system-i386 -drive file=disk_image, if=virtio, aio=native
- Si utiliza una imagen de disco qcow2, el rendimiento de E/S se puede mejorar considerablemente al garantizar que el caché L2 es de tamaño suficiente. La fórmula [4] para calcular La caché L2 es: l2_cache_size = disk_size * 8 / cluster_size. Suponiendo que la imagen qcow2 se creó con el tamaño de clúster predeterminado de 64 K, esto significa que para cada 8 GB de tamaño de la imagen qcow2, 1 MB de caché L2 es mejor para el rendimiento. QEMU utiliza sólo 1 MB por defecto; Especificar una caché más grande se hace en la línea de comandos QEMU. Por ejemplo, para especificar 4 MB de caché (adecuado para un disco de 32 GB con un tamaño de clúster de 64 KB):
$ qemu-system-i386 -drive file=disk_image,format=qcow2, l2-cache-size=4M
- Si está ejecutando varias máquinas virtuales al mismo tiempo que todas tienen el mismo sistema operativo instalado, puede ahorrar memoria al habilitar kernel de la misma página de fusión. Consulte #Habilitar KSM.
- En algunos casos, la memoria se puede recuperar de correr máquinas virtuales ejecutando un controlador de globo de memoria en el sistema operativo invitado y lanzando QEMU con la opción
-balloon virtio
. - Es posible utilizar una capa de emulación para un controlador ICH-9 AHCI (aunque puede ser inestable). La emulación AHCI soporta NCQ, por lo que varias peticiones de lectura o escritura pueden estar pendientes al mismo tiempo:
$ qemu-system-i386 -drive id=disc, file=disk_image, if=none -device ich9-ahci, id=ahci -device ide-drive, drive=disk, bus=ahci.0
Mira https://www.linux-kvm.org/page/Tuning_KVM para más información.
El cursor del ratón está nervioso o errático
Si el cursor "brinca" descontroladamente, podría ayudar ingresar este comando en la terminal antes de iniciar QEMU
$ export SDL_VIDEO_X11_DGAMOUSE=0
Si funciono, puedes agregarlo a tu ~/.bashrc
archivo.
El cursor no es visible
Añade -show-cursor
a las opciones de QEMU para poder ver el cursor.
Si persiste, asegurate de configurar la pantalla apropiadamente
Por ejemplo: -vga qxl
No se puede mover / adjuntar el cursor
Reemplaza -usbdevice tablet
con -usb
como opción en QEMU.
El teclado parece roto ó las teclas de flecha no funcionan
Probablemente notarás que algunas de tus teclas no funcionan ó "presionan" la tecla equivocada (en particular, las flechas), preferentemente, necesitas especificar la distribución de tu teclado como una opción. La distribución del teclado puede encontrarse en /usr/share/qemu/keymaps
.
$ qemu-system-i386 -k keymap disk_image
Pantalla de invitado estirada en el tamaño de la ventana
Para restarurar el tamaño por defecto de la ventanta, presiona Ctrl+Alt+u
.
ioctl(KVM_CREATE_VM) failed: 16 Device or resource busy
Si un mensaje de error como este es listado en el arranque de QEMU con la opción -enable-kvm
:
ioctl(KVM_CREATE_VM) failed: 16 Device or resource busy failed to initialize KVM: Device or resource busy
Significa que otro hypervisor está actualmente activo. No se recomienda ó no es poible correr varios hypervisores en paralelo.
Mensaje de error libgfapi
El mensaje de error listado en el arranque:
Failed to open module: libgfapi.so.0: cannot open shared object file: No such file or directory
No es un problema, sólo significa que hace falta la dependencia opcional de GlusterFS
Kernel panic en entornos live
Si inicia un sistema en vivo (ó bootea uno) podría encontrar esto:
end Kernel panic - not syncing: VFS: Unable to mount root fs on unknown block(0,0)
Ó algún otro proceso de arranque (ej. no se puede desempaquetar initramfs, no puede iniciar un servicio foo).
Intente iniciar la Máquina Virtual con el -m VALOR
switch y un tamaño apropiado de RAM, si la RAM es muy poca probablemente encontrará problemas similares a los anteriores.
Ver también
- Sitio web oficial de QEMU
- Sitio web oficial de KVM
- Documentación para el usuario del emulador QEMU (en inglés)
- Wikilibro de QEMU (en inglés)
- [http://alien.slackbook.org/dokuwiki/doku.php?id=slackware:qemu Virtualización de hardware con QEMU por AlienBOB (última actualización en 2008) (en inglés)
- Construyendo un ejército virtual por Falconindy (en inglés)
- Últimos documentos
- QEMU en Windows
- Wikipedia
- QEMU - Wiki de Debian (en inglés)
- QEMU Networking on gnome.org[enlace roto 2022-09-22]
- Red virtual de QEMU en sistemas BSD (en inglés)
- QEMU on gnu.org
- QEMU en FreeBSD como host (en inglés)