351.3 QEMU

Introdução ao KVM - Kernel Virtual Machine

O Kernel Virtual Machine (KVM) é uma tecnologia de virtualização open source baseada no Linux. Com o KVM, é possível transformar o Linux em um hypervisor, permitindo assim que o sistema execute vários ambientes virtuais isolados, conhecidos com guest ou máquinas virtuais.

O KVM faz parte do Linux e foi incluído na versão 2.6.20 do Kernel!

O KVM é um hypervisor híbrido, isso significa que ele é um hypervisor do Tipo 1 e do Tipo 2, embora precise de um sistema operacional Linux genérico para funcionar, é capaz de funcionar como um hypervisor perfeitamente bem, integrando-se a uma instalação do Linux em execução. As máquinas virtuais implantadas com KVM usam o daemon libvirt e utilitários de software associados para serem criados e gerenciados.

O KVM faz uso das extensões de virtualização dos processadores (HVM), sendo vmx para Intel e svm para AMD. Com o KVM vamos usar também o QEMU, Libvirt, Virt-manager entre outros utilitários.

Tipos de hypervisors

Há dois tipos de hypervisors que podem ser usados para a virtualização: são o tipo 1 e o tipo 2.

Tipo 1
É comumente conhecido como hypervisor nativo ou até mesmo bare-metal, ele é executado diretamente no hardware do host para gerenciar sistemas operacionais guest. Ele ocupa o lugar de um sistema operacional host, e os recursos da máquina virtual são programados diretamente no hardware pelo hypervisor.
Exemplos: VMware vSphere/ESXi, Microsoft Hyper-V, Oracle VM Server, Xen, KVM.

O Sistemas Operacional nesse caso é o próprio Hypervisor.
Este tipo de Hypervisor é mais comum em data centers pois o hardware precisa ser bastante robusto, o que é mais encontrado em servidores (quanto mais robusto mais caro será o hardware).

Tipo 2
É denominado hosted e é executado em um Sistema Operacional convencional, tendo uma camada de software ou aplicação para gerenciar tanto o hypervisor quanto as máquina virtuais.

Normalmente o gerenciamento do Hypervisor em sí é bastante tranquilo, sendo feita a instalação, configurações necessária e desse ponto em diante, todo o gerenciamento mesmo é feito em cima das máquinas virtuais somente, já que a base (hypervisor) já está solidificada no Sistema Operacional.
Esse tipo de hypervisor é mais usado por usuários individuais que desejam executar vários sistemas operacionais em um computador pessoal para fins de testes/aprendizado, mesmo que ainda seja possível encontrar esse tipo em pequenas empresas.
Exemplos: Oracle VirtualBox e VMWare Workstation.

O Quick Emulator ou apenas QEMU é o principal componente no quesito virtualização, é ele quem fornece uma maneira de fazer virtualização de hardware e emulação de processador.

QEMU - Quick Emulator

O Quick Emulator ou apenas QEMU é o principal componente no quesito virtualização, é ele quem fornece uma maneira de fazer virtualização de hardware e emulação. O QEMU usa o KVM apenas para fazer a virtualização de máquinas virtuais, mas pode ser usado sozinho para fazer a emulação de outros sistemas e aplicações.

Resumindo, o QEMU é responsável pela emulação de dispositivos, como redes, discos, placas de vídeo e outros componentes de hardware, que são necessários para que as máquinas virtuais funcionem corretamente. Ele fornece uma camada de abstração que permite que as máquinas virtuais acessem esses dispositivos, mesmo que eles não estejam fisicamente presentes no hardware real.

Já o KVM vai fornece recursos de virtualização de hardware, como HVM (Hardware Virtual Machine), para o QEMU. Isso permite que o QEMU execute as máquinas virtuais de forma mais eficiente, aproveitando as extensões de virtualização do processador subjacente. Com o KVM, as máquinas virtuais podem ter um desempenho melhor e um acesso mais direto aos recursos de hardware do sistema hospedeiro.

A imagem abaixo demonstra as camadas no Sistema com uso do Xen, KVM e apenas QEMU. A imagem é disponibilizada por researchgate.net.

Instalação do QEMU e KVM

Vamos instalar o KVM e o QEMU no Ubuntu 22.04.

Terminal

# Atualize o repositório:
$ sudo apt update

# Atualize os pacotes:
$ sudo apt upgrade -y

