Como usar o Vagrant com libvirt no Debian

Pronto! Imagem box do Ubuntu Server criado.

7. Iniciar com o Vagrant

Depois de todas as etapas acima, vamos de fato iniciar com o Vagrant com libvirt no Debian. Todas as etapas teve o intuito de demonstrar a criação de um box personalizado até mesmo por medida de segurança, sabendo a fonte de criação da mesma e também podendo ser configurada para atender as suas necessidades.

O Vagrant utiliza a linguagem HCL (Hashicorp Configuration Language) baseada em Ruby que nos possibilita definir recursos da VM tais como hostname, IP, CPU, memória, disco, quantidade de máquinas para serem criadas e scripts que serão executados ao iniciar a VM. O mesmo precisa de um Provider, que é um Hypervisor e que nesse post utilizaremos o libvirt KVM/Qemu, que será utilizado para nos fornecer os recursos de virtualização.

Para saber muito mais sobre o Vagrant, explore sua documentação clicando no link abaixo.

• Documentação – Vagrant

7.1. Adicionar a box

Vamos adicionar a box criada.

Para listar a imagem box adicionada execute.

Para remover a imagem box adicionada execute.

7.2. Criar o Vagrantfile

O Vagrantfile (canse sensitive) é o arquivo de configuração que descreve o provisionamento de cada tipo de VM e que faz toda a mágica acontecer. Para criar o arquivo Vagrantfile, execute o comando com a opção -m (minimal) para remover todas as linhas comentadas e ficar somente o necessário.

Vale lembrar que daqui em diante todos os comandos deverão ser executados no diretório do projeto onde se encontra o arquivo Vagrantfile.

O arquivo Vagrantfile é bastante completo tendo muitos comentários no mesmo caso você crie sem a opção -m conforme mostrado no comando acima, e com isso você consegue subir sua VM alterando apenas o nome da box para a que criamos “ubuntu-server”.

Portanto, criaremos a nossa própria configuração de provisionamento de acordo com as modificações feitas na VM do Ubuntu Server antes de criarmos a box como no caso do SSH.

7.3. Construindo o Vagrantfile

A template que criaremos teve como base o exemplo do Rodrigo Martins.

Estrutura lógica do Vagrant

Utilizaremos com essa estrutura lógica o provisionamento de um array, onde cada bloco dentre as chaves pertence a uma VM a ser criada com suas devidas variáveis de configuração declaradas.

Segue abaixo as linhas de configuração criada, sendo comentadas cada uma para que as mesmas sejam entendidas. Nesse link Vagrantfile você pode baixar o arquivo.

7.3.1. Vagrantfile comentado

# Script a executar ao iniciar VM.
$script = <<-EOF
# Mudar a senha do usuário Vagrant.
echo ‘vagrant:zxc147’ | sudo chpasswd
# Atualizar e instalar pacotes no sistema.
apt update
apt install -y htop neofetch
EOF

# Início do array.
servers=[
# Início do primeiro bloco.
{
# Adaptador de rede do host.
:vm_network => “enp3s0”,
# Hostname da VM.
:vm_hostname => “sup-master”,
# IP da VM.
:vm_ip => “192.168.0.120”,
# Imagem box utilizada na VM.
:vm_box => “ubuntu-server”,
# Quantidade de cores CPUs da VM.
:vm_cpus => 2,
# Quantidade de Memória da VM.
:vm_mem => 1536,
# Fim do primiero bloco.
},

{
:vm_network => “enp3s0”,
:vm_hostname => “sup-node01”,
:vm_ip => “192.168.0.121”,
:vm_box => “ubuntu-server”,
:vm_cpus => 1,
:vm_mem => 1024,
},

{
:vm_network => “enp3s0”,
:vm_hostname => “sup-node02”,
:vm_ip => “192.168.0.122”,
:vm_box => “ubuntu-server”,
:vm_cpus => 1,
:vm_mem => 512,
# Fim do último bloco, observando de não ter o “,” fechando o bloco.
}
# Fim do array.
]

# Início da configuração do Vagrant em sua versão 2 baseado em ruby.
Vagrant.configure(“2”) do |config|

# Nome do array e Variável declaradas em cada bloco com o domínio “srv” mesclando adequadamente em cada configuração.
servers.each do |srv|

# Define o hostname para cada server/bloco de acordo com o domínio.
config.vm.define srv[:vm_hostname] do |node|

# Configuração da box que criamos ou que baixamos.
node.vm.box = srv[:vm_box]
# O nome que a VM vai ter ao ser criada.
node.vm.hostname = srv[:vm_hostname]
# Configuração de rede pública, com IP e interface da rede em modo bridge.
node.vm.network “public_network”,
ip: srv[:vm_ip],
dev: srv[:vm_network]

# Configuração para o provider que será utilizado, no caso libvirt.
node.vm.provider :libvirt do |kvm|
# CPUs utilizada.
kvm.cpus = srv[:vm_cpus]
# Quantidade de memória.
kvm.memory = srv[:vm_mem]
# Mapa do teclado em ABNT2.
kvm.keymap = “pt-br”
# Host padrão.
kvm.host = “localhost”
# URI da conexão do sistema QEMU, padrão usado para obter o endereço IP para gerenciamento.
kvm.uri = “qemu:///system”

# Montar compartilhamento NFS no DIR especificado (/vagrant), o valor “desabled: true” desabilita; Argumento 1 – o caminho do diretório atual do host ( “.” ); Argumento 2 – o caminho do diretório a ser montado no guest ( “/vagrant” ).
node.vm.synced_folder “.”, “/vagrant”, disabled: false

# Com o valor true, o Vagrant procurará por atualizações na caixa configurada em todos os lugares vagos.
config.vm.box_check_update = false

# A chave insegura gerada automaticamente, nesse caso deixamos desabilitada com valor falso.
config.ssh.insert_key = false

# O caminho para a chave privada a ser usada no SSH na máquina convidada. Em nosso exemplo, criamos nossa própria box personalizada com uma chave SSH personalizada, isso deverá apontar para essa chave privada.
config.ssh.private_key_path = [“~/.ssh/vagrant/vagrant_ubuntu_key”]

# Mensagem que será apresentada após o comando vagrant up.
config.vm.post_up_message = “Bem-vindo a Virtualização no SempreUpdate!!!”

# Script – está no topo deste Vagrantfile. Apenas como exemplo.
#config.vm.provision “shell”, inline: $script # Onde temos a configuração para o provisionamento que será feito, no caso o script em shell.

# Script – arquivo executável dentro do diretório do projeto. Crie de acordo com sua necessidade.
#config.vm.provision “shell”, path: “script_basic.sh”

# Script – mensagem ao carregar o Vagrant. Crie de acordo com sua necessidade. Lembre de descomentar as linhas abaixo de cada comentário.
#config.vm.provision “shell”, run: “always”, inline: <<-SHELL
# echo “Seja bem-vindo ao Vangrant!”
#SHELL

## Fim do provisionamento do domínio node.
end
## Fim da definição do bloco do domínio hostname.
end
## Fim da declaração do domínio do array.
end
## Fim da configuração do Vagrant.
end

7.4. Executar o Vagrant

Após a criação do Vagrantfile de acordo com suas necessidades, execute o comando para validar o mesmo sem nenhum erro. Caso apareça erro, deverá ser corrigido o mesmo antes de continuar.

Tendo o retorno Vagrantfile validated successfully, vamos carregar a VM, nesse caso o sup-master (hostname de um bloco).

Veja na imagem acima que todas as variáveis que declaramos no primeiro bloco do array do hostname sup-master foi carregado corretamente.

Com a VM carregada sem erros, vamos acessar a mesma com o comando abaixo.

Nas imagens abaixo veja a VM sup-master acessada, com a identificação da rede em modo bridge com o IP 192.168.0.120 e com acesso ao compartilhamento NFS do diretório do projeto ~/SempreUpdate/ProjecteFile sendo montado na VM em /vagrant.

8. Conclusão

Esse post como usar o Vagrant com libvirt no Debian foi elaborado para demostrar todas as etapas desde a instalação do Vagrant, Virt-Manager (indicando outro post para instalação do mesmo), configuração da VM previamente instalada, criação da própria imagem box em vez de fazer download das já existentes e por fim a configuração do Vagrantfile com os comentários de cada linha como visto acima.

Caso a explicação não seja a mais adequada, por favor nos comuniquem para corrigirmos, pois como muitos, sou entusiasta em relação a esta e outras ferramentas e sempre buscando conhecimento.

Para ficar atualizado no Sempre Update siga lá no canal do Telegram ou no Twitter e fique sabendo sempre de novas postagens.

Caso tenha alguma dúvida, entre em nosso grupo no Telegram e compartilhe-o.