Estação de Trabalho como Código (Parte 6): Virtualizando com KVM e LIBVIRT

Tutorial Anterior: Estação de Trabalho como Código (Parte 5): Customizando o GNOME Terminal e a Interface do Ubuntu

Introdução

Até agora, focamos em configurar nosso ambiente de linha de comando e personalizar nossa interface visual. Agora, daremos um salto significativo em direção à infraestrutura como código, começando com a virtualização local.

O KVM (Kernel-based Virtual Machine) é um hipervisor de código aberto integrado ao kernel do Linux, permitindo que máquinas Linux funcionem como plataformas de virtualização. O LIBVIRT é uma API e um conjunto de ferramentas que simplificam o gerenciamento de máquinas virtuais, redes e armazenamento. Juntos, KVM e LIBVIRT transformam sua estação de trabalho em um laboratório de infraestrutura profissional.

Nesta parte, vamos transformar sua estação de trabalho em um laboratório completo, permitindo criar, testar e destruir máquinas virtuais rapidamente. Isso é fundamental para as próximas partes, onde usaremos Terraform e Packer para automatizar a criação de imagens e infraestrutura.

Observação: Esta parte é essencial para as próximas etapas da série. Se você preferir não usar virtualização local, pode pular para a Parte 11 (Multi-Cloud). No entanto, recomendamos completar esta parte para ter um laboratório local funcional.

Objetivos desta Parte

• Entender o que é KVM, LIBVIRT e QEMU e como funcionam juntos
• Verificar o suporte de virtualização do processador (Intel VT-x ou AMD-V)
• Instalar KVM, QEMU, LIBVIRT e ferramentas relacionadas
• Configurar permissões para usar LIBVIRT sem sudo
• Criar e configurar pools de armazenamento para máquinas virtuais
• Configurar redes virtuais para as máquinas virtuais
• Criar e testar a primeira máquina virtual
• Integrar configurações com workspace-as-code e versioná-las no Git

Pré-requisitos

• Conclusão da Parte 5 desta série
• Processador com suporte a virtualização (Intel VT-x ou AMD-V)
• Pelo menos 8GB de RAM disponível
• Pelo menos 50GB de espaço em disco livre

A quem se destina

Este tutorial é ideal para:

• DevOps Engineers: Que precisam de um laboratório local para testar infraestrutura
• SysAdmins: Que querem aprender virtualização em um ambiente controlado
• Desenvolvedores: Que precisam testar aplicações em múltiplos ambientes
• Profissionais de TI: Que querem experimentar com infraestrutura como código

Pré-conhecimento: Conhecimento básico de linha de comando (coberto nas partes anteriores) é recomendado.

Tempo Estimado

⏱ 60-75 minutos

Isso inclui:

• Leitura e compreensão: ~15 min
• Verificação de pré-requisitos: ~5 min
• Instalação de pacotes: ~10 min
• Configuração de pools e redes: ~15 min
• Criação de primeira VM: ~15-20 min
• Troubleshooting (se necessário): ~5 min

Dica Útil: Se você quiser apenas copiar e colar, pode fazer em 40 minutos. Mas recomendamos ler e entender cada seção.

---

Entendendo KVM, LIBVIRT e QEMU

Antes de começar a instalar, é importante entender como essas três tecnologias trabalham juntas.

O que é KVM?

KVM (Kernel-based Virtual Machine) é um módulo do kernel Linux que transforma o Linux em um hipervisor. Ele permite que máquinas virtuais rodem com performance próxima à nativa, pois aproveita recursos de virtualização do processador (Intel VT-x ou AMD-V).

O que é QEMU?

QEMU (Quick Emulator) é um emulador de máquina que pode funcionar de forma independente ou em conjunto com KVM. Quando usado com KVM, QEMU fornece a emulação de dispositivos (disco, rede, etc) enquanto KVM fornece a virtualização do processador.

O que é LIBVIRT?

LIBVIRT é uma API e um conjunto de ferramentas que simplificam o gerenciamento de máquinas virtuais. Ele oferece uma interface unificada para trabalhar com diferentes hipervisores (KVM, QEMU, Xen, etc), facilitando a automação e o gerenciamento.

Como Funcionam Juntos?

