Guia Completo: Como Utilizar o Vagrant para Gerenciar Máquinas Virtuais

Introdução

Vagrant é uma ferramenta para criação e gerenciamento de máquinas virtuais de forma automatizada. Ele é usado principalmente para fins de desenvolvimento, permitindo que seja criado um ambiente de desenvolvimento padronizado que pode ser facilmente configurado e replicado.

A função do vagrant é permitir que os usuários criem e configurem máquinas virtuais de forma rápida e fácil. O vagrant pode ser usado para criar e configurar máquinas virtuais em diversos ambientes, incluindo ambientes de desenvolvimento, teste e em alguns casos produção.

Como obter a ferramenta?

Para utilizar todo o poder do Vagrant é necessário realizar o download da ferramenta.

Debian/Ubuntu:

wget -O- https://apt.releases.hashicorp.com/gpg | gpg --dearmor | sudo tee /usr/share/keyrings/hashicorp-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/hashicorp-archive-keyring.gpg] https://apt.releases.hashicorp.com $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/hashicorp.list

sudo apt update && sudo apt install vagrant

RHEL/CentOS:

sudo yum install -y yum-utils

sudo yum-config-manager --add-repo https://rpm.releases.hashicorp.com/RHEL/hashicorp.repo

sudo yum -y install vagrant

Fedora:

sudo dnf install -y dnf-plugins-core

sudo dnf config-manager --add-repo https://rpm.releases.hashicorp.com/fedora/hashicorp.repo

sudo dnf -y install vagrant

MACOS:

brew install vagrant

Windows

Links dos binários:

Amd64 – https://releases.hashicorp.com/vagrant/2.3.0/vagrant_2.3.0_windows_amd64.msi

686 – https://releases.hashicorp.com/vagrant/2.3.0/vagrant_2.3.0_windows_i686.msi

O Vagrant possui um arquivo central chamado Vagrantfile, tem como base a linguagem de programação Ruby, mas é bem simples de entender e editar, através dele podemos descrever todos os detalhes da configuração das máquinas que desejamos provisionar.

Estrutura do diretório exemplo:

vagrant
    ├── provision
    │   ├── alma.sh
    │   └── debian.sh
    └── Vagrantfile

Versões utilizadas:

Vagrant 2.2.19

VirtualBox 6.1.36

Para provisionar as máquinas a partir desta estrutura será necessário ter instalado além do Vagrant , também o VirtualBox que será o provider utilizado.

O primeiro passo para provisionamento com o Vagrant é entender como seu arquivo principal é estruturado.

# -*- mode: ruby -*-
# vi: set ft=ruby :

machines = {
  'debian' => {'memory' => '1024', 'cpus' => 1, 'ip' => '97', 'box' => 'debian/bullseye64', 'provision' => 'debian.sh'},
  'alma' => {'memory' => '1024', 'cpus' => 1, 'ip' => '22', 'box' => 'almalinux/8', 'provision' => 'alma.sh'},
}

Vagrant.configure("2") do |config|

  config.vm.box_check_update = false

  machines.each do |name, conf|
    config.vm.define "#{name}" do |m|
      m.vm.box = "#{conf['box']}"
      m.vm.network 'private_network', ip: "192.168.57.#{conf['ip']}"
      m.vm.hostname = "#{name}"
      m.vm.provider 'virtualbox' do |vb|
        vb.memory = conf['memory']
        vb.cpus = conf['cpus']
        vb.name = "#{name}"
      end
      m.vm.disk :disk, size: "25GB", name: "new_storage"
      m.vm.provision 'shell', path: "provision/#{conf['provision']}"
    end
  end
end

Os comentários iniciais são para definir o tipo de arquivo que segue o formato do ruby.

Declaramos uma variável machines que tem como conteúdo informações de configuração, definimos então um nome, no caso foi especificado um valor para a memoria e cpu, qual é o IP desta máquina, qual a box usar e qual será o arquivo de provisionamento.

A próxima linha é padrão para inicio da configuração, nessa linha também definimos qual a versão terá como base, neste caso a versão 2 será utilizada.

Ao utilizar a opção box_check_update = false dizemos para que não busque por atualizações da box.

A partir da declaração machines.each do |name, conf| ao especificar o each será analisado cada nome (name) e configuração (conf) definidos previamente, com isto em config.vm.define “#{name}” do |m| será definido um nome para as máquinas, de agora em diante para cada máquina será usada a conf especificada na variável.

