Estação de Trabalho como Código (Parte 8): Criando Imagens com Packer

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

Introdução

Até agora, usamos imagens de disco genéricas do Debian para criar nossas máquinas virtuais. Mas em um ambiente de produção ou laboratório profissional, você frequentemente precisa de imagens customizadas com software pré-instalado, configurações específicas e hardening de segurança. É aqui que entra o Packer, uma ferramenta que automatiza a criação de imagens de máquinas virtuais.

O Packer permite definir um “template” que especifica como construir uma imagem: qual imagem base usar, quais pacotes instalar, quais arquivos copiar e quais scripts executar. Você pode reutilizar esse template para criar imagens idênticas repetidas vezes, garantindo consistência em todo o seu ambiente.

Observação: Esta parte é essencial para criar imagens reutilizáveis que serão usadas com Terraform. Se você preferir usar imagens genéricas, pode pular para a Parte 9. No entanto, recomendamos completar esta parte para entender como criar imagens profissionais.

Objetivos desta Parte

• Entender o que é Packer e como funciona
• Instalar o Packer no Ubuntu 24.04
• Entender a estrutura de um template Packer
• Criar um template Packer para QEMU/LIBVIRT
• Entender e usar Preseed para instalação automatizada
• Usar provisioners para customizar imagens
• Construir uma imagem personalizada
• Integrar Packer com workspace-as-code

Pré-requisitos

• Conclusão da Parte 7 desta série
• Terraform e LIBVIRT funcionando corretamente
• Conhecimento básico de linha de comando
• Pelo menos 30GB de espaço em disco livre

A quem se destina

Este tutorial é ideal para:

• DevOps Engineers: Que precisam criar imagens customizadas
• SysAdmins: Que querem automatizar criação de imagens
• Desenvolvedores: Que precisam de ambientes reproduzíveis
• Profissionais de TI: Que querem experimentar com automação

Pré-conhecimento: Conhecimento básico de Terraform e virtualização (coberto nas partes anteriores) é recomendado.

Tempo Estimado

⏱ 90-120 minutos

Isso inclui:

• Leitura e compreensão: ~15 min
• Instalação do Packer: ~5 min
• Preparação de arquivos: ~10 min
• Configuração de template: ~15 min
• Build da imagem (primeira vez): ~40-60 min
• Validação e testes: ~10 min

Dica Útil: O primeiro build leva mais tempo porque precisa baixar e instalar o Debian. Builds subsequentes são mais rápidos.

---

Entendendo Packer

Antes de começar a instalar, é importante entender os conceitos fundamentais.

O que é Packer?

Packer é uma ferramenta de automação que cria imagens de máquinas virtuais idênticas para múltiplas plataformas a partir de uma única configuração. Ele funciona automatizando o processo de instalação e configuração de um sistema operacional.

Como Packer Funciona?

O fluxo de trabalho do Packer é:

1. Validação: Valida o template HCL
2. Inicialização: Cria VM temporária
3. Instalação: Instala SO usando Preseed
4. Provisioning: Executa provisioners (scripts, cópias de arquivos)
5. Limpeza: Remove informações temporárias
6. Compactação: Compacta imagem final
7. Saída: Salva imagem em local especificado

Componentes Principais

Componente	Descrição
Builder	Define como criar a imagem (ex: QEMU)
Provisioner	Personaliza a imagem (scripts, arquivos)
Post-processor	Processa imagem após build (compactação)
Template	Arquivo HCL que define tudo

---

Verificando Pré-Requisitos

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

Passo 1: Verificar LIBVIRT

# Verifique se libvirtd está rodando
$ systemctl is-active libvirtd

# Você deve ver:
# active

Passo 2: Verificar Espaço em Disco

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

# Você deve ter pelo menos 30GB livres

Passo 3: Verificar Terraform

# Verifique se Terraform está instalado
$ terraform --version

# Você deve ver:
# Terraform v1.14.5

---

Instalando Packer

Passo 1: Instalar Packer

