Vagrant - um tutorial prático

Olá! Este é um tutorial que estou desenvolvendo sobre o Vagrant enquanto estudo um pouco mais sobre ele. Ele está público em http://paulojeronimo.github.io/tutorial-vagrant. Os fontes, um documento no formato AsciiDoctor e um script shell para sua construção, estão disponíveis num repositório GitHub. Ele também possui uma versão em PDF, caso você queira baixá-lo para impressão.

Ainda não gerei nenhum release desse tutorial. Portanto, considere esta versão como em desenvolvimento. Essa primeira release deverá ser publicada na primeira semana de setembro.

O Vagrant é muito utilizado em ambientes de desenvolvimento para automatizar a sua instalação. Neste tutorial eu não apresento os motivos para utilizá-lo pois foco na parte prática, pressupondo que você já tenha o embasamento teórico que inclui suas motivações de uso. Caso esse não seja o teu caso, eu sugiro que você leia a página Why Vagrant e/ou ouça o GrokPodcast, nos episódios 100, 101 e 102. Nesses episódios são discutidos o Vagrant e o Docker que, em breve, também pretendo apresentar um caso prático a respeito.

Antes de começar a utilizar o Vagrant eu criei um projeto pessoal e caseiro que utilizo para criar minhas próprias máquinas virtuais (VMs). Esse projeto ainda está ativo e disponibilizado em http://github.com/paulojeronimo/vms. Digo que vale a pena você dar uma lida nele para que compreenda o quanto pode ser interessante o uso do Vagrant. Dando uma olhada neste projeto você perceberá que eu criei, de minha forma e utilizando scripts Bash, boa parte das soluções que o Vagrant resolve. Mas, especificamente para a utilização de VMs executadas no VirtualBox. Isso me deixa um pouco limitado além do fato de me fazer concentar na criação de scripts para gerar estas VMs. Apesar de gostar muito dessa área de automação, tudo o que eu preciso, no final das contas, são de VMs pré-configuradas para utilizar em alguns laboratórios e tutoriais que crio. Dessa forma, para mim o Vagrant resolve parte de meus problemas pois acaba com certas "distrações" em meu processo de criar VMs.

Após ouvir um pouco de teoria sobre Vagrant e Docker no GrokPodcast, e também de dar uma olhada no projeto pessoal que citei, volte para cá e comece a explorar as coisas de forma prática, mão na massa! =)

Para começar este tutorial você precisará ter instalado o Ruby, o VirtualBox e o Vagrant, em teu ambiente. No momento em que escrevo esta versão do tutorial, estas são as versões para as ferramentas que tenho instaladas:

Nesta versão do tutorial eu estou apresentando a execução do Vagrant para gerar uma VM Fedora 20, utilizando o OS X instalado em meu Mac. Contudo, os passos que demonstro aqui também ser reproduzidos em Linux e, numa próxima versão deste tutorial, eu demonstrarei sua execução no Fedora que tenho instalado em meu Mac, para gerar uma VM Ubuntu.

Vamos começar criando um novo diretório para este tutorial:

A execução do comando vagrant sem nenhum parâmetro apresenta-nos várias possibilidades. Executemos o comando abaixo para observar sua saída:

Temos várias opções disponíveis, não é? Por exemplo, para verificar a versão do Vagrant executemos o seguinte comando:

Devemos notar também que, na primeira execução do Vagrant, será criado o diretório ~/.vagrant.d.

Vejamos a estrutura desse diretório:

A saída desse comando em meu ambiente é a seguinte:

Para localizar os boxes (VMs, na linguagem do Vagrant) disponíveis para a instalação acessemos a URL https://vagrantcloud.com/discover/featured. Observamos que nesse site são encontrados inúmeros boxes, produzidos por diferentes usuários. Podemos notar também que é possível criar nosso próprio box e publicá-lo pois há opções para isso (mais a frente discutiremos a esse respeito).

Localizado o box que gostaríamos de usar, vamos agora criar um novo diretório para iniciá-lo. Iniciaremos um box Fedora 20 executando:

Pela saída do último comando acima, observemos que isso gerará um arquivo Vagrantfile no diretório corrente. Esse arquivo nada mais é que um código Ruby. Vejamos o seu conteúdo:

Para colocar o box que foi iniciado em execução, executemos:

A saída desse comando apresenta alguns detalhes interessantes. Dentre as linhas mostradas, notemos as seguintes:

Observemos que só há um adaptador de rede nessa box e que ele está configurado para usar NAT. Dessa forma, só conseguiríamos fazer um ssh para esse box através do uso de um túnel SSH reverso. O interessante é que o Vagrant já cria esse túnel para nós, facilitando nossa vida! =)

Podemos perceber, pela leitura da saída acima, que o SSH será feito do hospedeiro (HOST) para o box através da porta 2222. Num HOST Linux ou OS X, por exemplo, é possível verificar isso através do comando a seguir:

Também podemos notar que o Vagrant já monta uma pasta compartilhada /vagrant associando-a ao diretório onde o box foi iniciado ~/tutorial-vagrant. Isso facilita a troca de arquivos entre e o box e o HOST.

Um último detalhe é que, após colocarmos o box em execução, também é criado o diretório .vagrant, no diretório de inicialização do box. Observemos isso executando os comandos a seguir:

Para listar os boxes instalados (podemos estar qualquer diretório), executemos:

Observemos, pela saída do comando executado acima, que são apresentadas as informações do nome do box, o provider que está executando-o e sua versão:

Experimentemos, agora, fazer um ssh para o box. Executemos:

No shell, dentro do box, executemos:

Para ver o status do box, executemos:

Observemos que a saída desse comando nos informa que, para parar a VM, podemos executar um vagrant suspend ou um vagrant halt (esse último é como se fosse pressionar o botão power off da máquina com ela em funcionamento).

Suspendamos a execução da VM:

Se observarmos a tela de administração do VirtualBox, notaremos que a execução da VM foi suspensa. Poderíamos desligar o computador, ir tomar um café ou fazer qualquer outra coisa. Outra hora, poderíamos voltar e colocar a VM em funcionamento novamente. Mas, por agora, façamos isto:

Enviemos um comando para desligar a VM, via SSH:

Será solicitada a senha do usuário vagrant que, por padrão, é vagrant. Um detalhe: para evitar passar essa senha a cada execução do comando ssh, gere sua chave pública com o comando ssh-keygen (se ainda não tiver uma) e utilize o comando ssh-copy-id para inserí-la no arquivo ~/.ssh/authorized_keys do usuário vagrant. Note também que o usuário vagrant tem permissões de root, conforme as configurações definidas no arquivo /etc/sudoers.

Executemos mais uma vez o comando a seguir. Ele deverá nos informar que a VM está no estado de desligada.

Agora, removamos o registro da VM. Para isso, serão necessários dois passos. O primeiro deles é executar e observar a saída do comando a seguir:

No meu caso, sua saída foi essa:

O que nos importa é o id do box. Com ele podemos solicitar sua destruição, executando o comando a seguir (informe o id apresentado em tua saída):

Um detalhe a respeito desse id (5d24c9b): a cada vez que destruímos e inicializamos uma nova VM, esse número muda.

O comando vagrant destroy <id> forcará a parada da VM e também removerá seu registro do provider (no caso, o VirtualBox). Notemos, entretanto, que esse “destroy” na verdade só remove o box (VM) do VirtualBox (ou do provider em que ela estiver sendo utilizado). O box baixado ainda continua disponível para ser registrado novamente no VirtualBox pois ele permanece no diretório ~/.vagrant.d.

Agora, repitamos o comando tree ~/.vagrant.d e observemos a estrutura final do dotfile do Vagrant:

Em meu ambiente, esta é a saída produzida:

Façamos um backup do diretório dotfile para testarmos um comando logo a seguir:

Agora, executemos:

Observemos, pela saída do comando a seguir, que o box foi eliminado do diretório ~/.vagrant.d:

Após termos feito isso, se for necessário executar novamente esse box o Vagrant terá que fazer o seu download outra vez. Como não queremos isso nesse instante, vamos simplesmente voltar o que tinhamos, através do rsync:

Isso é o básico de Vagrant! Utilizando-o percebemos o quanto fica simples trabalhar com VMs, baixando-as de um repositório de VMs já existentes. Mas, agora, resolvamos outra questão: e se quisermos ter a nossa própria VM registrada nesse repositório?

É nesse ponto que entram as ferramentas Packer, ou o Veewee.

O Packer é um projeto da própria HashiCorp, a empresa fundada pelo Mitchell Hashimoto e que está por trás do desenvolvimento do Vagrant. O Packer é desenvovido em Go e, se quiséssemos fazer seu uso sem ser através dos binários de instalação disponíveis, precisaríamos de montar um ambiente de desenvolvimento para o trabalho com essa linguagem. Em próximos tutoriais eu falarei sobre o uso do Packer mas, se você já quiser ver exemplos de como construir VMs com o seu uso, eu sugiro, por exemplo, que você veja o projeto packer-templates do Satashi Matsumoto.

O Veewee, por sua vez, é uma ferramenta Ruby. Utilizarei-o nesse primeiro tutorial.

