Antes da TriadWorks entrar de cara na área de ensino e treinamentos a empresa durante muito tempo atuou como consultoria, onde a maior parte dos trabalhos tinha a ver com definição de arquitetura e tecnologias, gerenciamento de equipes e processo de desenvolvimento. O curioso, é que em cada empresa que prestávamos consultoria havia projetos e ambientes de desenvolvimento bem diferenciados, que ia desde a versão da JVM até servidores de aplicação e banco de dados. Algumas destas diferenças nos ambientes e projetos podem ser vistas logo abaixo:

• versões do Java: alguns usavam versões antigas da JVM como Java 5 ou 6 e até implementações que não da Oracle, como OpenJDK;
• banco de dados: projetos rodando no MySQL, Oracle, PostgreSQL ou Firebird. Muitas vezes a aplicação se integrava com vários SGBDs ao mesmo tempo;
• servidores de aplicação: alguns projetos rodavam em Tomcat, enquanto outros optavam por Jetty ou JBoss.
• outras plataformas: projetos desenvolvidos em Delphi, Ruby on Rails e até projetos menores desenvolvidos em C;
• sistemas operacionais: haviam desenvolvedores trabalhando em Linux, Windows e MacOSX;
• integrações entre aplicações: para piorar, era comum o projeto principal da empresa se integrar com outros projetos que rodavam noutra plataforma, banco ou versão de servidor de aplicação;

Como consultor, não era fácil ter todos estas ferramentas e servidores configurados na máquina, pois era comum haver problemas e conflitos entre versões de banco de dados, servidores de aplicação, bibliotecas, sistemas de arquivos, regras de firewall e até mesmo conflito entre as portas do sistema operacional.

Não me canso de lembrar das vezes que tive de formatar e reinstalar o MacOSX por causa da bagunça que havia feito no sistema operacional. - Rafael Ponte

Para resolver isso, nossa melhor opção era trabalhar com máquinas virtuais (VM), como a VirtualBox. Nela conseguíamos instalar o que fosse necessário para determinado projeto e, ao fim da consultoria, descartar aquele ambiente.

Simplificou um pouco nossa vida, mas ainda tínhamos um problema: tudo era feito MANUALMENTE. Era necessário algumas horas ou dias para baixar e configurar a VM, instalar cada aplicativo, servidor, banco de dados, depois fazer o backup e, quando necessário, distribuir a VM para o resto da equipe.

Agora imagina ter que compartilhar uma .iso de 25gb? Só quem já passou por isso sabe do que estou falando...

Se perdêssemos essa VM configurada ou ela corrompesse por algum motivo nós tínhamos que fazer TUDO de novo, TUDO! Ah, não parece tão ruim assim, né? E para lembrar todos os passos e detalhes da configuração feitos há 6 meses atrás? Eis aí um problemão especialmente chatinho de resolver!

Precisávamos de uma maneira automatizada de criar, configurar, compartilhar e gerenciar nossos ambientes, nossas VMs...

Automatizando o ambiente com Vagrant

Foi aí que conhecemos o Vagrant! Ele é uma ferramenta para automatizar a criação, configuração e principalmente gerenciamento de ambientes de desenvolvimento através de máquinas virtuais (VM) via softwares de virtualização como VirtualBox, VMWare, Parallels, entre outros.

A idéia principal do Vagrant é você poder montar e configurar uma máquina virtual de maneira totalmente AUTOMATIZADA através de um conjunto de instruções escritas usando a DSL (Domain-Specific Language) da própria ferramenta. Sempre que você rodar essas instruções o resultado deverá ser o mesmo.

Para nós, desenvolvedores, o Vagrant irá isolar dependências e configurações em um único ambiente virtual, consistente e descartável, sem precisar sacrificar nenhuma das ferramentas que estamos acostumados a trabalhar. Para isso, só precisamos criar um único arquivo dentro do projeto, o Vagrantfile, e logo em seguida dar um simples comando para que todo o ambiente seja montado, instalado e configurado.

Outra grande vantagem é a possibilidade de replicar o mesmo ambiente de maneira fácil e rápida em diferentes máquinas.

E como eu compartilho este ambiente com minha equipe?