# Instale Packer (repositório HashiCorp já foi adicionado na Parte 7)
$ sudo apt install -y packer

# Verifique a instalação
$ packer --version

# Você deve ver:
# Packer v1.15.0

Passo 2: Configurar Autocompletar

# Configure autocompletar para bash
$ packer -autocomplete-install

# Recarregue o shell
$ exec bash

---

Criando Estrutura Packer

Passo 1: Criar Diretórios

# Crie a estrutura de diretórios
$ mkdir -p ~/workspace-as-code/packer/qemu/debian12/{scripts,http}
$ cd ~/workspace-as-code/packer/qemu/debian12

# Verifique
$ pwd
# /home/ubuntu/workspace-as-code/packer/qemu/debian12

Passo 2: Criar Arquivos

# Crie os arquivos necessários
$ touch main.pkr.hcl variables.pkr.hcl locals.pkr.hcl
$ touch http/preseed.cfg
$ touch scripts/cleanup.sh scripts/install-packages.sh

# Verifique
$ ls -la

---

Configurando Template Packer

Passo 1: Criar Arquivo main.pkr.hcl

$ cat > ~/workspace-as-code/packer/qemu/debian12/main.pkr.hcl << 'EOF'
packer {
  required_version = ">= 1.7.0"
  required_plugins {
    qemu = {
      source  = "github.com/hashicorp/qemu"
      version = "~> 1.0"
    }
  }
}

source "qemu" "debian12" {
  boot_command = [
    "<wait><wait><wait>c<wait><wait><wait>",
    "linux /install.amd/vmlinuz ",
    "auto=true ",
    "url=http://:/preseed.cfg ",
    "hostname=${var.vm_name} ",
    "domain=${var.domain} ",
    "interface=auto ",
    "vga=788 noprompt quiet --<enter>",
    "initrd /install.amd/initrd.gz<enter>",
    "boot<enter>"
  ]
  boot_wait              = var.boot_wait
  communicator           = "ssh"
  cpus                   = var.cpus
  accelerator            = "kvm"
  disk_cache             = "writeback"
  disk_compression       = true
  disk_discard           = "unmap"
  disk_interface         = "virtio-scsi"
  disk_size              = var.disk_size
  format                 = "qcow2"
  headless               = var.headless
  host_port_min          = 5900
  host_port_max          = 6000
  http_directory         = "http"
  iso_checksum           = var.iso_checksum
  iso_target_extension   = "iso"
  iso_urls               = ["${var.iso_url}"]
  machine_type           = "q35"
  efi_boot               = true
  efi_firmware_code      = "/usr/share/OVMF/OVMF_CODE.fd"
  efi_firmware_vars      = "/usr/share/OVMF/OVMF_VARS.fd"
  memory                 = var.memory
  net_device             = "virtio-net"
  output_directory       = "output-${var.vm_name}"
  qemu_binary            = "/usr/bin/qemu-system-x86_64"
  shutdown_command       = "echo '${var.ssh_password}' | sudo -S poweroff"
  shutdown_timeout       = var.shutdown_timeout
  ssh_password           = var.ssh_password
  ssh_timeout            = var.ssh_timeout
  ssh_username           = var.ssh_username
  vm_name                = var.vm_name
}

build {
  name = "debian12-image"
  sources = [
    "source.qemu.debian12"
  ]

  # Provisioner 1: Atualizar sistema
  provisioner "shell" {
    execute_command = "echo '${var.ssh_password}' |  sudo -E -S ''"
    inline = [
      "echo '==> Atualizando sistema'",
      "sudo apt-get update",
      "sudo apt-get -y dist-upgrade",
      "sudo apt-get -y autoremove",
      "sudo apt-get -y autoclean"
    ]
  }

  # Provisioner 2: Instalar pacotes essenciais
  provisioner "shell" {
    execute_command = "echo '${var.ssh_password}' |  sudo -E -S ''"
    script          = "scripts/install-packages.sh"
  }

  # Provisioner 3: Executar script de limpeza
  provisioner "shell" {
    execute_command = "echo '${var.ssh_password}' |  sudo -E -S ''"
    script          = "scripts/cleanup.sh"
  }

  # Provisioner 4: Preencher espaço livre com zeros
  provisioner "shell" {
    execute_command = "echo '${var.ssh_password}' |  sudo -E -S ''"
    inline = [
      "echo '==> Preenchendo espaço livre com zeros'",
      "dd if=/dev/zero of=/ZEROFILL bs=1M status=progress || true",
      "sync",
      "rm -f /ZEROFILL"
    ]
  }
}
EOF

