Virtualização de Ambientes - Vagrant em ação - Parte 2
Como visto no artigo Virtualização de Ambientes - Uma introdução ao conceito e Vagrant - Parte 1, enfrentamos diversos problemas com processos repetíveis, problemas com os quais podemos resolver ao automatizamos de maneira que tudo aconteça de forma natural e controlada. Essa deve ser a busca de times que buscam ser o mais produtivo possível e utilizar seu tempo com atividades que realmente demande.
Finalmente, mão na massa!
Vamos entender melhor como funciona o Vagrant e colocar a mão na massa. A primeira parte da série de artigos aborda os problemas existentes e os problemas que a ferramenta se dispõe a resolver, só irei salientar que é extremamente recomendável ler o primeiro artigo da série sobre Virtualização de Ambientes, acompanhar de forma sequencial fará tudo ter mais sentido.
Vamos analisar melhor quais são as possibilidades que o Vagrant nos dá para criarmos a nossa Virtual Machine configurada e pronta para o uso do time de desenvolvimento.
O Vagrant tem uma interface de linha de comando, simples e extremamente útil. A partir do momento que instalamos o Vagrant em nosso sistema operacional, ele vai ficar disponível através da linha de comando. O Vagrant é construído em Ruby, e tem como sua sintaxe uma DSL em Ruby, após configurado o rodaremos a partir da linha de comando, é um processo extremamente simples que se baseia em dois passos.
- Configurar o arquivo com a DSL em Ruby;
- Rodar o Vagrant a partir da linha de comando.
O primeiro passo com o Vagrant é o **vagrant init** para inicializar o vagrant em nosso projeto, claro que tudo fica melhor com um hands-on.
**$ mkdir vagrant_project****$ cd vagrant_project****$ vagrant init ubuntu/trusty64****$ vagrant up**
Voilà!!
Adicionamos o Vagrant ao projeto e já inicializamos a nossa Virtual Machine, com poucos comandos e de forma rápida. Vale comentar que no comando vagrant init foi adicionado um argumento novo para nós até o momento, mas irei falar mais a frente sobre a sua função.
Agora temos um novo arquivo chamado Vagrantfile, esse arquivo é quem faz toda a mágica, nele passamos todas as configurações para o nosso projeto ser virtualizado. Para contextualizar melhor, esse projeto vai ter como stack o MEAN (MongoDB, Express, AngularJS, NodeJS).
Vamos verificar o conteúdo do Vagrantfile:
- na linha 8 temos a inicialização da configuração;
- na linha 15 vemos qual o box será utilizado para criar a Virtual Machine;
- na linha 71 fecha o escopo da configuração e termina o arquivo.
Não há configuração para adicionarmos o Vagrant ao nosso projeto. O arquivo foi inicializado com essas 4 linhas que interessam. O resto são comentários que o Vagrant gera no arquivo, é recomendável ler tudo para conhecer algumas configurações.
Configurando o Vagrant para gerenciar
Se formos relembrar o Vagrant é um gerenciador para a virtualização de ambientes, basicamente, contém as informações para a virtualização e delega para a ferramenta de virtualização conforme o que estiver definido nele. Essas informações ficam com o Vagrant e são as configurações que é necessária para a inicialização e utilização da VM. Vamos ver quais são as principais, conhecer melhor e assim editar o nosso arquivo.
config.vm
As configurações dentro do config.vm modificam toda a parte de alocação de hardware e virtualização da VM.
**config.vm.box**
Onde é configurado o box. Box é uma imagem que o Vagrant utiliza para clonar e criar a Virtual Machine, ao invés de termos que baixar manualmente. Temos inúmeras distribuições de sistemas para usar como nosso box, você pode buscar qual você deseja aqui;
**config.vm.network**
Onde temos a configuração de rede para acessar o nosso aplicativo pela virtual machine;
**config.vm.provision**
Onde temos a configuração para o provisionamento que será feito;
**config.vm.provider**
Onde temos a configuração para o provider que será utilizado, default é o Virtual Box;
**config.vm.synced_folder**
Onde é passado quais pastas queremos que seja sincronizada com a nossa VM, por default, a pasta onde temos o Vagrantfile já é sincronizada automaticamente sobre a pasta _/vagrant/_ na VM;
**config.vm.communicator**
Onde é configurado como será feita a comunicação entre a VM e a maquina local, por default, é utilizado ssh;
**config.vm.post_up_message**
Onde é configurado qual mensagem será apresentada após o comando vagrant up, pode ser muito útil para apresentar informações sobre como acessar todos os componentes do sistema;
config.ssh
As configurações dentro do config.ssh servem para configurar como o Vagrant irá acessar a VM via ssh.
**config.ssh.username**
Onde define qual usuário será configurado pra acessar a VM via ssh, por default, o usuário é o 'vagrant';
**config.ssh.password**
Onde define a senha para o usuário que for usado para conectar via ssh. É recomendável utilizar private_key_path para a configuração de senha;
**config.ssh.sudo_command**
Onde define que será por padrão a utilização do sudo nos comandos de shell;
config.winrm
As configurações dentro do config.winrm servem para configurar como o Vagrant irá acessar a VM com o Windows.
**config.winrm.username**
Onde define qual usuário será configurado pra acessar a VM via winrm, por default, o usuário é o 'vagrant';
**config.winrm.password**
Onde define a senha para o usuário que for usado para conectar via winrm, por default, a senha é 'vagrant';
Implementar é sempre melhor!
Bom, agora que conhecemos melhor as principais configurações do Vagrant, precisamos conhecer os comandos mais simples, vamos modificar o nosso arquivo para a criação da VM. E após isso, vamos rodar os comandos, assim teremos um fluxo de aprendizado por partes, e iremos fazer tudo isso com um hands on - :-).
Configuramos o nosso arquivo conforme o que vamos precisar por enquanto para a instalação da stack MEAN. Veja como pode ser tudo tão simples com o Vagrant, e simplicidade é a nossa busca diária, estamos mais um passo próximo do nosso ambiente de desenvolvimento pronto e de forma rápida.
Conforme o nosso arquivo Vagrantfile,
- na linha 4 começamos a nossa configuração;
- na linha 6 mantemos o mesmo box;
- na linha 8 colocamos uma mensagem para quando o Vagrant subir a maquina;
- na linha 10 configuramos a rede e o acesso a ela;
- na linha 12 é aberto um bloco para a configuração do provider, ou seja, do Virtual Box, colocamos a quantidade de memória RAM alocada;
- na linha 16 terminamos tudo.
O nosso arquivo diminui muito de tamanho, pois a partir de agora será excluido os comentários criados pelo Vagrant para termos um arquivo mais legível.
Comandos - **init, up, suspend, provision...**
**vagrant box**
Comando utilizado para gerenciar os boxes (add, remove, list, outdated, repackage, update);
**vagrant destroy**
Comando para parar a máquina em funcionamento e destruir todos os recursos que foram criados durante o processo de criação da máquina. Depois de executar este comando, o computador deve ficar em um estado limpo, como se você nunca tivesse criado a VM;
**vagrant halt**
Comando para desligar a VM;
**vagrant init [box-name] [box-url]**
Comando para inicializar o Vagrant no diretório atual, através da criação de um arquivo Vagrantfile, se o arquivo não existir;
**vagrant provision**
Comando para rodar o provisionamento conforme o que estiver configurado junto ao Vagrantfile;
**vagrant reload**
Comando equivalente a utilizar o vagrant halt e vagrant up em sequencia. Reinicializa a VM;
**vagrant ssh**
Comando para inicializar a comunicação entre a VM via ssh para acessarmos o shell.
**vagrant status**
Comando para exibir o estado em que a VM está no momento.
**vagrant suspend**
Comando para desligar a VM e salvar o estado em que ela estiver, quando inicializar a VM novamente, irá retornar ao mesmo estado.
**vagrant up**
Comando para inicializar a VM de acordo com o que estiver configurado no Vagrantfile.
Esses são os principais comandos e configurações que temos no Vagrant, claro, existe outros além desses e quem quiser conhecer sobre mais comandos e configurações, eu recomendo ler a documentação oficial.
Agora, como o esperado, precisamos testar, vamos inicializar a nossa VM com o seguinte comando:
**$ vagrant up**
Agora temos nossa VM criada e inicializada, podemos acessa-la via:
**$ vagrant ssh**
O output do comando deverá gerar a seguinte saída: 
E pronto, podemos manusear a VM da forma que desejamos. Rodem todos os comandos, vejam os outputs, testem as configurações, só assim poderá se tornar um verdadeiro mestre em virtualização de ambientes.
Tudo simples e fácil, porém, não atingimos o estado da arte desejável, criamos até agora uma VM com seu hardware alocado, mas vazia, sem as ferramentas que precisamos pra desenvolver. O próximo passo para um ambiente de desenvolvimento totalmente automatizado é o provisionamento, para isso iremos utilizar o Ansible e vamos falar sobre ele no último artigo da série de Virtualização de Ambientes. O código para isso será versionado no Github e pode ser acompanhado através desse link: Projeto Vagrant
Conclusão
Colocamos a mão na massa com o Vagrant, e vimos o quão fácil é utilizar e trabalhar com ele. Sua curva de aprendizado é curta, e é isso que eu espero que todos vejam. O Vagrant prove facilidade ao configurar ambientes totalmente portáveis e reproduzir em várias maquinas diferentes, tudo construído em um único arquivo, pronto para ser versionado e compartilhado por qualquer equipe da empresa.
Com certeza a aplicação dessa tecnologia irá trazer mais produtividade, flexibilidade e domínio da configuração de ambiente para qualquer time.