Componente	Função
KVM	Virtualização de CPU (integrado ao kernel)
QEMU	Emulação de dispositivos (disco, rede, etc)
LIBVIRT	Interface unificada para gerenciar tudo
Virt-Manager	Interface gráfica para LIBVIRT

Quando você cria uma VM usando LIBVIRT, o fluxo é:

1. LIBVIRT recebe o comando
2. LIBVIRT instrui QEMU a criar uma máquina virtual
3. QEMU usa KVM para virtualização de CPU
4. QEMU emula os dispositivos
5. VM executa com performance próxima à nativa

---

Verificando Pré-Requisitos

Antes de instalar, certifique-se de que seu ambiente está pronto.

Passo 1: Verificar Suporte de Virtualização do Processador

# Verifique se o processador suporta virtualização
$ grep -E 'vmx|svm' /proc/cpuinfo | head -1

# Se o comando retornar algo com 'vmx' (Intel) ou 'svm' (AMD), sua CPU suporta virtualização
# Você deve ver algo como:
# flags: ... vmx ... (para Intel)
# flags: ... svm ... (para AMD)

Se não houver saída, você pode precisar habilitar a virtualização no BIOS da sua máquina.

Atenção: Se o processador não suportar virtualização, você não conseguirá usar KVM. Neste caso, considere usar máquinas virtuais em nuvem (Parte 11+).

Passo 2: Verificar se o Módulo KVM Está Carregado

# Verifique se o módulo KVM está carregado
$ lsmod | grep kvm

# Você deve ver algo como:
# kvm_intel             290816  0
# kvm                   921600  1 kvm_intel

Se o módulo não estiver carregado, carregue-o manualmente:

# Para Intel
$ sudo modprobe kvm
$ sudo modprobe kvm_intel

# Ou para AMD
$ sudo modprobe kvm
$ sudo modprobe kvm_amd

# Verifique novamente
$ lsmod | grep kvm

Passo 3: Verificar Espaço em Disco

# Verifique espaço disponível
$ df -h

# Você deve ter pelo menos 50GB livres
# Exemplo:
# /dev/sda1  ext4  500G  200G  300G  40% /

Passo 4: Verificar RAM Disponível

# Verifique RAM disponível
$ free -h

# Você deve ter pelo menos 8GB de RAM
# Exemplo:
#                total        used        free
# Mem:           15Gi        4.5Gi       10.5Gi

---

Instalando KVM, QEMU e LIBVIRT

Passo 1: Instalar Pacotes Necessários

# Atualize o gerenciador de pacotes
$ sudo apt update

# Instale os pacotes necessários
$ sudo apt install -y \
  qemu-system-x86 \
  qemu-kvm \
  libvirt-daemon-system \
  libvirt-clients \
  virt-manager \
  virt-viewer \
  libosinfo-bin \
  ovmf \
  guestfs-tools

# Verifique a instalação
$ virsh version --daemon

# Você deve ver:
# Compiled against library: libvirt 10.0.0
# Using library: libvirt 10.0.0
# Using API: QEMU 10.0.0
# Running hypervisor: QEMU 8.2.2
# Running against daemon: 10.0.0

Passo 2: Adicionar Usuário ao Grupo KVM

Para usar LIBVIRT sem sudo, adicione seu usuário ao grupo kvm:

# Adicione o usuário ao grupo kvm
$ sudo usermod -aG kvm $USER

# Adicione também ao grupo libvirt
$ sudo usermod -aG libvirt $USER

# Aplique as mudanças de grupo (sem fazer logout)
$ newgrp kvm
$ newgrp libvirt

# Verifique se funcionou
$ virsh list

# Você deve ver:
#  Id   Name   State
# ----+--------+-------

Informação: Se receber erro de permissão, faça logout e login novamente.

Passo 3: Iniciar e Habilitar Serviços

# Inicie o daemon libvirtd
$ sudo systemctl start libvirtd

# Habilite para iniciar automaticamente
$ sudo systemctl enable libvirtd

# Verifique o status
$ sudo systemctl status libvirtd

# Você deve ver:
# ● libvirtd.service - Virtualization daemon
#    Loaded: loaded
#    Active: active (running)

---

Configurando Pools de Armazenamento