Esse é um tópico avançado deste tutorial, consome algum tempo e é um processo tedioso (assim como citado na página "Creating a Base Box". Eu não espero que você consiga seguir-me em sua execução pois, para isso, você precisaria criar um mirror local do Fedora e, também, disponibilizá-lo através de um servidor HTTP em tua máquina, assim como eu faço em meu projeto vms. Portanto, prosseguirei a execução deste tutorial sozinho e espero que você consiga voltar para cá e adaptar os comandos que apresento para o teu ambiente de forma que, em seguida, possa me dar um feedback positivo sobre sua execução.

Para iniciar a criação de um box próprio, meu primeiro passo é instalar o Veewee através do gems:

Para definir minha VM, eu utilizo um template. E, para listar os templates disponíveis para a geração de um Fedora, por exemplo, executo:

Utilizarei, como template de definição para o Fedora 20, o template Fedora-19-x86_64. Então, executo:

Heisenbug é o codenome oficial para o Fedora 20. Veja o histórico de codenomes do Fedora.

Esse comando gerará diversos arquivos, dentro do diretório corrente, no diretório definitions. Vejamos quais:

Em meu ambiente, esta é a saída:

Precisamos ajustar esses arquivos de acordo com nossas necessidades.

No meu caso particular, onde gero minha vm-fedora e disponiblizo-a para que as pessoas possam executar alguns dos meus tutoriais, eu edito os arquivos ks.cfg e o definitions.rb. Vou baixar o meu projeto veewee-definitions para mostrar minhas alterações na estrutura que Veewee gerou localmente, na saída que apresentei acima. Farei isso executando os seguintes comandos:

A saída do diff, que apresentarei a seguir, poderá variar no futuro se o meu projeto veewee-definitions sofrer atualizações. Mas, no momento em que escrevo este tutorial, esta é a saída:

As mudanças que eu faço no arquivo definition.rb são apenas para aumentar a memória da VM, diminuir o tamanho do seu disco e, na sua geração, utilizar o ISO e o mirror que tenho locais em minha máquina. Detalhe: eu crio e utilizo esse mirror local (veja como em meu projeto mirrors) pois, sem ele, o Veewee teria que baixar vários pacotes pela Internet e isso tornaria o processo de geração da VM ainda mais lento.

Outro detalhe é que, antes de iniciar a construção da VM, o Veewee fará uma cópia de alguns ISOs para o diretório iso, casos eles já não estejam lá. Como, em meu caso, eu já possuo estes isos localmente no sistema de arquivos do meu Mac (na estrutura de diretórios do mirror do Fedora), eu executo os seguintes passos:

Para encontrar o valor de iso_sha1 que configurei no arquivo definition.rb, no Mac, eu executo:

Finalmente, terminadas as edições dos arquivos em definitions (e a geração, opcional, dos links para os isos), a construção da VM através do Veewee é feita de forma totalmente automática (sem nehum input de nossa parte), pela execução do seguinte comando:

O processo de construção da VM leva cerca de 10 minutos em meu Mac. Quando esse processo termina, eu executo o seginte comando para encerrar a execução do box gerado:

Para disponibilizar o box para uso do Vagrant, executo:

Esse último comando gera o arquivo Fedora-20-x86_64.box, no diretório corrente, e apresenta uma instrução para que esse box possa ser importado pelo Vagrant. No meu ambinte, sua saída é esta:

Para testar, o box gerado, eu sigo as instruções passadas:

Como no diretório corrente já existe um Vagrantfile, eu preciso movê-lo para Vagrantfile.old, pois continuo a execução deste tutorial nesse mesmo diretório:

Inicio o novo box que acabei de importar:

Executo o box e faço um ssh para ele:

Por fim, faço destruição do box:

That’s all! Agora sei que o box está funcionando. Minha última tarefa é publicá-lo para que outras pessoas possam utilizá-lo.

O repositório de onde o Vagrant baixa as VMs (boxes) é o Vagrant Cloud. Dessa forma preciso criar minha conta nesse serviço para poder utilizá-lo e após criá-la, posso configurar meus próprios boxes.

O site Vagrant Cloud apresenta um passo a passo muito simples para que possamos publicar nossos próprios boxes. É só segui-lo, não tem segredos e os passos são descritos na página Creating a new Box! =) Num dos últimos passos é necessário informar uma URL para a localização do box (o arquivo com a extensão .box). No meu caso, eu informo o link público para o box que publico em minha conta no Google Drive. Por fim, depois de ter meu box publicado no Vagrant, eu posso utilizá-lo através do comando a seguir:

Daí é só usar, como eu expliquei anteriormente!

Todas as VMs que criamos no Vagrant Cloud também ficam acessíveis através de uma URL contendo nosso nome de usuário no Vagrant Cloud. A minha URL é https://vagrantcloud.com/paulojeronimo/.

O Vagrant pode ser extremamente útil para vários ambientes (desenvolvimento, integração, …​). Especificamente no caso de ambientes de desenvolvimento, sua utilização pode facilitar enormemente a inclusão de um novo desenvolvedor num projeto pois reduz, de forma significativa, o tempo de setup inicial que esse desenvolvedor teria para montar o seu ambiente. Além disso, cria um ambiente comum e de configurações iguais para todos os desenvolvedores de uma mesma equipe. A utilização do Veewee oferece visibilidade a todo o processo de montagem da VM e apresenta, de forma clara, todas as etapas e configurações necessárias para a criação de uma VM.