Concrete Logo
Hamburger button

Criando ambientes virtualizados com Vagrant

  • Blog
  • 31 de Outubro de 2012
Share

logo_vagrant-81478652
Existem centenas de “receitas” para criar um software web. Você pode utilizar Ruby, PHP, Java, Node.js, com banco de dados MySQL, PostgreSQL, MongoDB, Redis, servidor web Apache, NGinx, etc. aproveitando a versão xyz de cada uma dessas ferramentas.

Além disso, existem diferentes sistemas operacionais disponíveis, como CentOS, Debian, Ubuntu, etc. Ou seja, cada projeto pode aproveitar um conjunto muito variado de dependências.

E mais, a maioria dos projetos de software possui mais de uma pessoa envolvida no desenvolvimento. E cada uma deve montar seu ambiente de desenvolvimento utilizando as mesmas ferramentas, como manda o figurino.

O problema é que isso nem sempre (nunca?) acontece. Um desenvolvedor prefere utilizar Mac OS com Homebrew ou Macports. Outro prefere Linux com apt-get ou yum. Já o pessoal do front-end usa Windows.

Ou seja, é muito difícil garantir que todos estão com o mesmo ambiente.

Lembram do post (2+2) Desenvolvedores e SOs heterogêneos?

É este problema que o Vagrant procura resolver.

hippie Através de uma API em Ruby e uma ferramenta de linha de comando, ele nos permite virtualizar o ambiente de desenvolvimento e compartilhá-lo com mais pessoas. Assim, podemos garantir que os desenvolvedores estão com um ambiente de desenvolvimento idêntico e mais próximo ao ambiente de produção.

Por baixo dos panos, o Vagrant utiliza o VirtualBox para criar e gerenciar as máquinas virtuais. Ou seja, o Vagrant em si não é um software de virtualização, ele atua apenas como um helper.

Instalação

O Vagrant é compatível com Windows, algumas distribuições Linux (como Ubuntu e Debian) e com o Mac OS X. Basta baixar a versão correspondente ao seu SO. Também é necessário ter o VirtualBox instalado.

Você também tem a opção de instalar através do Rubygems: [sourcecode language=”bash” autolinks=”false”]gem install vagrant[/sourcecode]

Criando seu primeiro box

Um box é uma imagem de sistema operacional, que serve como base para criar o ambiente virtualizado de um projeto.

Antes de criar um ambiente, precisamos adicionar ao menos um box no Vagrant. Como exemplo, vamos adicionar o box do Ubuntu 12.04 (Precise Pangolin):

[sourcecode language=”bash” autolinks=”false”]
vagrant box add precise32 https://files.vagrantup.com/precise32.box[/sourcecode]

Com o box adicionado, agora podemos criar um projeto de exemplo:

[sourcecode language=”bash” autolinks=”false”]
mkdir meu_projeto && cd $_
echo "<h1>Hey u</h1>" > index.html
vagrant init precise32[/sourcecode]

O último comando criará um arquivo Vagrantfile no diretório do seu projeto. Este arquivo é responsável pela configuração da sua máquina virtual.

Isso já é suficiente para iniciar a máquina virtual e acessá-la por SSH:

[sourcecode language=”bash” autolinks=”false”]vagrant up
vagrant ssh[/sourcecode]

Pronto, agora você está logado como usuário vagrant. Navegue até o diretório /vagrant. Esse diretório, por padrão, é compartilhado com o host da sua máquina virtual. Listando os arquivos deste diretório, podemos ver o index.html e o Vagrantfile do nosso projeto de exemplo.

[sourcecode language=”bash” autolinks=”false”]cd /vagrant
ls -a[/sourcecode]

Setup do ambiente

Por enquanto nossa máquina virtual está “crua”, apenas com as ferramentas básicas do sistema operacional. Portanto, precisamos instalar algumas ferramentas úteis. No nosso exemplo, vamos utilizar o Nginx para servir a página index.html que criamos.