Pools de armazenamento organizam onde as máquinas virtuais e suas imagens serão armazenadas.

Passo 1: Criar Diretórios

# Crie os diretórios para armazenamento
$ mkdir -p ~/workspace-as-code/kvm/{images,templates,isos}

# Verifique se foram criados
$ ls -la ~/workspace-as-code/kvm/

# Você deve ver:
# drwxr-xr-x images
# drwxr-xr-x templates
# drwxr-xr-x isos

Passo 2: Criar Pools de Armazenamento

# Crie o pool de imagens (discos das VMs)
$ virsh pool-define-as images --type dir --target ~/workspace-as-code/kvm/images

# Crie o pool de templates (imagens base)
$ virsh pool-define-as templates --type dir --target ~/workspace-as-code/kvm/templates

# Crie o pool de ISOs (imagens de instalação)
$ virsh pool-define-as isos --type dir --target ~/workspace-as-code/kvm/isos

# Inicie os pools
$ virsh pool-start images
$ virsh pool-start templates
$ virsh pool-start isos

# Habilite para iniciar automaticamente
$ virsh pool-autostart images
$ virsh pool-autostart templates
$ virsh pool-autostart isos

# Verifique se foram criados
$ virsh pool-list --all

# Você deve ver:
#  Name       State    Autostart
# -----------+----------+-----------
#  images     active   yes
#  templates  active   yes
#  isos       active   yes

Passo 3: Verificar Informações dos Pools

# Obtenha informações sobre um pool
$ virsh pool-info images

# Você deve ver:
# Name:           images
# UUID:           a5b9dbca-fb51-49cd-89b5-2a7512d11e51
# State:          running
# Persistent:     yes
# Autostart:      yes
# Capacity:       100.00 GiB
# Allocation:     0.00 B
# Available:      100.00 GiB

---

Configurando Redes Virtuais

Redes virtuais permitem que máquinas virtuais se comuniquem entre si e com a rede externa.

Passo 1: Criar Arquivo de Configuração de Rede

# Crie o arquivo de configuração de rede
$ cat > ~/workspace-as-code/kvm/lab-network.xml << 'EOF'
<network>
  <name>lab-network</name>
  <forward mode='nat'>
    <nat>
      <port start='1024' end='65535'/>
    </nat>
  </forward>
  <bridge name='virbr1' stp='on' delay='0'/>
  <ip address='192.168.123.1' netmask='255.255.255.0'>
    <dhcp>
      <range start='192.168.123.2' end='192.168.123.254'/>
    </dhcp>
  </ip>
</network>
EOF

# Verifique se foi criado
$ cat ~/workspace-as-code/kvm/lab-network.xml

Passo 2: Definir Rede no LIBVIRT

# Defina a rede
$ virsh net-define ~/workspace-as-code/kvm/lab-network.xml

# Inicie a rede
$ virsh net-start lab-network

# Habilite para iniciar automaticamente
$ virsh net-autostart lab-network

# Verifique se foi criada
$ virsh net-list --all

# Você deve ver:
#  Name          State    Autostart   Persistent
# ---------------+---------+-----------+-----------
#  default       active   yes         yes
#  lab-network   active   yes         yes

Passo 3: Verificar Configuração de Rede

# Obtenha informações sobre a rede
$ virsh net-info lab-network

# Você deve ver:
# Name:          lab-network
# UUID:          12345678-1234-1234-1234-123456789012
# Active:        yes
# Persistent:    yes
# Autostart:     yes
# Bridge:        virbr1

# Verifique a interface de rede
$ ip addr show virbr1

# Você deve ver:
# 3: virbr1: <BROADCAST,MULTICAST,UP,LOWER_UP>
#     inet 192.168.123.1/24 brd 192.168.123.255 scope global virbr1

---

Criando Sua Primeira Máquina Virtual

Passo 1: Baixar Imagem ISO

# Baixe a ISO do Ubuntu 24.04
$ wget https://releases.ubuntu.com/24.04/ubuntu-24.04-live-server-amd64.iso \
  -O ~/workspace-as-code/kvm/isos/ubuntu-24.04-live-server-amd64.iso

# Verifique o download
$ ls -lh ~/workspace-as-code/kvm/isos/