Por as configurações do Vagrant serem apenas arquivos texto, elas podem estar embutidas dentro do seu projeto e controle de versão (como Git), onde qualquer membro da equipe poderá baixar e criar o próprio ambiente de desenvolvimento a partir do Vagrantfile criado por você. Isso é genial, não é?

No final das contas, todos os desenvolvedores da equipe estarão rodando o mesmo ambiente independente do sistema operacional utilizado na máquina hospedeira. Como dito no próprio site do Vagrant:

Dê adeus à desculpa "na minha máquina roda"!

Agora precisamos instalar o Vagrant na máquina de cada desenvolvedor e configurar um ambiente para entender como ele funciona...

Instalando o Vagrant

Para esse post, consideraremos que a máquina hospedeira (máquina do desenvolvedor) roda o sistema operacional Linux Ubuntu. Mas estes passos com pouquíssimas diferenças podem ser aplicados para Windows ou MacOSX.

Instalar o Vagrant no Ubuntu é extremamente fácil. Primeiro, precisamos instalar o programa VirtualBox, que é um dos gigantes em que o Vagrant se apoia, utilizando-o para criar dinamicamente máquinas virtuais configuráveis, leves e portáteis. Para isso, execute o seguinte comando no terminal:

sudo apt-get install virtualbox

Após o VirtualBox ter sido instalado corretamente, instalaremos agora o Vagrant. No
terminal, execute:

sudo apt-get install vagrant

Para ter certeza que o Vagrant foi instalado como esperado, ainda no terminal, digite o comando a seguir:

vagrant -v

Este comando vai exibir a versão do Vagrant que você acabou de instalar, algo semelhante a "Vagrant 1.7.4".

Pronto! Já podemos começar a usar o Vagrant...

Configurando o projeto com Vagrant

Escolha e acesse, via terminal, um diretório ou projeto qualquer existente da sua máquina. Caso não tenha um projeto em mãos ou queria apenas testar o Vagrant, você pode executar os comandos abaixo:

mkdir meu_projeto
cd meu_projeto

Agora, iremos criar o arquivo que conterá toda a configuração inicial do nosso ambiente virtual. Esse arquivo é o Vagrantfile, mencionado anteriormente. Ele será criado automaticamente quando executarmos o seguinte comando:

vagrant init hashicorp/precise64

Após o comando ser completado, o arquivo Vagrantfile será criado no diretório atual com a configuração para uma máquina virtual Ubuntu 12.04 LTS 64-bit. Agora, para rodar esta VM basta executar o comando abaixo:

vagrant up

O comando vagrant up criará uma VM do VirtualBox, instalará o Ubuntu nessa VM usando a imagem determinada por nós (hashicorp/precise64) e iniciará o Ubuntu. É importante ter paciência ao rodar este comando pela primeira vez, pois o Vagrant terá que baixar a VM da internet de um repositório global com VMs pré-configuradas.

Se o comando foi executado com sucesso, já podemos utilizar nossa máquina virtual. Para isso, podemos conectar na VM via SSH através do comando a seguir:

vagrant ssh

Dentro da VM você pode fazer o que quiser, como instalar servidores de aplicação, banco de dados relacionais e não relacionais, filas de mensagens etc. Tudo será instalado e configurado de forma isolada dentro dela. Se por algum motivo você bagunçar a VM ou não precisar mais dela, você pode simplesmente destruí-la e recomeçar tudo de novo. Para destruí-la basta rodar o comando:

vagrant destroy

Peraí, não precisarei mais baixar um .iso, executar a interface gráfica do VirtualBox e seguir seu passo-a-passo? Exatamente... o Vagrant automatizou o processo para nós! Dessa forma, criar uma VM, acessá-la e logo em seguida destruí-la é uma mera questão de comandos no terminal.

E o Java e Tomcat, quem vai instalar na minha VM? É aí que entra um conceito extremamente importante do Vagrant...

Provisionamento

A VM instalada pelo Vagrant vem enxuta e normalmente não satisfaz os requisitos do nosso ambiente de desenvolvimento. Podemos até logar via SSH e configurar o ambiente como bem entendermos, instalando o Java, o Tomcat e tudo mais... porém toda vida que recriarmos a VM teremos que fazer estes mesmos passos...

Não era bem o que tínhamos em mente, não é?

O ideal é que o Vagrant fizesse isso automaticamente sempre criássemos a VM no primeiro comando vagrant up. Para isso, eu teria que de alguma forma indicar ao Vagrant para executar alguns comandos dentro da VM assim que ela fosse inicializada. Esses comandos poderiam estar em um script shell, como abaixo:

sudo apt-get -y update
sudo apt-get -y install openjdk-7-jdk
sudo apt-get -y install tomcat7
sudo service tomcat7 start

Pronto! Agora só resta indicar ao Vagrant para rodar o script inicializacao.sh acima que fica localizado na raiz do nosso projeto. Para isso, precisamos configurar o arquivo Vagrantfile como a seguir:

# todos os comentários foram removidos para limpar o arquivo

Vagrant.configure("2") do |config|
    config.vm.box = "hashicorp/precise64"
    config.vm.provision :shell, path: "inicializacao.sh"
end

Basicamente adicionamos a linha config.vm.provision informando o tipo do arquivo a ser provisionado (:shell) e sua localização relativa dentro do projeto. Para finalizar, só precisamos executar o comando vagrant up e nossa VM será criada e configurada a partir do nosso script shell.

Este conceito de configurar a máquina virtual no momento em que ela é criada é chamada de PROVISIONAMENTO. O Vagrant permite rodar outros tipos de provisionadores mais robustos como Puppet, Chef ou Ansible.

A principal vantagem de usar o provisionamento do Vagrant é que podemos automatizar todo o processo de configuração da VM o que nos permite ter ambientes replicáveis. E o melhor, tudo isso sem a interação humana!

Um pouco mais sobre Vagrantfile

Por fim, para ter certeza que o Tomcat foi instalado e está rodando, precisamos acessá-lo preferencialmente de fora da VM. Para isso, podemos configurar o Vagrantfile e habilitar o seu redirecionamento de portas, como abaixo:

Vagrant.configure("2") do |config|
    # outras configurações

    config.vm.network "forwarded_port", guest: 8080, host: 8089
end

A configuração acima nos permitirá acessar a porta 8080 da VM através da porta 8089 da máquina hospedeira. Agora, basta reiniciar sua VM e abrir seu navegador preferido e digitar http://localhost:8089 para ver a página inicial do Tomcat:

Pronto! Já criamos, configuramos e acessamos nosso ambiente de desenvolvimento virtual. E todo esse processo é automatizado pelo Vagrant. Podemos, inclusive, excluir a máquina virtual criada com o comando vagrant destroy, que quando criarmos outra máquina com vagrant up, será uma máquina nova e idêntica a anterior. Percebemos que não importa quantas máquinas criemos, elas sempre seguirão as configurações especificadas no Vagrantfile.

O arquivo Vagrantfile nos permite descrever o tipo de VM que queremos para nosso projeto e como provisionaremos esta VM. Ele possui muito mais configurações, que vão desde outras configurações de rede, outros tipos de providers além da VirtualBox, sincronização de diretórios entre a VM e máquina hospedeira até configuração da CPU e memória utilizada pela VM e muito mais...

Meu ambiente é seu ambiente

Com Vagrant podemos criar ambientes de desenvolvimento padronizados e facilmente configuráveis para um projeto. Dessa forma, um novo desenvolvedor poderá configurar seu ambiente de maneira simples e em questões de minutos ou horas.

Na TriadWorks, por exemplo, as apostilas para os nossos cursos são geradas numa VM de 256mb do Vagrant, dessa forma os instrutores não precisam se preocupar em configurar todo um ambiente no seu notebook. Além disso, hoje em dia praticamente não instalamos mais bancos de dados nas nossas máquinas, todos os bancos são instalados e configurados em VMs do Vagrant.

Com Vagrant você pode ir ainda mais longe, como configurar e gerenciar ambientes de homologação ou mesmo produção para rodar sua bateria de testes e estresse ou simplesmente para simular um bug que só ocorre em produção!

E você, já conhecia o Vagrant? Que outras ferramentas você utiliza para automatizar seu ambiente de desenvolvimento?