Em m.vm.box definimos qual será a box utulizada, uma box é de fato a VM que irá rodar, dentro desta box contém tudo que é necessário para que uma máquina seja provisionada.

Em m.vm.network podemos definir uma rede privada, como um range e também qual IP queremos que a máquina tenha, ou pode ser definido como DHCP caso não precise de algo padronizado.

A opção m.vm.hostname define qual será o hostname de cada máquina.

Em m.vm.provider definimos qual será o provider, no caso é o VirtualBox, mas poderia ser o LibVirt ou VMwAre, por exemplo. Nesta etapa definimos algumas configurações relacionadas aos recursos das máquinas como memória e CPUS, podemos deixar alinhado também qual será o nome desta máquina no painel do VirtualBox.

A seguinte linha m.vm.disk é utilizada para gerenciamento do disco das máquinas, este recurso ainda está em fase experimental, como ele é possível por exemplo redimensionar o tamanho de um disco, ou até mesmo adicionar um novo disco às máquinas, como mostrado no exemplo.

E a última linha especifica sobre como será feito o provisionamento, foi definido que será através do shell, mas poderia ser por uma playbook do ansible, por exemplo. Como apresentado no inicio a estrutura do diretório exemplo, existe uma pasta chamada provision, dentro há dois scripts, nestes scripts pode ser definido que desejamos realizar nas máquinas, deste instalar pacotes até passar instruções para subir um servidor web ou um serviço necessário.

Para ilustração segue um simples de exemplo:

debian.sh

#!/bin/bash

apt-get install -y vim-common tzdata
timedatectl set-timezone America/Sao_Paulo
mkdir -p /root/.ssh
cp /vagrant/.keys/id_rsa* /root/.ssh
chmod 400 /root/.ssh/id_rsa*
cp /vagrant/.keys/id_rsa.pub /root/.ssh/authorized_keys

</div>

alma.sh:

</div>
#!/bin/bash

dnf install -y epel-release vim net-tools tzdata
timedatectl set-timezone America/Sao_Paulo
mkdir -p /root/.ssh
cp /vagrant/.keys/id_rsa* /root/.ssh
chmod 400 /root/.ssh/id_rsa*
cp /vagrant/.keys/id_rsa.pub /root/.ssh/authorized_keys

 

Esses scripts irão instalar alguns pacotes, garantir que a data e hora estará correta e realizar a adição uma par de chave nas máquinas para estabelecer uma conexão de confiança entre elas.

 

O principal fator de atenção neste arquivo é a indentação e o encerramento de cada bloco com o end.

Principais comandos do Vagrant:

Iniciar/Ligar uma máquina:

vagrant up <nome da maquina>

Desligar uma máquina:

vagrant halt <nome da maquina>

Verificar o status:

vagrant status

Acessar a máquina:

vagrant ssh <nome da maquina>

Reiniciar uma máquina:

vagrant reload <nome da maquina>

Destruir uma máquina:

vagrant destroy

 

Antes de continuar com o provisionamento é necessário lembrar que no arquivo foi utilizado um recurso experimental, e precisamos declarar uma variável para que o vagrant entenda que queremos utilizar este recurso, sendo assim podemos executar VAGRANT_EXPERIMENTAL que é uma variável de ambiente:

VAGRANT_EXPERIMENTAL="disks"

Este recurso ativado permitirá que o Vagrant gerencie e configure discos rígidos virtuais nas máquinas definidas no Vagrantfile.

Vamos iniciar o provisionamento das duas máquinas:

vagrant up

Saída deve ser semelhante a esta:

 

Ao finalizar e verificar o status deve estar desta forma:

 

Vamos verificar se a nossa rede foi criada:

E a interface eth1 foi adicionada com o ip 192.168.57.97 de acordo com as configurações definidas.

E o disco foi criado?

Vamos verificar:

Está disponível um segundo disco (sdb) na máquina o com o tamanho definido de 25GB.

Conclusão

Após realizar todos estes passos concluímos  que o Vagrant é bem simples de utilizar e possui uma grande vantagem para agilizar o processo de provisionamento para ambientes de teste e desenvolvimento.

Caso deseje saber mais detalhes sobre o vagrant acesse a sua documentação e divirta-se com esta ferramenta fantástica.

Despertou a curiosidade para saber mais sobre ferramentas que agilizam processos e provisionamentos na Infraestrutura?

Conheça o nosso curso INFRAESTRUTURA ÁGIL COM PRÁTICAS DEVOPS