Existem algumas formas de se fazer o setup do ambiente:

  • – Via vagrant ssh, ou seja, acessando a máquina virtual, instalando os pacotes e fazendo a configuração manualmente;
  • – Aproveitando os dois provisioners disponíveis no Vagrant, Puppet e Chef.

Vou demonstrar como o setup do ambiente pode ser feito com o Puppet (stand-alone).

Puppet

Antes de mais nada, é necessário adicionar o provisioner :puppet ao seu Vagrantfile:

[sourcecode language=”ruby” autolinks=”false”]
config.vm.provision :puppet do |puppet|
puppet.manifests_path = "puppet"
puppet.manifest_file = "default.pp"
puppet.module_path = "puppet/modules"
end[/sourcecode]

Note que estamos definindo um caminho e um nome de arquivo, que é o manifest usado pelo Puppet para fazer o setup do ambiente. No caso, puppet/default.pp.

Edite o arquivo puppet/default.pp e adicione o seguinte conteúdo:

[sourcecode language=”bash” autolinks=”false”]
class nginx
{
exec { "apt-get update":
command => "/usr/bin/apt-get -y update"
}

package { "nginx" :
ensure => latest,
require => Exec[‘apt-get update’]
}

service { "nginx" :
ensure => running,
subscribe => File["/etc/nginx/nginx.conf"]
}

file { "nginx.conf" :
name => "/etc/nginx/nginx.conf",
ensure => present,
source => "puppet:///modules/nginx/nginx.conf"
}
}

include nginx[/sourcecode]

Basicamente, este manifest vai instalar um pacote do Nginx, substituir o /etc/nginx/nginx.conf por um template e então reiniciar o serviço do Nginx.

Crie o template puppet/modules/nginx/files/nginx.conf com o seguinte conteúdo:

[sourcecode language=”bash” autolinks=”false”]
events {
worker_connections 768;
}

http {
include /etc/nginx/mime.types;
index index.html;

server {
listen 80;
server_name _;
root /vagrant;
}
}[/sourcecode]

Veja que essa é uma configuração mínima para o Nginx servir a nossa página. Nela, estamos definindo um host que ficará disponível na porta 80 e servirá os arquivos do diretório /vagrant.

Port forwarding (redirecionamento de portas)

O Vagrantfile possui uma opção para você configurar redirecionamentos de portas do host para a máquina virtual. Vamos definir que a porta 8080 da nossa máquina deve direcionar para a porta 80 da máquina virtual. Para isso, adicione o seguinte no seu Vagrantfile:

[sourcecode language=”ruby” autolinks=”false”]config.vm.forward_port 80, 8080[/sourcecode]

O primeiro argumento é a porta da máquina virtual, o segundo é a porta do host.

Finalizando

Depois de todos estes passos, podemos finalmente reiniciar a máquina virtual. Abra um outro terminal ou saia daquele em que está usando o ssh e digite:

[sourcecode language=”bash” autolinks=”false”]
vagrant reload[/sourcecode]

Neste momento, o Vagrant fará o setup utilizando o provisioner Puppet. Quando o setup terminar, acesse a url https://localhost:8080 e veja que sua página está sendo servida pelo Nginx.

Após isso, podemos gerar um box com a imagem da máquina:

[sourcecode language=”bash” autolinks=”false”]vagrant package[/sourcecode]

Isso vai criar um arquivo package.box dentro do diretório do seu projeto. Ele contém a imagem do seu ambiente (quase 400 MB) e pode ser compartilhado com outras pessoas.

Mais sobre o Vagrant

O exemplo que demonstrei é bem simples, servindo apenas para demonstrar o caminho básico para criar uma máquina virtual com o Vagrant. Sugiro que você leia a documentação e dê uma olhada no funcionamento dos provisioners e na integração com o Rake.

Também vale ler alguns posts, falando sobre o Vagrant: