qemu-kvm / guestfish

Sumário

QEMU-KVM
Montando partições LVM da VM
Acessando imagem QCOW2 com Guestfish
Recursos adicionais

O QEMU-KVM (Quick Emulator - Kernel-based Virtual Machine) é uma ferramenta de virtualização poderosa para sistemas Linux. Ele permite que você execute máquinas virtuais em seu sistema hospedeiro.

Passo 1: Instalação

Certifique-se de ter o QEMU-KVM instalado em seu sistema. Você pode instalá-lo usando o gerenciador de pacotes do seu sistema. Por exemplo, no Ubuntu, você pode usar o seguinte comando:

apt install qemu-kvm # linha debian
dnf install qemu-kvm # linha redhat

Passo 2 Verificar a compatibilidade da CPU e se o driver KVM está habilitado

Antes de criar uma VM, verifique se sua CPU suporta virtualização e se a virtualização está habilitada no BIOS/UEFI. Você pode usar o seguinte comando para verificar:

$ ls -l /dev/kvm
crw-rw-rw- 1 root kvm 10, 232 Dec 21 15:22 /dev/kvm

Passo 3: Criar uma imagem de disco para a VM

Você precisará criar uma imagem de disco que servirá como o disco rígido da sua VM. Substitua my_vm_disk.img pelo nome que você deseja para o arquivo de imagem:

qemu-img create -f qcow2 my_vm_disk.img 20G

Este comando criará um arquivo de imagem de disco de 20GB no formato qcow2.

Passo 4: Iniciar a VM

Agora, você pode iniciar a VM usando o seguinte comando. Substitua my_vm_disk.img pelo caminho real do seu arquivo de imagem:

qemu-system-x86_64 -hda my_vm_disk.img -boot c -m 1024 -display gtk

Passo 5: Exemplo para instalar o sistema operacional na VM

Agora, a VM deverá inicializar como se fosse um computador real. Você pode instalar um sistema operacional na VM, seja a partir de uma imagem ISO ou outra fonte.

cd /tmp
qemu-img create -f qcow2 my_vm_disk.qcow2 15G
wget https://ftp.unicamp.br/pub/rocky/9/isos/x86_64/Rocky-x86_64-boot.iso
qemu-kvm -cpu host -hda my_vm_disk.qcow2 -boot c -m 1024 -display gtk

Montando a partição LVM da VM

Para montar a partição LVM da VM, você precisará fazer o seguinte:

# Vendo as tabelas de partições dentro da partição LVM
fdisk -l /dev/servidor_pool-vd01/lvKvmDebianLdap

# Mapeando a partição LVM que é o disco da VM em um dev loop (ex: loop14).
losetup /dev/loop14 /dev/servidor_pool-vd01/lvKvmDebianLdap

# relenado as tabelas de partições para incluir no sistema operacional
partprobe /dev/loop14 

# buscando LVM em novos discos e em seguida habilitando.
pvscan 
vgchange -ay 

# listar as partições LVM disponivel
lvs

# montando a partição LVM necessário, no exemplo o root do FS da VM
mount /dev/vg1/lvSystemRoot /mnt/r

# desmontando root
umount /mnt/r 

# Desabilitando o LVM para desassociação do disco da VM
vgchange -an vg1

# Desmapeando o disco 
losetup -d /dev/loop14

Acessando imagem qcow2 com guestfish

Aqui está uma documentação / guia passo-a-passo de como acessar e modificar uma imagem QCOW2 usando o guestfish, com base no post da Red Hat “How to customize VM and cloud images with guestfish”. (Red Hat)

Você pode usar esse guia como referência para adaptar ao seu ambiente (distribuição Linux, paths, versão de guestfish, etc.).

Visão geral

O guestfish é uma ferramenta da biblioteca libguestfs para examinar e modificar sistemas de arquivos dentro de imagens de disco de máquinas virtuais, sem precisar rodar a VM. (Red Hat)
Ele permite montar partições, editar arquivos (vi, write, edit), executar comandos de shell dentro da imagem, injetar arquivos, ajustar permissões, etc. (Red Hat)
Esse método é útil para fazer personalizações “offline” em imagens base (cloud images, imagens QCOW2 utilizadas em KVM/virt) antes de instanciar máquinas a partir delas. (Red Hat)

Pré-requisitos

Antes de começar, você deverá garantir:

Ter o pacote que fornece guestfish instalado (em muitas distros esse pacote é parte de libguestfs-tools ou equivalente). (Red Hat)
Que a imagem QCOW2 que você quer modificar esteja acessível e não esteja em uso por nenhuma VM em execução. (Red Hat)
Ter permissões de root ou usar sudo, pois muitas operações exigem acesso ao dispositivo de bloco.
Opcionalmente, conhecer ou gerar senhas criptografadas, chaves, scripts ou arquivos que você queira injetar na imagem. O artigo da Red Hat cria uma senha criptografada com openssl passwd -1. (Red Hat)

Etapas de uso do guestfish para acessar/modificar a imagem QCOW2

A seguir está o fluxo geral de uso com comandos de exemplo (adaptados):

1. Gerar senha criptografada (caso você vá editar `/etc/shadow`)

Se você quiser substituir a senha do root ou de algum usuário dentro da imagem, pode gerar um hash criptografado a ser inserido no /etc/shadow. No exemplo:

openssl passwd -1 123456
# Saída: por exemplo: $1$9pskY4to$DQT/NOOjQT7E.t.NKIzJr0

Esse hash será usado para sobrescrever a entrada do root no /etc/shadow. (Red Hat)

2. Invocar guestfish apontando a imagem QCOW2

Você pode abrir o guestfish de diferentes modos. Alguns exemplos:

Usando --rw (read-write) para permitir escrita:
```
sudo guestfish -w -a nome-da-imagem.qcow2
```
Ou usar as flags automáticas --rw e --network e -i, caso o guestfish reconheça automaticamente partições do SO convidado:
```
sudo guestfish --rw --network -i -a nome-da-imagem.qcow2
```
A flag -i (“inspect”) instrui o guestfish a localizar automaticamente os sistemas de arquivos e montá-los. (Red Hat)

Depois de iniciar, você verá um prompt do tipo:

Welcome to guestfish, the guest filesystem shell ...
Type: 'help' for help on commands

3. Ativar rede (se necessário)

No shell do guestfish, você pode habilitar recursos de rede (se for usar comandos que dependem de rede):

><fs> set-network true

4. Executar a inspeção – montar os sistemas de arquivos

Você precisa pedir ao guestfish para “rodar” a inspeção e montar as partições:

><fs> run

Depois, para ver os sistemas de arquivos detectados:

><fs> list-filesystems

Isso mostrará algo como:

/dev/sda3: xfs
/dev/sda2: vfat
/dev/sda1: unknown

No exemplo da Red Hat, /dev/sda3 é o root, /dev/sda2 é /boot/efi, etc. (Red Hat)

Em seguida, monte a partição de sistema de arquivos que você quer editar como root:

><fs> mount /dev/sda3 /

5. Editar arquivos dentro da imagem

Agora você pode usar comandos do guestfish para editar, escrever ou injetar arquivos. Exemplos:

Editar /etc/shadow para ajustar a senha do root:
```
><fs> vi /etc/shadow
```

Escrever mensagem no /etc/motd:

><fs> write /etc/motd "Mensagem personalizada"

Ajustar permissões:
```
><fs> chmod 0644 /etc/motd
```

Ajustar hostname:

><fs> write /etc/hostname "meu-host.custom"

Inserir configuração de rede (num arquivo de configuração de interface):
```
><fs> touch /etc/sysconfig/network-scripts/ifcfg-eth0
><fs> edit /etc/sysconfig/network-scripts/ifcfg-eth0
```
Ao usar edit, você entra em um editor interativo para redigir o conteúdo. No exemplo, eles inserem configurações de endereço IP estático, gateway, DNS etc. (Red Hat)

Injetar um tarball ou diretório:

><fs> tar-in /caminho/host/para/arquivo.tar /root/

Criar usuário:

><fs> command "adduser -G wheel -p 123456 -c 'Usuário Nome' usuario"

6. Relabel SELinux (se aplicável) e sincronizar

Se o sistema alvo usa SELinux, é necessário ajustar contextos antes de sair:

><fs> selinux-relabel /etc/selinux/targeted/contexts/files/file_contexts /

Sincronizar para garantir que writes sejam aplicados:

><fs> sync

7. Sair do guestfish

><fs> exit

Após isso, a imagem QCOW2 estará modificada com suas alterações.

8. (Opcional) Validar a imagem modificada

Você pode verificar se a imagem cresceu pouco (ou conforme esperado), usando:

qemu-img info nome-da-imagem.qcow2

E então instanciar uma máquina virtual a partir dessa imagem e testar as modificações (senha, hostname, rede, arquivos etc.). No exemplo do artigo, o autor cria uma VM via Cockpit usando a imagem e testa o acesso SSH, hostname, rede etc. (Red Hat)

Exemplo resumido (fluxo completo)

Aqui vai um exemplo compacto com comandos:

# (opcional) gerar hash de senha
openssl passwd -1 123456

# iniciar guestfish em modo leitura-gravação
sudo guestfish -w -a minha-imagem.qcow2

# no prompt guestfish:
><fs> set-network true
><fs> run
><fs> list-filesystems
><fs> mount /dev/sda3 /           # monta partição root
><fs> vi /etc/shadow               # editar senha root
><fs> write /etc/hostname "meu-host"
><fs> write /etc/motd "Bem-vindo!"
><fs> chmod 0644 /etc/motd
><fs> edit /etc/sysconfig/network-scripts/ifcfg-eth0
><fs> tar-in /tmp/meutool.tar /root/
><fs> command "adduser -G wheel -p 123456 -c 'Usuário Ex' meuusuario"
><fs> selinux-relabel /etc/selinux/targeted/contexts/files/file_contexts /
><fs> sync
><fs> exit

Depois:

qemu-img info minha-imagem.qcow2
# criar VM com essa imagem e testar (SSH, hostname etc.)

Dicas, cuidados e limitações

A imagem não pode estar em uso por nenhuma VM no momento da modificação.
Mudanças de rede e interfaces devem corresponder à configuração da VM destino (nomes de dispositivos, drivers de rede presentes, etc.).
Se o sistema alvo tiver UUIDs de disco, fstab ou outros identificadores rígidos, tenha atenção ao montador automático ou entradas de fstab não correspondentes.
O SELinux exige selinux-relabel ou equivalentes para que as novas alterações não causem problemas de contexto.
O guestfish pode executar comandos arbitrários no contexto do sistema de arquivos da imagem através do comando command.
Verifique permissões, chaves, scripts injetados, e consistência de configuração antes de usar a imagem em produção.

Se quiser, posso formatar isso como PDF ou Markdown bonito para você usar, ou adaptar especificamente para sua distribuição (RHEL, CentOS, Ubuntu etc.). Você quer que eu monte dessa forma para seu caso?

Curso QEMU-KVM

Abaixo tem o curso ministrado sobre o QEMU-KVM por:

Miguel Di Ciurcio Filho e William Lima Reiznautt\ http://www.students.ic.unicamp.br/~william/cursokvm/

Comandos monitor qemu: https://en.wikibooks.org/wiki/QEMU/Monitor