# Verifique
$ cat ~/workspace-as-code/packer/qemu/debian12/main.pkr.hcl

Passo 2: Criar Arquivo variables.pkr.hcl

$ cat > ~/workspace-as-code/packer/qemu/debian12/variables.pkr.hcl << 'EOF'
variable "vm_name" {
  type        = string
  default     = "debian12-template"
  description = "Nome da máquina virtual"
}

variable "domain" {
  type        = string
  default     = "lab.local"
  description = "Domínio da máquina"
}

variable "cpus" {
  type        = number
  default     = 2
  description = "Número de CPUs"
}

variable "memory" {
  type        = number
  default     = 2048
  description = "Memória em MB"
}

variable "disk_size" {
  type        = number
  default     = 20480
  description = "Tamanho do disco em MB"
}

variable "headless" {
  type        = bool
  default     = true
  description = "Executar sem interface gráfica"
}

variable "boot_wait" {
  type        = string
  default     = "10s"
  description = "Tempo de espera antes de enviar boot commands"
}

variable "ssh_username" {
  type        = string
  default     = "debian"
  description = "Usuário SSH"
}

variable "ssh_password" {
  type        = string
  default     = "debian"
  sensitive   = true
  description = "Senha SSH"
}

variable "ssh_timeout" {
  type        = string
  default     = "20m"
  description = "Timeout de SSH"
}

variable "shutdown_timeout" {
  type        = string
  default     = "5m"
  description = "Timeout de shutdown"
}

variable "iso_url" {
  type        = string
  default     = "https://cdimage.debian.org/cdimage/release/12.7.0/amd64/iso-cd/debian-12.7.0-amd64-netinst.iso"
  description = "URL da ISO do Debian"
}

variable "iso_checksum" {
  type        = string
  default     = "sha256:a7e0b0e6c7e9e5f5e5f5e5f5e5f5e5f5e5f5e5f5e5f5e5f5e5f5e5f5e5f5e5"
  description = "Checksum da ISO"
}
EOF

# Verifique
$ cat ~/workspace-as-code/packer/qemu/debian12/variables.pkr.hcl

Passo 3: Criar Arquivo locals.pkr.hcl

$ cat > ~/workspace-as-code/packer/qemu/debian12/locals.pkr.hcl << 'EOF'
locals {
  timestamp = regex_replace(timestamp(), "[- TZ:]", "")
}
EOF

# Verifique
$ cat ~/workspace-as-code/packer/qemu/debian12/locals.pkr.hcl

Passo 4: Criar Arquivo Preseed

$ cat > ~/workspace-as-code/packer/qemu/debian12/http/preseed.cfg << 'EOF'
# Configuração de Locale
d-i debian-installer/language string en
d-i debian-installer/country string US
d-i debian-installer/locale string en_US.UTF-8

# Configuração de Teclado
d-i keyboard-configuration/xkb-keymap select us

# Configuração de Rede
d-i netcfg/choose_interface select auto
d-i netcfg/get_hostname string debian12
d-i netcfg/get_domain string lab.local
d-i netcfg/dhcp_timeout string 60

# Configuração de Relógio
d-i time/zone string UTC
d-i clock-setup/utc boolean true

# Configuração de Usuário
d-i passwd/root-login boolean false
d-i passwd/user-fullname string Debian User
d-i passwd/username string debian
d-i passwd/user-password password debian
d-i passwd/user-password-again password debian

# Configuração de Espelho
d-i mirror/country string manual
d-i mirror/http/hostname string deb.debian.org
d-i mirror/http/directory string /debian
d-i mirror/http/proxy string