# Execute o comando abaixo para verificar se o KVM é compatível. 
# Se o comando retornar um valor diferente de zero, significa que a CPU suporta virtualização.
$ egrep -c '(vmx|svm)' /proc/cpuinfo
24

# Além disso, também podemos verificar se a virtualização KVM está habilitada:
$ kvm-ok
INFO: /dev/kvm exists
KVM acceleration can be used

# Instale o KVM:
$ sudo apt install libvirt-daemon-system qemu-system-x86 libvirt-clients bridge-utils libosinfo-bin -y

# Adicione seu usuário ao grupo kvm:
$ sudo gpasswd -a $USER kvm

# Adicione seu usuário ao grupo libvirt:
$ sudo gpasswd -a $USER libvirt

# Com todos os pacotes instalados, habilite e inicie o daemon Libvirt.
$ sudo systemctl enable --now libvirtd
$ sudo systemctl start libvirtd

# Nós podemos validar as configurações de virtualização do host:
$ virt-host-validate  
  QEMU: Checking for hardware virtualization                                 : PASS
  QEMU: Checking if device /dev/kvm exists                                   : PASS
  QEMU: Checking if device /dev/kvm is accessible                            : PASS
  QEMU: Checking if device /dev/vhost-net exists                             : PASS
  QEMU: Checking if device /dev/net/tun exists                               : PASS
  QEMU: Checking for cgroup 'cpu' controller support                         : PASS
  QEMU: Checking for cgroup 'cpuacct' controller support                     : PASS
  QEMU: Checking for cgroup 'cpuset' controller support                      : PASS
  QEMU: Checking for cgroup 'memory' controller support                      : PASS
  QEMU: Checking for cgroup 'devices' controller support                     : PASS
  QEMU: Checking for cgroup 'blkio' controller support                       : PASS
  QEMU: Checking for device assignment IOMMU support                         : PASS
  QEMU: Checking if IOMMU is enabled by kernel                               : PASS
  QEMU: Checking for secure guest support                                    : WARN (Unknown if this platform has Secure Guest support)
   LXC: Checking for Linux >= 2.6.26                                         : PASS
   LXC: Checking for namespace ipc                                           : PASS
   LXC: Checking for namespace mnt                                           : PASS
   LXC: Checking for namespace pid                                           : PASS
   LXC: Checking for namespace uts                                           : PASS
   LXC: Checking for namespace net                                           : PASS
   LXC: Checking for namespace user                                          : PASS
   LXC: Checking for cgroup 'cpu' controller support                         : PASS
   LXC: Checking for cgroup 'cpuacct' controller support                     : PASS
   LXC: Checking for cgroup 'cpuset' controller support                      : PASS
   LXC: Checking for cgroup 'memory' controller support                      : PASS
   LXC: Checking for cgroup 'devices' controller support                     : PASS
   LXC: Checking for cgroup 'freezer' controller support                     : PASS
   LXC: Checking for cgroup 'blkio' controller support                       : PASS
   LXC: Checking if device /sys/fs/fuse/connections exists                   : PASS

O pacote do QEMU em sí é o qemu-system-x86, ele é o binário de emulação de sistema completo QEMU (x86). No sistema baseado em Red Hat devemos instalar oqemu-kvm e qemu-img.

Pode ocorrer um erro no IOMMU

Para consertar o aviso: WARN (IOMMU appears to be disabled in kernel. Add intel_iommu=on to kernel cmdline arguments) basta informar ao Kernel que vamos usar esse recurso, fazendo:

sudo vim /etc/default/grub
GRUB_CMDLINE_LINUX='intel_iommu=on'

Depois aplique as configurações do grub.

Terminal

$ sudo update-grub

Execução de VMs com QEMU/KVM

Agora vamos ver como subir uma VM usando o QEMU com KVM. Primeiro vamos precisar baixar a ISO do sistema operacional, vamos começar com o Ubuntu 22.04.

Terminal

# Baixe a ISO do Ubuntu 22.04:
$ wget https://releases.ubuntu.com/jammy/ubuntu-22.04.4-live-server-amd64.iso

Agora vamos começar o processo de criação da nossa VM. Vale ressaltar que essa criação da VM inicial não é persistente, ou seja, não será possível executar um start/stop/restart na VM, sempre que quisermos executar a VM, teremos que rodar o comando todo novamente.

Esse processo é realizado normalmente para instalar a VM, apesar da VM não ser persistente, todo dado gravado no disco da VM será persistente. Após essa etapa veremos como realmente criar a VM para que possamos gerenciar ela da forma que estamos acostumados.

Terminal

# Primeiro de tudo, crie o HD que será usado pela VM:
$ qemu-img create -f qcow2 /var/lib/libvirt/images/ubuntu.qcow2 25G

# Agora vamos criar a VM, 
# não é necessário que você faça a instalação do S.O para um ambiente de estudos:
$ sudo qemu-system-x86_64 -name Ubuntu22_test \
-machine accel=kvm \
-hda /var/lib/libvirt/images/ubuntu.qcow2 \
-cdrom ~/Downloads/ubuntu-22.04.3-live-server-amd64.iso \
-boot d \
-m 2048 \
-smp cpus=2

O caminho /var/lib/libvirt/images/ é onde ficam as HDs das VM se estiver usando o pool padrão.

Agora veremos cada parâmetro usado para criar a VM.

-machine accel=kvm
Esse parâmetro configura o uso do HVM. Também pode ser usado o enable-kvm.
-name
Configura o nome da VM.
-hda
Uma das maneiras de configurar o caminho do HD dessa VM.
-cdrom
Configura a ISO como cdrom da nossa VM.
-boot d
Configura a VM para iniciar pelo cdrom.
-m 2048
Configura a VM para usar 2048MB de memória RAM.
-smp cpus=2
Configura a VM para usar 2 núcleos da CPU do host hospedeiro.

console do KVM

Como estou usando o KVM no Ubuntu com interface gráfica, por padrão ele vai subir um console usando o GTK.

Podemos então usar o vnc para conectar na console da VM usando o parâmetro -vnc :0. Para iniciar em modo console CLI, podemos usar a opção -nographic, mas como vamos fazer a instalação do zero, esse modo pode sofrer algumas incompatibilidades e fazer com que a instalação fique muito complicada.

Se está executando num servidor mesmo ou num sistema que não tenha GUI, recomendo o uso do VNC.

Para um ambiente de estudos, podemos usar uma imagem já pronta, podemos baixar a imagem no nesse site. Depois de baixar a imagem no formato VDI (VirtualBox), temos que converter essa imagem para o formato qcow2, para assim poder usar o recurso de snapshot dentre outros recursos.

Terminal

# Após baixar a imagem, converta ela:
$ qemu-img convert -f vdi -O qcow2 Ubuntu-Server.vdi Ubuntu-Server.qcow2 -p -m3

# -p = Exibe um progresso.
# -m3 = Faz paralelismo, acelerando o processo.

Kernel e Boot

Para passar parâmetros para o Kernel da VM podemos usar a opção -kernel para informar o kernel da VM. O parâmetro -initrd informa qual o initrd a VM vai usar.

Para qualquer outro comando de inicialização podemos usar a opção -append. Exemplo:

Terminal

# Passando o vmlinuz e initrd do host hospedeiro para a VM:
$ sudo qemu-system-x86_64 .... \
-kernel /boot/vmlinuz \
-initrd /boot/initrd.img \
-append 'root=/dev/ubuntu-vg/ubuntu-lv fastboot quiet'

Storage

Nós já vimos que para adicionar um disco usamos a sintaxe -hda /path/to/disk.qcow2, para adicionar um segundo disco vamos usar a mesma sintaxe, mas trocando de -hda para -hdb.

Terminal

$ sudo qemu-system-x86_64 -name Test-Ubuntu2004 \
-enable-kvm
-hda /var/lib/libvirt/images/ubuntu.qcow2 \
-hdb /var/lib/libvirt/images/ubuntu_disk2.qcow2 \
-m 2048 \
-smp cpus=2

Aqui, estamos utilizando as opções -hda e -hdb para definir o primeiro e o segundo disco IDE, respectivamente. A nomenclatura é simples e direta, o que torna essa forma fácil de lembrar.

No entanto, essa abordagem oferece menos flexibilidade. Se você precisar de uma configuração mais complexa (por exemplo, alterar o tipo de controlador ou outras opções de disco), a próxima abordagem seria mais recomendada.

Terminal

$ sudo qemu-system-x86_64 -name Test-Ubuntu2004 \
-enable-kvm
-hda /var/lib/libvirt/images/ubuntu.qcow2 \
-drive file=/var/lib/libvirt/images/ubuntu_disk2.qcow2,index=1,media=disk,if=ide \
-m 2048 \
-smp cpus=2

Aqui, a opção -drive é usada, que é mais poderosa e flexível em comparação com -hdX.

file=...
Especifica o caminho para o arquivo de imagem do segundo disco.
index=1
Indica que esse disco será o segundo no controlador IDE (equivalente ao -hdb), a contagem começa em 0 (hda).
media=disk
Define que o tipo de mídia é um disco (pode ser importante quando se trabalha com CDs ou outros tipos de mídia).
if=ide
Especifica o tipo de interface usada, no caso, o IDE.

Outras formas de indicação de disco que podem ser usadas com qemu:

-drive file=iscsi://user%password@fileserver/iqn.2001-04.com.example/1
-drive file=ssh://user@host/tmp/file.img
-drive file=http://user:password@fileserver/pub/linux.iso,media=cdrom,readonly

Networking

Existem diferentes tipos de configuração de rede que podem ser usadas ao configurar máquinas virtuais com QEMU/KVM. Cada tipo de rede oferece diferentes níveis de acessibilidade, controle e performance, dependendo do caso de uso.

User Networking (Slirp)
Esse é o modo padrão de rede no QEMU quando nenhum parâmetro de rede é especificado. A rede do usuário usa a implementação Slirp, que permite que a máquina virtual tenha acesso à rede do host e à internet.
Private Virtual Bridge - TAP
Nesta configuração, a VM está conectada a uma ponte virtual privada, que permite a comunicação entre várias VMs no mesmo host, sem acesso à rede externa (internet ou rede local do host).
Public Bridge (Bridge Networking)
A configuração de bridge networking conecta a VM diretamente à rede física do host, compartilhando a mesma interface de rede. Dessa forma, a VM aparece na rede como um dispositivo separado, com seu próprio endereço IP.
VDE (Virtual Distributed Ethernet)
O VDE é um sistema de rede distribuída virtual que permite que múltiplos hosts compartilhem uma rede virtual. Ele funciona de maneira similar ao bridge networking, mas com suporte distribuído, permitindo que VMs em diferentes máquinas físicas compartilhem a mesma rede virtual.

User Networking

O uso de User Networking no QEMU é uma solução simples para configurar uma máquina virtual (guest) que tenha acesso à rede do host e à Internet, sem precisar de configurações complexas de rede ou permissões administrativas adicionais. Essa abordagem é baseada no Slirp, uma implementação de rede em nível de usuário, que não requer privilégios especiais para funcionar.

Aqui estão os principais pontos desse uso case e solução:

Conexão ao Host e Internet: A VM terá acesso à rede local e à internet por meio da interface do host.
Simplicidade: Não é necessário configurar parâmetros de rede adicionais; por padrão, a configuração de rede baseada no Slirp é usada.
Limitação de Acesso: A VM não será acessível a partir da rede externa ou de outra VM, o que simplifica a segurança, mas também pode ser uma limitação para alguns casos.
Impacto de Performance: O desempenho de rede é significativamente reduzido comparado a métodos como bridge networking, devido à natureza do Slirp.
Suporte Limitado a ICMP: Aplicações que dependem de ICMP, como ping, podem não funcionar corretamente.

Pré-requisitos:

O KVM deve estar configurado e em execução.
O usuário deve ter permissão de leitura e escrita em /dev/kvm se quiser evitar o uso de privilégios administrativos (root).
O host precisa ter conectividade à internet ou à rede local para que a VM consiga acessar esses recursos.

Nós também podemos especificar explicitamente a configuração da rede, customizando a rede da VM usando a opção -netdev:

Terminal

sudo qemu-system-x86_64 -name Test-Debian \
-enable-kvm \
-hda debian12.4.0-64bits.qcow2 \
-netdev user,id=mynet0,net=192.168.132.0/24,dhcpstart=192.168.132.100 \
-device e1000,netdev=mynet0 \
-m 2048 \
-smp cpus=2

