Vagrant – As vantagens da virtualização em ambiente local

Olá pessoal.

Quando conheci a ferramenta, achei realmente engraçado seu nome, uma ferramenta de Vagabundo. Seu nome vem da facilidade em que se cria ambientes diversos de forma rápida e prática.

Para facilitar, todos os exemplos foram colocados nesse repositório, cada branch, representa seu tipo de provisionamento.

A proposta é poder criar e configurar ambientes de desenvolvimento leves, reprodutíveis e portáteis.

Mudando sua forma de trabalhar

O download do Vagrant pode ser feito em seu site https://www.vagrantup.com/ e possui versões para Mac, Windows e Linux. Afinal não importa o seu sistema operacional, o que importa é que seu ambiente, é o mais próximo possível do ambiente de produção/homologação.

Configurar

A configuração é a mais simples possível, com apenas um arquivo “Vagrantfile“, você descreve o tipo de máquina, a URL da imagem, e os softwares que serão instalados em seu ambiente, e as maneiras que deseja ter acesso a essa máquina criando redes internas e externas. Além das configurações de IP, hostname, e tudo que envolve um ambiente de aplicações web.

Ambientes iguais.

Essa ferramenta acaba com as desculpas de: “Funciona na minha máquina”, pois o ambiente pode ser atualizado com frequência, e distribuído para toda a equipe.

Nosso primeiro ambiente com Puppet

Vamos iniciar a criação de ambientes, usando duas ferramentas: Puppet e Chef. Ambas ferramentas oferecem receitas prontas de configurações iniciais para o start do seu projeto, e tanto o PuPHPet como o Chef, possuem ótimas integrações com o Vagrant, tornando todo o trabalho de escolher uma imagem, e configurar a partir dela, para depois distribuir, seja poupado.

Então em alguns minutos, eu prometo para você que teremos uma máquina virtual utilizando

  • CentOs
  • NGINX
  • PHP-FPM
  • MySQL
  • MongoDB
  • xDebug
  • MailCatcher

Faça o Download do PuPHPet já gerado por mim ou gere o seu no site PuPHPet.

Coloque na pasta do seu projeto, no meu caso “~/projects/app”, (altere dentro do seu Vagrantfile caso o caminho do seu projeto seja diferente) e execute no terminal:

vagrant up

Após isso, aguarde a primeira execução do seu vagrant, enquanto ele faz o download da imagem, configura pela primeira vez seu ambiente com as configurações especificadas no arquivo “puphpet/config.yaml”.

Alguns itens importantes do seu ambiente

Abrindo o arquivo “puphpet/config.yaml” você irá encontrar algumas informações importantes sobre seu ambiente:

Memoria (1GB)

memory: '1024'

CPU’s

cpus: '1'

Rede Privada

private_network: 192.168.10.10

MySQL

mysql:
    install: '1'
    root_password: app_pwd
    adminer: '1'
    databases:
        ptUkwSJZgC0x:
            grant:
                - ALL
            name: app_dev
            host: localhost
            user: app_dev
            password: app_dev
            sql_file: ''

MongoDB

mongodb:
    install: '1'
    settings:
        auth: 1
        port: '27017'
    databases:
        iSWYd6Tv28w5:
            name: app_dev
            user: app_dev
            password: app_dev

Provisionamento Puppet

provision:
            puppet:
                manifests_path: puphpet/puppet
                manifest_file: site.pp
                module_path: puphpet/puppet/modules
                options:
                    - '--verbose'
                    - '--hiera_config /vagrant/puphpet/puppet/hiera.yaml'
                    - '--parser future'

Agora basta versionar a pasta puphpet e o arquivo VagrantFile e distribua junto ao projeto para todos. Os requisitos mínimos para a sua equipe iniciar será VirtualBox e Vagrant instalados localmente (Mac, Windows ou Linux).

Observação

Eu prefiro a utilização o Chef, que veremos mais abaixo, na minha opinião é consideravelmente mais organizado e rápido, além de integrações maiores com ChefServer & AWS(OpsWorks).

Acessando o ambiente

Para acessar seu ambiente, execute:

vagrant up
vagrant ssh

Após a primeira inicialização, será automaticamente gerada uma chave privada no diretório puphpet/files/dot/ssh/id_rsa.key.

Esta chave é gerada após seu primeiro start do ambiente.

Custom files

O PuPHPet permite que você, altere alguns arquivos do seu ambiente, e as variaveis do próprio sistema operacional, por parte dos Dotfiles.

Você pode colocar arquivos personalizados para seu ambiente, como por exemplo (.bash_aliases, .vimrc, .gitconfig, etc), na pasta puphpet/files/dot/.

Durante o lançamento do ambiente vagrant up, os mesmos serão automaticamente copiados para o seu ambiente. Pode começar brincando com o .bash_aliases 🙂

Eu sempre deixo alguns atalhos para facilitar o gerenciamento do ambiente:

#All Services
alias restart_all="sudo /etc/init.d/nginx restart & sudo /etc/init.d/php-fpm restart & sudo /etc/init.d/mysql restart & sudo /etc/init.d/mongo restart"

#Singles Services
alias nginx_restart="sudo /etc/init.d/nginx restart;"
alias php-fpm_restart="sudo /etc/init.d/php-fpm restart;"
alias mysql_restart="sudo /etc/init.d/mysql restart;"
alias mongo_restart="sudo /etc/init.d/mongo restart;"

#Logs
##APP
alias app_access_log="sudo tail -f /var/log/nginx/app.dev.access.log"
alias app_error_log="sudo tail -f /var/log/nginx/app.dev.error.log"

##PHP-FPM
alias php-fpm_error="sudo tail -f /var/log/php-fpm/error.log"


##NGINX
alias nginx_log="sudo tail -f /var/log/nginx/error.log"
alias nginx_access="sudo tail -f /var/log/nginx/access.log"

##MYSQL
alias mysql_log="sudo tail -f /var/log/mysql.log"

##MONGO
alias mongo_log="sudo tail -f /var/log/mongodb/mongod.log"

##CRONTAB LOG
alias crontab_log="sudo tail -f /var/log/cron"

Scripts Personalizados

Você também pode executar o seu próprio código de personalização do ambiente, adicionando os mesmos na pasta /puphpet/exec-always (executa toda vez), e /puphpet/exec-once (apenas uma vez. Assim como as pastas de inicialização sempre e de apenas uma vez.

Vale lembrar que os arquivos são executados em ordem alfabética, tome cuidado.

Após saber isso tudo, edite o arquivo de hosts do seu computador, e adicione:

192.168.10.10 app.dev

Após salvar, abra o endereço: http://app.dev e veja o seu ambiente prontinho 🙂

Dica: Observe sempre se ao subir o seu ambiente, todos os serviços estão rodando OK, basta acessar sua maquina usando vagrant ssh, e depois: /etc/init.d/servico status e verificar se o serviço está rodando ou não.

Shell, o bom e velho

O Vagrant permite a execução do provisionamento atráves de shell script, o que é também bastante simples. Nesse modelo de configuração do Vagrant, iremos dessa vez configurar uma imagem simples Ubuntu 12.04 LTS 32-bit.

Iniciado nosso ambiente

cd ~/projects/vagrant_shell/;

vagrant init hashicorp/precise32
vagrant up

Após essa execução, o vagrant irá fazer o download da imagem na url https://vagrantcloud.com/hashicorp/precise32/version/1/provider/virtualbox.box e importar ao seu VirtualBox.

Vagrantfile

Após isso, iremos editar o arquivo Vagrantfile e adicionar o nosso provisionamento via Shell, acrescente esse trecho após o |config|

config.vm.provision "shell", path: "tools/provision.sh"

Se o seu caso for windows, pode trocar o provision.sh por algum arquivo .bat ou .ps1.
Ou caso queira manter esse provisionamento em algum servidor, e distribuir apenas a URL, basta trocar o caminho: “tools/provision.sh” pelo endereço do provisionamento “http://url.com.br/provision.sh”

Agora, vamos criar o diretório tools e o arquivo provision.sh

mkdir tools/
cd tools;
touch provision.sh

Provisionamento

Agora vamos acrescentar o conteúdo do arquivo provision.sh:

#UPDATE UBUNTU
sudo apt-get update;
apt-get -f install

#Install Packages
##nginx
sudo apt-get install nginx --yes

##PHP5-FPM
sudo apt-get install php5-fpm php5-cli php5-common php5-curl php5-xdebug php5-gd php5-imagick php5-mcrypt --yes

##MySQL
echo "mysql-server-5.5 mysql-server/root_password password root" | debconf-set-selections
echo "mysql-server-5.5 mysql-server/root_password_again password root" | debconf-set-selections
sudo apt-get -y install mysql-server-5.5

#INSTALL MONGODB
sudo apt-key adv --keyserver hkp://keyserver.ubuntu.com:80 --recv 7F0CEB10 --yes
touch /etc/apt/sources.list.d/mongodb.list
echo 'deb http://downloads-distro.mongodb.org/repo/ubuntu-upstart dist 10gen' | sudo tee /etc/apt/sources.list.d/mongodb.list
sudo apt-get update --yes
sudo apt-get install mongodb-org --yes
sudo service mongod start

Para executar essa instalação padrão dos pacotes nginx, mysql-server, php5-fpm e mongodb execute no seu prompt:

vagrant provision

Após a execução do provisionamento, entre no seu ambiente e verifique se os serviços já estão todos rodando 🙂

Agora abra o arquivo Vagrantfile novamente, e vamos acrescentar as portas necessárias para comunicação dos serviços instalados.

  #NGINX
  config.vm.network "forwarded_port", guest: 80, host: 80

  #MYSQL
  config.vm.network "forwarded_port", guest: 3306, host: 3306

  #MONGODB
  config.vm.network "forwarded_port", guest: 27017, host: 27017

  #PRIVATE NETWORK
  config.vm.network "private_network", ip: "192.168.33.100"

  #SHAREFOLDER DEFAULT NGINX VHOST
  config.vm.synced_folder "./", "/var/www/"

Agora, basta solicitar ao vagrant para reiniciar o seu ambiente:

vagrant reload

Agora se tudo deu certo, acesse no seu browser: http://192.168.33.100 e pronto, veja seu ambiente nginx pronto para receber sua aplicação web. Veja só:

Chef

O Vagrant possui integrações com o Vagrant Chef Solo e Chef Client, porem, nesse exemplo, um dica é gerar um arquivo inicial pelo http://rove.io que é um projeto que gera o start inicial baseado nas suas escolhas, bem prático 😀

Gere o seu pack inicial, e vamos a configuração rápida do arquivo Cheffile

Cheffile

# encoding: utf-8

site 'http://community.opscode.com/api/v1'

cookbook "apt"
cookbook "php", {}
cookbook "mysql", {}
cookbook "nginx", {}
cookbook "mongodb", {}
cookbook "git", {}

A entrada site ‘http://community.opscode.com/api/v1’ define que usaremos as receitas fornecidas pela API do http://www.getchef.com/. e logo depois nossos livrinhos de receitas que usaremos, que é o apt, o php, o mysql, nginx mongodb e git.

Vagrantfile

Agora vamos configurar o nosso Vagrantfile:

# encoding: utf-8
# This file originally created at http://rove.io/06d3af5cb4c2ff1ad165f7efa50f20df
# ALTERADO POR JO O VAGNER
# Permalink: http://blog.rivendel.com.br/2014/08/20/vagrant-as-vantagens-da-virtualizacao-em-ambiente-local
# -*- mode: ruby -*-
# vi: set ft=ruby :

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

  config.vm.box = "opscode-ubuntu-12.04_chef-11.4.0"
  config.vm.box_url = "https://opscode-vm-bento.s3.amazonaws.com/vagrant/opscode_ubuntu-12.04_chef-11.4.0.box"
  config.ssh.forward_agent = true

  #NGINX
  config.vm.network "forwarded_port", guest: 80, host: 8080

  #MYSQL
  config.vm.network "forwarded_port", guest: 3306, host: 3308

  #MONGODB
  config.vm.network "forwarded_port", guest: 27017, host: 27017

  #PRIVATE NETWORK
  config.vm.network "private_network", ip: "192.168.33.101"

  #SHAREFOLDER DEFAULT NGINX VHOST
  config.vm.synced_folder "./", "/var/www/"

  config.vm.provision :chef_solo do |chef|
    chef.cookbooks_path = ["cookbooks"]
    chef.add_recipe :apt
    chef.add_recipe 'php'
    chef.add_recipe 'mysql::server'
    chef.add_recipe 'nginx'
    chef.add_recipe 'mongodb::default'
    chef.add_recipe 'git'
    chef.json = {
      :mysql   => {
        :server_root_password   => "app_cheff",
        :server_repl_password   => "app_cheff",
        :server_debian_password => "",
        :service_name           => "mysql",
        :basedir                => "/usr",
        :data_dir               => "/var/lib/mysql",
        :root_group             => "root",
        :mysqladmin_bin         => "/usr/bin/mysqladmin",
        :mysql_bin              => "/usr/bin/mysql",
        :conf_dir               => "/etc/mysql",
        :confd_dir              => "/etc/mysql/conf.d",
        :socket                 => "/var/run/mysqld/mysqld.sock",
        :pid_file               => "/var/run/mysqld/mysqld.pid",
        :grants_path            => "/etc/mysql/grants.sql"
      },
      :nginx   => {
        :dir                => "/etc/nginx",
        :log_dir            => "/var/log/nginx",
        :binary             => "/usr/sbin/nginx",
        :user               => "www-data",
        :init_style         => "runit",
        :pid                => "/var/run/nginx.pid",
        :worker_connections => "1024"
      },
      :mongodb => {
        :dbpath  => "/var/lib/mongodb",
        :logpath => "/var/log/mongodb",
        :port    => "27017"
      },
      :git     => {
        :prefix => "/usr/local"
      }
    }
  end
end

É necessário instalar librarian-chef (Ruby), instalado.

sudo apt-get install ruby
sudo apt-get install ruby-dev
sudo apt-get install rubygems
sudo gem install librarian-chef

Depois execute a instalação dos cookbooks e inicie seu ambiente

librarian-chef install

Após a conclusão do librarian-chef , basta iniciar o seu vagrant pela primeira vez, e aguardar o download da imagem do Ubuntu 12-04 fornecido no Vagrantfile:

vagrant up

Após isso, basta acessar seu ambiente no browser http://192.168.33.101

Gostou do conteúdo? Tem alguma dúvida? Entre em contato com nossos Especialistas Mandic Cloud, ficamos felizes em ajudá-lo.



Serviços e Plataformas Cloud