# Configuração de Pacotes
tasksel tasksel/first multiselect standard, ssh-server
d-i pkgsel/include string sudo, curl, wget, git, vim, htop, net-tools, qemu-guest-agent, cloud-init
d-i pkgsel/upgrade select full-upgrade

# Configuração de Particionamento
d-i partman-auto/disk string /dev/sda
d-i partman-auto/method string regular
d-i partman-auto/choose_recipe select atomic
d-i partman-partitioning/confirm_write_new_label boolean true
d-i partman/choose_partition select finish
d-i partman/confirm boolean true
d-i partman/confirm_nooverwrite boolean true

# Configuração de GRUB
d-i grub-installer/only_debian boolean true
d-i grub-installer/bootdev string default

# Configuração Final
d-i finish-install/reboot_in_progress note
d-i preseed/late_command string \
  in-target sed -i 's/^#\s*\(%sudo\s\)/\1/' /etc/sudoers; \
  in-target echo 'debian ALL=(ALL) NOPASSWD: ALL' >> /etc/sudoers.d/debian
EOF

# Verifique
$ cat ~/workspace-as-code/packer/qemu/debian12/http/preseed.cfg

Passo 5: Criar Scripts de Provisioning

# Script de instalação de pacotes
$ cat > ~/workspace-as-code/packer/qemu/debian12/scripts/install-packages.sh << 'EOF'
#!/bin/bash
set -e

echo "==> Instalando pacotes essenciais"
sudo apt-get install -y \
  build-essential \
  curl \
  wget \
  git \
  vim \
  htop \
  net-tools \
  openssh-server \
  openssh-client \
  qemu-guest-agent \
  cloud-init \
  unattended-upgrades

echo "==> Habilitando qemu-guest-agent"
sudo systemctl enable qemu-guest-agent
sudo systemctl start qemu-guest-agent

echo "==> Instalação de pacotes concluída"
EOF

# Script de limpeza
$ cat > ~/workspace-as-code/packer/qemu/debian12/scripts/cleanup.sh << 'EOF'
#!/bin/bash
set -e

echo "==> Limpando cache do APT"
sudo apt-get clean
sudo apt-get autoclean
sudo apt-get autoremove -y

echo "==> Removendo logs"
sudo find /var/log -type f -name "*.log" -exec truncate -s 0 {} \;
sudo find /var/log -type f -name "*.gz" -delete

echo "==> Removendo histórico de shell"
history -c
cat /dev/null > ~/.bash_history

echo "==> Limpeza concluída"
EOF

# Tornar scripts executáveis
$ chmod +x ~/workspace-as-code/packer/qemu/debian12/scripts/*.sh

# Verifique
$ ls -la ~/workspace-as-code/packer/qemu/debian12/scripts/

---

Executando Packer

Passo 1: Validar Template

# Navegue para o diretório
$ cd ~/workspace-as-code/packer/qemu/debian12

# Valide o template
$ packer validate .

# Você deve ver:
# The configuration is valid.

Passo 2: Formatar Template

# Formate os arquivos
$ packer fmt .

# Você deve ver os arquivos formatados

Passo 3: Inspecionar Template

# Inspecione o template
$ packer inspect .

# Você deve ver informações sobre o template

Passo 4: Executar Build

# Execute o build (isso leva 40-60 minutos)
$ packer build .

# Você verá progresso como:
# ==> Executing builder ...
# ==> Running builder ...
# Build 'debian12-image' finished after 45 minutes 30 seconds.
# 
# --> debian12-image: Artifacts saved in: output-debian12-template

---

Verificando Imagem Criada

Passo 1: Listar Imagens

# Verifique se a imagem foi criada
$ ls -lh ~/workspace-as-code/packer/qemu/debian12/output-debian12-template/

# Você deve ver:
# -rw-r--r-- debian12-template.qcow2 (~ 500 MB)

Passo 2: Inspecionar Imagem

# Obtenha informações sobre a imagem
$ qemu-img info ~/workspace-as-code/packer/qemu/debian12/output-debian12-template/debian12-template.qcow2

# Você deve ver:
# image: debian12-template.qcow2
# file format: qcow2
# virtual size: 20 GiB
# disk size: 500 MiB

Passo 3: Copiar para Templates

# Copie a imagem para o diretório de templates
$ cp ~/workspace-as-code/packer/qemu/debian12/output-debian12-template/debian12-template.qcow2 \
  ~/workspace-as-code/kvm/templates/debian12-packer.qcow2

# Verifique
$ ls -lh ~/workspace-as-code/kvm/templates/

---

Exemplos Práticos

Exemplo 1: Build com Variáveis Customizadas

# Execute build com variáveis personalizadas
$ packer build \
  -var 'vm_name=debian12-custom' \
  -var 'cpus=4' \
  -var 'memory=4096' \
  .

Exemplo 2: Build com Arquivo de Variáveis

# Crie arquivo de variáveis
$ cat > custom.pkrvars.hcl << 'EOF'
vm_name = "debian12-prod"
cpus    = 4
memory  = 4096
EOF

# Execute build
$ packer build -var-file=custom.pkrvars.hcl .

Exemplo 3: Adicionar Provisioner de Arquivo

# Adicione ao main.pkr.hcl
provisioner "file" {
  source      = "files/app.tar.gz"
  destination = "/tmp/app.tar.gz"
}

provisioner "shell" {
  execute_command = "echo '${var.ssh_password}' |  sudo -E -S ''"
  inline = [
    "cd /tmp",
    "tar -xzf app.tar.gz",
    "cd app",
    "./install.sh"
  ]
}

---

Tabela de Comandos Packer

Comando	Descrição
packer validate	Valida template
packer fmt	Formata arquivos HCL
packer inspect	Inspeciona template
packer build	Executa build
packer build -debug	Build com modo debug
packer build -var	Build com variáveis
packer build -var-file	Build com arquivo de variáveis

---

Troubleshooting

Erro: “ISO checksum mismatch”

Problema: Checksum da ISO não corresponde.

Solução:

# Obtenha o checksum correto
$ sha256sum ~/workspace-as-code/kvm/isos/debian-12.7.0-amd64-netinst.iso

# Atualize o arquivo variables.pkr.hcl com o checksum correto

Erro: “SSH connection timeout”

Problema: Packer não consegue conectar via SSH.

Solução:

# Verifique se a VM está rodando
$ virsh list

# Aumente o timeout
$ packer build -var 'ssh_timeout=30m' .

Erro: “Disk space insufficient”

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

Solução:

# Verifique espaço
$ df -h ~/workspace-as-code/

# Libere espaço ou mude diretório de saída

Build muito lento

Problema: Build está demorando muito.

Solução:

# Aumente recursos
$ packer build \
  -var 'cpus=4' \
  -var 'memory=4096' \
  .

# Ou use headless=false para ver progresso
$ packer build -var 'headless=false' .

Preseed não está funcionando

Problema: Instalação não automatizada.

Solução:

# Verifique arquivo preseed.cfg
$ cat http/preseed.cfg

# Execute com debug
$ packer build -debug .

# Pressione 'c' para continuar quando solicitado

---

Dicas e Boas Práticas

Dica 1: Use Variáveis para Reutilização

# Defina variáveis para fácil customização
variable "base_image" {
  type    = string
  default = "debian12"
}

# Use em múltiplos templates

Dica 2: Organize Scripts em Diretórios

# Crie estrutura clara
scripts/
├── install-packages.sh
├── configure-network.sh
├── install-docker.sh
└── cleanup.sh

Dica 3: Use Post-processors para Compactação

post-processor "compress" {
  output = "debian12-template-compressed.qcow2"
}

Dica 4: Versione Imagens

# Use timestamp em nomes
output_directory = "output-${var.vm_name}-${local.timestamp}"

Dica 5: Teste Imagens Antes de Usar

# Crie VM de teste
$ virt-install \
  --import \
  --name test-image \
  --disk ~/workspace-as-code/kvm/templates/debian12-packer.qcow2 \
  --network network=lab-network

---

Integrando com workspace-as-code

Passo 1: Organizar Estrutura

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

# Você deve ver:
# ~/workspace-as-code/packer/
# └── qemu/
#     └── debian12/
#         ├── main.pkr.hcl
#         ├── variables.pkr.hcl
#         ├── locals.pkr.hcl
#         ├── http/
#         │   └── preseed.cfg
#         ├── scripts/
#         │   ├── install-packages.sh
#         │   └── cleanup.sh
#         └── output-debian12-template/
#             └── debian12-template.qcow2

Passo 2: Criar .gitignore

# Crie arquivo .gitignore
$ cat > ~/workspace-as-code/packer/.gitignore << 'EOF'
# Packer output
output-*/
*.qcow2
crash.log