# Você deve ver:
# -rw-r--r-- ubuntu-24.04-live-server-amd64.iso (~ 2.5 GB)

Passo 2: Criar Máquina Virtual

# Crie uma máquina virtual Ubuntu
$ virt-install \
  --virt-type kvm \
  --machine q35 \
  --name ubuntu-lab-01 \
  --description "Ubuntu 24.04 Lab VM" \
  --boot uefi \
  --cdrom ~/workspace-as-code/kvm/isos/ubuntu-24.04-live-server-amd64.iso \
  --os-variant ubuntu24.04 \
  --disk pool=images,size=32,format=qcow2,bus=virtio,cache=none \
  --memory 4096 \
  --vcpus 2 \
  --cpu host-passthrough \
  --network network=lab-network,model=virtio \
  --graphics spice \
  --noautoconsole

# Você deve ver:
# Starting install process
# Creating domain...
# Domain creation completed

Passo 3: Verificar Máquina Virtual

# Liste as máquinas virtuais em execução
$ virsh list

# Você deve ver:
#  Id   Name              State
# ----+------------------+--------
#  1   ubuntu-lab-01     running

# Obtenha informações sobre a VM
$ virsh dominfo ubuntu-lab-01

# Você deve ver:
# Name:           ubuntu-lab-01
# UUID:           12345678-1234-1234-1234-123456789012
# OS Type:        hvm
# State:          running
# CPU(s):         2
# CPU time:       15.2s
# Max memory:     4194304 KiB
# Used memory:    4194304 KiB
# Persistent:     yes
# Autostart:       off
# Managed save:    no

Passo 4: Conectar à Máquina Virtual

# Abra a console da VM
$ virt-viewer ubuntu-lab-01

# Ou use virt-manager para interface gráfica
$ virt-manager

---

Exemplos Práticos

Exemplo 1: Criar VM com Configuração Customizada

# Crie uma VM com mais recursos
$ virt-install \
  --virt-type kvm \
  --machine q35 \
  --name ubuntu-dev \
  --description "Ubuntu Development VM" \
  --boot uefi \
  --cdrom ~/workspace-as-code/kvm/isos/ubuntu-24.04-live-server-amd64.iso \
  --os-variant ubuntu24.04 \
  --disk pool=images,size=64,format=qcow2,bus=virtio,cache=none \
  --memory 8192 \
  --vcpus 4 \
  --cpu host-passthrough \
  --network network=lab-network,model=virtio \
  --graphics spice \
  --noautoconsole

Exemplo 2: Gerenciar Máquinas Virtuais

# Listar todas as VMs (rodando e paradas)
$ virsh list --all

# Desligar uma VM
$ virsh shutdown ubuntu-lab-01

# Ligar uma VM
$ virsh start ubuntu-lab-01

# Reiniciar uma VM
$ virsh reboot ubuntu-lab-01

# Forçar desligamento (se necessário)
$ virsh destroy ubuntu-lab-01

# Remover uma VM completamente
$ virsh undefine ubuntu-lab-01 --remove-all-storage

Exemplo 3: Clonar Máquina Virtual

# Clone uma VM existente
$ virt-clone \
  --original ubuntu-lab-01 \
  --name ubuntu-lab-02 \
  --file ~/workspace-as-code/kvm/images/ubuntu-lab-02.qcow2

# Você deve ver:
# Allocating 'ubuntu-lab-02.qcow2'
# Clone 'ubuntu-lab-02' created successfully

---

Tabela de Opções de virt-install

Opção	Descrição	Exemplo
--virt-type	Tipo de hipervisor	kvm, qemu, xen
--machine	Tipo de máquina	q35 (recomendado), pc
--name	Nome da VM	ubuntu-lab-01
--memory	RAM em MB	4096 (4GB)
--vcpus	Número de CPUs	2, 4, 8
--disk	Configuração de disco	pool=images,size=32,format=qcow2
--cdrom	Caminho para ISO	~/kvm/isos/ubuntu.iso
--network	Configuração de rede	network=lab-network,model=virtio
--graphics	Tipo de gráficos	spice, vnc, none
--os-variant	Variante do SO	ubuntu24.04, debian12, win11
--boot	Modo de boot	uefi, bios
--cpu	Modo de CPU	host-passthrough, host-model