-netdev user
Define o backend de rede como user, que é uma forma simples de fornecer conectividade de rede NAT (Network Address Translation) à máquina virtual. Nesse modo, a máquina virtual tem acesso à rede externa (como a internet), mas não é diretamente acessível de fora.
id=mynet0
Atribui um identificador (mynet0) a essa configuração de rede. Esse id será usado posteriormente para conectar a interface de rede da máquina virtual.
net=192.168.132.0/24
Define a rede virtual interna que será usada pela máquina virtual, no formato CIDR.
dhcpstart=192.168.132.100
Define o primeiro endereço IP que será atribuído à máquina virtual via DHCP.
-device e1000
Especifica a emulação de uma interface de rede e1000, que é uma placa de rede Gigabit Ethernet Intel 82540EM. Esta emulação é útil porque é amplamente compatível e reconhecida pela maioria dos sistemas operacionais como uma interface de rede padrão.
netdev=mynet0
Liga esta interface de rede (dispositivo e1000) à configuração de rede definida anteriormente por -netdev user,id=mynet0. Basicamente, essa opção conecta a interface virtual da máquina (e1000) à rede NAT criada, para que a máquina tenha conectividade de rede usando o backend configurado.

Rede em modo NAT

Quando usamos o backend de rede user em QEMU (-netdev user), ele automaticamente configura o modo de rede para operar como um NAT. Nesse modo, a máquina virtual tem acesso à rede externa (como a internet) através da máquina host, mas a máquina virtual não é diretamente acessível de fora.

Este comportamento é uma característica do modo user em QEMU. Diferentemente de outras opções como tap (que cria uma interface de rede de nível 2 diretamente conectada à rede física do host), o modo user atua como uma forma simplificada de conectividade, fornecendo NAT sem a necessidade de configurações avançadas no host.

Para que o host possa acessar essa máquina, podemos usar a opção hostfwd:

Terminal

sudo qemu-system-x86_64 -name Test-Debian \
-enable-kvm \
-hda debian12.4.0-64bits.qcow2 \
-netdev user,id=mynet0,net=192.168.132.0/24,dhcpstart=192.168.132.100,hostfwd=tcp::2222:22 \
-device e1000,netdev=mynet0 \
-m 2048 \
-smp cpus=2

O parâmetro hostfwd=tcp::2222-:22 redireciona a porta 2222 no Host para a porta 22 na VM.

Private Virtual Bridge - TAP

O TAP no QEMU é uma forma de conectar várias máquinas virtuais entre si, formando uma rede privada local onde as VMs podem se comunicar diretamente. Nesse caso, o tráfego entre essas VMs não passa pela rede externa (LAN ou internet) e o host pode ou não ter acesso a essa rede, dependendo da configuração.

Um bridge atua como um "switch virtual", permitindo que várias interfaces de rede (virtuais ou físicas) se conectem e troquem dados entre si, como se estivessem na mesma rede local. No caso de um TAP, o QEMU cria uma rede privada virtual isolada, na qual apenas as VMs conectadas a essa bridge podem se comunicar. Isso é útil quando você deseja simular uma rede interna entre VMs, sem necessidade de conectividade com a rede externa ou com o host.

No contexto do QEMU, o script /etc/qemu-ifup é responsável por configurar a interface TAP quando você inicializa uma máquina virtual em modo tap/bridge. Uma modificação que deve ser realizada é a alteração do comportamento padrão do script, de forma que ele use uma interface bridge diretamente, nesse nosso exemplo será br0.

Terminal

/etc/qemu-ifup
#switch=$(ip route ls | \
#    awk '/^default / {
#          for(i=0;i<NF;i++) { if ($i == "dev") { print $(i+1); next; } }
#         }'
#        )
switch=br0

Antes de mais nada, é necessário ter uma interface bridge existente:

Terminal

# Cria uma interface do tipo bridge chamada br0:
$ sudo ip link add br0 type bridge

# Torna a interface UP (Ativa):
$ sudo ip link set br0 up

Para usar esse tipo de rede temos que usar o parâmetro -netdev tap,id=br0, informando qual a interface de rede bridge que deve ser usada. Além disso, temos que informar qual o MAC da interface de rede.

Terminal

sudo qemu-system-x86_64 -name Test-Debian \
-enable-kvm \
-hda debian12.4.0-64bits.qcow2 \
-netdev user,id=mynet0,net=192.168.132.0/24,dhcpstart=192.168.132.100,hostfwd=tcp::2222:22 \
-device e1000,netdev=mynet0 \
-m 2048 \
-smp cpus=2 \
-netdev tap,id=br0 \
-device e1000,netdev=br0,mac=AA:DF:BE:22:1B:C4 &

Para gerar o MAC podemos usar o comando abaixo, além dele a RedHat fornece um script para gerar MAC tendo mais parâmetros que podem ser configurados.

Terminal

$ printf 'DE:AD:BE:EF:%02X:%02X\n' $((RANDOM%256)) $((RANDOM%256))

QEMU Monitor

O QEMU Monitor é uma interface de controle integrada ao QEMU (Quick Emulator), uma popular ferramenta de virtualização e emulação. Ele permite que você interaja diretamente com a máquina virtual (VM) em execução, fornecendo comandos para monitorar, ajustar e controlar o estado da VM em tempo real.

Há duas maneiras principais de acessar o QEMU Monitor:

Janela do Monitor
Ao iniciar uma VM no QEMU, você pode abrir uma janela separada dedicada ao monitor. Isso é feito com o parâmetro -monitor durante a inicialização do QEMU.
Terminal
$ qemu-system-x86_64 -name Ubuntu2404 \ -enable-kvm \ -hda Ubuntu-Server.qcow2 \ -m 2048 \ -smp cpus=2 \ -monitor stdio
Nesse exemplo, o monitor é acessado diretamente via a interface de linha de comando padrão (stdio).

Via Telnet ou UNIX Socket
O QEMU Monitor pode ser acessado remotamente via uma conexão Telnet ou UNIX socket. Isso é útil quando você quer gerenciar a VM sem precisar acessar o terminal local.

Quando a VM já foi iniciada também é possível acessar o QEMU Monitor. Clique em View -> compatmonitor0 (também podemos clicar em View -> show tabs, depois em compat_monitor0).

Exemplos de Comandos do QEMU Monitor:

Comando	Descrição
info status	Exibe o estado atual da VM (em execução, pausada, etc.).
stop	Pausa a execução da VM.
cont	Retoma a execução da VM.
system_powerdown	Desliga a VM.
system_reset	Reinicia a VM.
info network	Exibe informações sobre as interfaces de rede da VM.
info cpus	Exibe informações sobre a quantidade de CPUs.
migrate "tcp:192.168.0.10:4444"	Inicia a migração da VM para outro host via TCP.
info block	Existe informações dos discos.

dica

Só é possível conectar no QEMU Monitor se for especificado o uso durante a execução da VM ou acessando a janela do QEMU.

Block Device com QEMU Monitor

No QEMU Monitor, você pode gerenciar dispositivos de bloco (block devices), como discos virtuais e imagens de disco, em tempo real enquanto a máquina virtual está em execução. Isso inclui a adição, remoção, inspeção e modificação de discos virtuais conectados à VM. Nem todas as interfaces e dispositivos de bloco suportam hot-plugging (adicionar dispositivos enquanto a máquina virtual está em execução). Isso depende da interface de disco escolhida e do sistema operacional que está sendo executado na VM.

Terminal

# Adiciona um novo disco:
drive_add 0 if=none,file=Ubuntu-ServerN.qcow2,id=newdrive

# Associa o drive a um dispositivo Virtio:
device_add virtio-blk-pci,drive=newdisk,id=newdisk1

O dispositivo será montado como vda porque estamos utilizando a interface Virtio. No Linux, discos conectados via Virtio são geralmente nomeados como vda, vdb, vdc, etc., em vez de sda, sdb (que são usados para interfaces como SCSI ou SATA). Se você tentar adicionar um disco SATA em tempo real (hot-plug) em uma máquina virtual no QEMU, isso pode não funcionar corretamente, pois a maioria das controladoras SATA e IDE no QEMU não suportam hot-plugging de dispositivos enquanto a VM está em execução. Isso significa que, diferente da interface Virtio, que suporta hot-plug, interfaces como SATA e IDE geralmente só aceitam dispositivos durante a inicialização da VM.

Também podemos adicionar uma ISO ao CDROM:

Terminal

# Veja se tem o CDROM:
(qemu) info block
ide0-hd0 (#block113): Ubuntu-Server.qcow2 (qcow2)
    Attached to:      /machine/unattached/device[25]
    Cache mode:       writeback

ide1-cd0: [not inserted]
    Attached to:      /machine/unattached/device[26]
    Removable device: not locked, tray closed

floppy0: [not inserted]
    Attached to:      /machine/unattached/device[18]
    Removable device: not locked, tray closed

sd0: [not inserted]
    Removable device: not locked, tray closed

newdisk (#block750): Ubuntu-ServerN.qcow2 (qcow2)
    Attached to:      /machine/peripheral/newdisk1/virtio-backend
    Cache mode:       writeback


# ide1-cd0 é o CDROM!

# Monte uma ISO:
(qemu) change ide1-cd0 /home/fulano/ubuntu-server.iso

# Para ejetar o disco:
(qemu) eject ide1-cd0

Snapshots com QEMU Monitor

O QEMU Monitor permite a criação e gerenciamento de snapshots (instantâneos) de máquinas virtuais em tempo real, ou seja, você pode tirar uma "foto" do estado atual da VM, incluindo o conteúdo da memória e o status do disco, para restaurá-lo posteriormente se necessário. Isso é útil para testes, desenvolvimento e recuperação de falhas. O recurso de snapshot com QEMU Monitor só funciona com imagens do tipo qcow2.

Terminal

# Criar um snapshot:
savevm nome_snapshot

# Listar snapshots:
info snapshots

# Restaurar um snapshot:
loadvm nome_snapshot

# Deletar um snapshot:
delvm nome_snapshot

VirtIO e QEMU Guest Agent

O VirtIO e o QEMU Guest Agent são componentes importantes no ecossistema de virtualização do QEMU/KVM, projetados para otimizar o desempenho e facilitar a comunicação entre o host (sistema que roda a VM) e a guest (máquina virtual).

VirtIO

O VirtIO é uma interface de virtualização eficiente usada pelo QEMU/KVM para emular dispositivos como discos, interfaces de rede, e outros dispositivos de E/S de maneira mais rápida e otimizada do que os dispositivos emulados tradicionais, como IDE ou SATA. O VirtIO permite que a máquina virtual (guest) e o host se comuniquem diretamente através de uma interface otimizada para ambientes de virtualização. Basicamente é um conjunto de drivers para Rede e Discos.

Terminal

# Para subir uma VM com virtio:
$ qemu-system-x86_64 -name Ubuntu2404 \
-enable-kvm \
-drive file=Ubuntu-Server.qcow2,if=virtio \
-m 2048 \
-smp cpus=2 \
-net nic,model=virtio -net user 

QEMU Guest Agent

O QEMU Guest Agent é um software que é instalado dentro da máquina virtual (guest) e permite que o host se comunique diretamente com o sistema operacional da VM. Ele é uma ferramenta essencial para operações de gerenciamento e monitoramento de VMs. Para tirar proveito completo do QEMU Guest Agent, ele deve ser instalado no sistema operacional guest.

Terminal

# Instale o qemu-guest-agent
$ sudo apt-get install -y qemu-guest-agent

# Inicie o serviço e Habilite para subir no boot:
$ sudo systemctl start qemu-guest-agent
$ sudo systemctl enable qemu-guest-agent

# Agora é só subir uma VM as opções corretas:
$ qemu-system-x86_64 -name Ubuntu2404  \
-enable-kvm -hda Ubuntu-Server.qcow2  \
-m 2024 -smp cpus=2  \
-chardev socket,path=/tmp/qga.sock,server=on,wait=off,id=qga0 \
-device virtio-serial \
-device virtserialport,chardev=qga0,name=org.qemu.guest_agent.0

Fontes

https://linux-kvm.org/page/Main_Page

https://qemu.org

https://linuxgenie.net/how-to-install-kvm-on-ubuntu-22-04/

https://www.linuxtechi.com/how-to-install-kvm-on-ubuntu-22-04/

https://www.osboxes.org

https://wiki.qemu.org/Documentation/Networking

https://wiki.qemu.org/Features/GuestAgent

https://en.wikibooks.org/wiki/QEMU/Devices/Virtio

Introdução ao KVM - Kernel Virtual Machine​

Tipos de hypervisors​

QEMU - Quick Emulator​

Instalação do QEMU e KVM​

Execução de VMs com QEMU/KVM​

Kernel e Boot​

Storage​

Networking​

User Networking​

Private Virtual Bridge - TAP​

QEMU Monitor​

Block Device com QEMU Monitor​

Snapshots com QEMU Monitor​

VirtIO e QEMU Guest Agent​

VirtIO​

QEMU Guest Agent​

Fontes​

Introdução ao KVM - Kernel Virtual Machine

Tipos de hypervisors

QEMU - Quick Emulator

Instalação do QEMU e KVM

Execução de VMs com QEMU/KVM

Kernel e Boot

Storage

Networking

User Networking

Private Virtual Bridge - TAP

QEMU Monitor

Block Device com QEMU Monitor

Snapshots com QEMU Monitor

VirtIO e QEMU Guest Agent

VirtIO

QEMU Guest Agent

Fontes