# Variáveis sensíveis
*.auto.pkrvars.hcl
EOF

# Verifique
$ cat ~/workspace-as-code/packer/.gitignore

Passo 3: Versionar no Git

# Adicione ao Git
$ cd ~/workspace-as-code
$ git add packer/
$ git commit -m "feat: add packer configuration for debian12 image"
$ 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 Packer

echo "Validando Packer..."

# Verificar Packer
if command -v packer &> /dev/null; then
    echo "✓ Packer instalado"
else
    echo "✗ Packer não instalado"
    exit 1
fi

# Verificar versão
if packer version | grep -q "v1"; then
    echo "✓ Packer versão OK"
else
    echo "✗ Versão do Packer incorreta"
    exit 1
fi

# Verificar arquivos
if [ -f "main.pkr.hcl" ]; then
    echo "✓ Arquivo main.pkr.hcl existe"
else
    echo "✗ Arquivo main.pkr.hcl não existe"
    exit 1
fi

# Validar template
if packer validate . &> /dev/null; then
    echo "✓ Template Packer válido"
else
    echo "✗ Template Packer inválido"
    exit 1
fi

# Verificar preseed
if [ -f "http/preseed.cfg" ]; then
    echo "✓ Arquivo preseed.cfg existe"
else
    echo "✗ Arquivo preseed.cfg não existe"
    exit 1
fi

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

---

Conclusão

Você aprendeu a usar Packer para criar imagens de máquinas virtuais personalizadas e reutilizáveis. Com Packer, você pode automatizar a criação de imagens consistentes, garantindo que todas as VMs tenham a mesma configuração.

O Que Você Alcançou

✓ Entendimento de Packer e como funciona ✓ Instalação do Packer ✓ Criação de template Packer ✓ Configuração de Preseed para instalação automatizada ✓ Uso de provisioners para customização ✓ Build de imagem personalizada ✓ Integração com workspace-as-code

Próximos Passos Imediatos

1. Verifique pré-requisitos:

   $ systemctl is-active libvirtd
   $ df -h ~/workspace-as-code/kvm/
   

2. Instale Packer:

   $ sudo apt install -y packer
   $ packer --version
   

3. Crie estrutura:

   $ mkdir -p ~/workspace-as-code/packer/qemu/debian12/{scripts,http}
   $ cd ~/workspace-as-code/packer/qemu/debian12
   

4. Configure template:

   $ packer validate .
   $ packer fmt .
   

5. Execute build:

   $ packer build .
   

6. Versione no Git:

   $ cd ~/workspace-as-code
   $ git add packer/
   $ git commit -m "feat: add packer configuration"
   $ git push origin main
   

Próximo Tutorial

Com imagens customizadas criadas com Packer, o próximo passo é aprender a testar e validar essas imagens antes de usá-las em produção.

• Próximo: Estação de Trabalho como Código (Parte 9): Testando e Validando Imagens

---

Recursos Adicionais

• Packer Documentation
• Packer QEMU Builder
• Preseed Documentation
• Packer Best Practices
• Debian Installation Guide

---

Fim da Parte 8

Próxima: Testando e Validando Imagens