---

Troubleshooting

Erro: “KVM not available”

Problema: Módulo KVM não está carregado.

Solução:

# Carregue o módulo KVM
$ sudo modprobe kvm
$ sudo modprobe kvm_intel  # ou kvm_amd para AMD

# Verifique
$ lsmod | grep kvm

Erro: “Permission denied” ao usar virsh

Problema: Usuário não está no grupo libvirt.

Solução:

# Adicione usuário ao grupo
$ sudo usermod -aG libvirt $USER

# Aplique mudanças
$ newgrp libvirt

# Verifique
$ virsh list

Erro: “Network not found”

Problema: Rede lab-network não foi criada.

Solução:

# Verifique redes existentes
$ virsh net-list --all

# Se não existir, crie
$ virsh net-define ~/workspace-as-code/kvm/lab-network.xml
$ virsh net-start lab-network
$ virsh net-autostart lab-network

Erro: “Pool not found”

Problema: Pool de armazenamento não foi criado.

Solução:

# Verifique pools existentes
$ virsh pool-list --all

# Se não existir, crie
$ virsh pool-define-as images --type dir --target ~/workspace-as-code/kvm/images
$ virsh pool-start images
$ virsh pool-autostart images

VM não consegue acessar a internet

Problema: Rede NAT não está funcionando corretamente.

Solução:

# Verifique a rede
$ virsh net-info lab-network

# Reinicie a rede
$ virsh net-destroy lab-network
$ virsh net-start lab-network

# Dentro da VM, configure DHCP
$ sudo dhclient eth0

Erro: “Insufficient disk space”

Problema: Não há espaço em disco para criar VM.

Solução:

# Verifique espaço disponível
$ df -h ~/workspace-as-code/kvm/

# Libere espaço ou mude o diretório de armazenamento
$ virsh pool-edit images  # Edite o caminho

---

Dicas e Boas Práticas

Dica 1: Use Snapshots para Testar

# Crie um snapshot antes de fazer mudanças
$ virsh snapshot-create-as ubuntu-lab-01 before-changes

# Liste snapshots
$ virsh snapshot-list ubuntu-lab-01

# Reverta para um snapshot
$ virsh snapshot-revert ubuntu-lab-01 before-changes

Dica 2: Configure Autostart para VMs Importantes

# Habilite autostart
$ virsh autostart ubuntu-lab-01

# Desabilite autostart
$ virsh autostart --disable ubuntu-lab-01

Dica 3: Use Virt-Manager para Gerenciamento Gráfico

# Abra virt-manager
$ virt-manager

# Interface gráfica facilita gerenciamento de VMs, redes e armazenamento

Dica 4: Organize VMs em Grupos

# Use nomes descritivos
$ virt-install ... --name web-server-01
$ virt-install ... --name db-server-01
$ virt-install ... --name cache-server-01

Dica 5: Faça Backup de Configurações

# Exporte configuração de VM
$ virsh dumpxml ubuntu-lab-01 > ~/workspace-as-code/kvm/ubuntu-lab-01.xml

# Exporte configuração de rede
$ virsh net-dumpxml lab-network > ~/workspace-as-code/kvm/lab-network.xml

# Versione no Git
$ cd ~/workspace-as-code
$ git add kvm/
$ git commit -m "backup: kvm configurations"

---

Integrando com workspace-as-code

Passo 1: Organizar Estrutura de Diretórios

# Verifique a estrutura
$ tree ~/workspace-as-code/kvm/

# Você deve ver:
# ~/workspace-as-code/kvm/
# ├── images/
# ├── templates/
# ├── isos/
# ├── lab-network.xml
# └── README.md

Passo 2: Criar README com Documentação

$ cat > ~/workspace-as-code/kvm/README.md << 'EOF'
# KVM e LIBVIRT Configuration

Configuração de virtualização local usando KVM e LIBVIRT.

## Estrutura

- `images/`: Discos das máquinas virtuais (qcow2)
- `templates/`: Imagens base para clonagem
- `isos/`: Imagens de instalação (ISO)
- `lab-network.xml`: Configuração de rede virtual

## Comandos Úteis

### Máquinas Virtuais

```bash
virsh list --all          # Listar todas as VMs
virsh start <vm-name>     # Ligar VM
virsh shutdown <vm-name>  # Desligar VM
virsh reboot <vm-name>    # Reiniciar VM
virsh destroy <vm-name>   # Forçar desligamento

Redes

virsh net-list --all      # Listar redes
virsh net-info lab-network  # Informações de rede

Pools

virsh pool-list --all     # Listar pools
virsh pool-info images    # Informações de pool

EOF

Verifique

$ cat ~/workspace-as-code/kvm/README.md

### Passo 3: Versionar no Git

```bash
# Adicione ao Git
$ cd ~/workspace-as-code
$ git add kvm/
$ git commit -m "feat: add kvm and libvirt configuration"
$ git push origin main

# Verifique
$ git log --oneline | head -5

---

Script de Validação

Para verificar se tudo foi configurado corretamente:

#!/bin/bash
# Script de validação de KVM/LIBVIRT

echo "Validando KVM/LIBVIRT..."

# Verificar KVM
if grep -q "vmx\|svm" /proc/cpuinfo; then
    echo "✓ CPU suporta virtualização"
else
    echo "✗ CPU não suporta virtualização"
    exit 1
fi

# Verificar módulo KVM
if lsmod | grep -q "^kvm"; then
    echo "✓ Módulo KVM carregado"
else
    echo "✗ Módulo KVM não carregado"
    exit 1
fi

# Verificar libvirtd
if systemctl is-active --quiet libvirtd; then
    echo "✓ Daemon libvirtd ativo"
else
    echo "✗ Daemon libvirtd inativo"
    exit 1
fi

# Verificar pools
if virsh pool-list | grep -q "images"; then
    echo "✓ Pool 'images' existe"
else
    echo "✗ Pool 'images' não existe"
    exit 1
fi

# Verificar rede
if virsh net-list | grep -q "lab-network"; then
    echo "✓ Rede 'lab-network' existe"
else
    echo "✗ Rede 'lab-network' não existe"
    exit 1
fi

echo ""
echo "Validação concluída com sucesso!"

---

Conclusão

Você transformou sua estação de trabalho em um laboratório de virtualização profissional. Com KVM e LIBVIRT configurados, você pode criar, testar e destruir máquinas virtuais rapidamente, fornecendo um ambiente perfeito para as próximas partes da série.

O Que Você Alcançou

✓ Entendimento de KVM, LIBVIRT e QEMU ✓ Verificação de suporte de virtualização ✓ Instalação de ferramentas necessárias ✓ Configuração de permissões ✓ Criação de pools de armazenamento ✓ Configuração de redes virtuais ✓ Criação de primeira máquina virtual ✓ Integração com workspace-as-code

Próximos Passos Imediatos

1. Verifique pré-requisitos:

   $ grep -E 'vmx|svm' /proc/cpuinfo | head -1
   

2. Instale pacotes:

   $ sudo apt install -y qemu-system-x86 qemu-kvm libvirt-daemon-system libvirt-clients virt-manager
   

3. Configure permissões:

   $ sudo usermod -aG kvm $USER
   $ sudo usermod -aG libvirt $USER
   $ newgrp libvirt
   

4. Crie pools e rede:

   $ mkdir -p ~/workspace-as-code/kvm/{images,templates,isos}
   $ virsh pool-define-as images --type dir --target ~/workspace-as-code/kvm/images
   

5. Versione no Git:

   $ cd ~/workspace-as-code
   $ git add kvm/
   $ git commit -m "feat: add kvm and libvirt setup"
   $ git push origin main
   

Próximo Tutorial

Com virtualização local estabelecida, o próximo passo é automatizar a criação de máquinas virtuais usando Terraform, transformando nossa infraestrutura em código.

• Próximo: Estação de Trabalho como Código (Parte 7): Infraestrutura como Código com Terraform e LIBVIRT

---

Recursos Adicionais

• KVM Documentation
• LIBVIRT Documentation
• Virt-Manager Documentation
• QEMU Documentation
• Ubuntu Cloud Images

---

Fim da Parte 6

Próxima: Infraestrutura como Código com Terraform e LIBVIRT