Como Automatizar Implantações de Aplicativos Ruby On Rails Usando o Capistrano

Tutoriais
CentOS Ruby

Introdução

Se você ainda não está cansado de repetir as mesmas tarefas mundanas para atualizar seus servidores de aplicativos e colocar seu projeto online, provavelmente ficará eventualmente. A alegria que você sente ao desenvolver seu projeto tende a diminuir quando se trata das partes chatas da administração do sistema (por exemplo, fazer upload da sua base de código, alterar configurações, executar comandos repetidamente, etc.)

Mas não tema! Capistrano, a ferramenta de automação de tarefas, está aqui para ajudar.

Neste artigo da DigitalOcean, vamos criar uma configuração de servidor sólida como uma rocha, executando a versão mais recente do CentOS para hospedar aplicativos Ruby-on-Rails usando Nginx e Passenger. Continuaremos aprendendo como automatizar o processo de implantação – e atualizações – usando a ferramenta de automação baseada em Ruby, Capistrano.

Nota: Este artigo baseia-se no conhecimento do nosso artigo anterior sobre Capistrano: Automatização de Implantações com Capistrano: Primeiros Passos. Para obter um bom conhecimento da ferramenta, o que é altamente recomendado se você pretende usá-la, é aconselhável ler antes de continuar com este texto. Da mesma forma, se você gostaria de aprender mais sobre como preparar uma gota fresca para implantações de aplicativos baseados em Rails com Passenger (e Nginx), confira o artigo Como Implantar Aplicativos Rails Usando Passenger Com Nginx.

Nota: O Capistrano depende do Git para implantações. Para saber mais, considere ler os artigos da comunidade da DigitalOcean sobre o assunto clicando aqui.

Glossário

1. Preparando o Servidor de Implantação

  1. Atualizando e Preparando o Sistema Operacional
  2. Configurando o Ambiente Ruby e Rails
  3. Baixando e Instalando Servidores de Aplicativos e HTTP.
  4. Criando o Script de Gerenciamento do Nginx
  5. Configurando o Nginx para Implantação de Aplicativos
  6. Baixando e Instalando o Capistrano
  7. Criando um Usuário do Sistema para Implantação

2. Preparando Aplicações Rails para Implantação baseada em Git com o Capistrano

  1. Criando uma Aplicação Básica Ruby-On-Rails
  2. Criando um Repositório Git

3. Trabalhando com o Capistrano para Automatizar Implantações

  1. Instalando o Capistrano dentro do Diretório do Projeto
  2. Trabalhando com config/deploy.rb dentro do Diretório do Projeto
  3. Trabalhando com config/deploy/production.rb dentro do Diretório do Projeto
  4. Implantando no Servidor de Produção

Preparando o Servidor de Implantação

Nota: Para ter uma melhor compreensão da seção abaixo, que pode ser considerada um resumo detalhado, confira o artigo completo sobre o assunto: Como implantar aplicativos Rails usando o Passenger com Nginx.

Atualizando e preparando o sistema operacional

Execute o seguinte comando para atualizar as ferramentas padrão do seu droplet baseado em CentOS:

yum -y update

Instale o conjunto contendo as ferramentas de desenvolvimento executando o seguinte comando:

yum groupinstall -y 'development tools'

Alguns dos pacotes que precisamos para este tutorial (por exemplo, libyaml-devel, nginx etc.) não são encontrados no repositório oficial do CentOS.

Execute o seguinte para adicionar o repositório EPEL:

sudo su -c 'rpm -Uvh http://dl.fedoraproject.org/pub/epel/6/x86_64/epel-release-6-8.noarch.rpm'

yum -y update

Finalmente, para instalar algumas bibliotecas e ferramentas adicionais, execute o seguinte comando:

yum install -y curl-devel nano sqlite-devel libyaml-devel

Configurando o ambiente Ruby e Rails

Nota: Esta seção é um resumo do nosso artigo dedicado Como instalar o Ruby 2.1.0 no CentOS 6.5.

Execute os seguintes dois comandos para instalar o RVM e criar um ambiente de sistema para o Ruby:

curl -L get.rvm.io | bash -s stable

source /etc/profile.d/rvm.sh
rvm reload
rvm install 2.1.0

Já que o Rails precisa de um interpretador JavaScript, também precisaremos configurar o Node.js.

Execute o seguinte para baixar e instalar o nodejs usando yum:

yum install -y nodejs

Execute o seguinte comando usando o gem do Ruby para baixar e instalar o rails:

gem install bundler rails

Baixando e instalando Servidores de Aplicativos e HTTP

Nota: Se seu VPS tiver menos de 1 GB de RAM, será necessário realizar o procedimento abaixo para preparar um espaço de SWAP de disco de 1024 MB para ser usado como um recipiente temporário de dados (substituto de RAM). Como os servidores DigitalOcean vêm com discos SSD rápidos, isso realmente não constitui um problema ao realizar as tarefas de instalação de aplicativos do servidor.

# Criar um espaço de SWAP de 1024 MB
sudo dd if=/dev/zero of=/swap bs=1M count=1024
sudo mkswap /swap
sudo swapon /swap

Phusion Passenger

O gerenciador de pacotes padrão do Red Hat Linux, RPM (RPM Package Manager), fornece aplicativos contidos em arquivos .rpm. Infelizmente, no caso do Passenger, eles estão bastante desatualizados. Portanto, estaremos utilizando o RubyGem, mais uma vez, para baixar e instalar a versão mais recente disponível do Passenger – versão 4.

Utilize o seguinte comando para simplesmente baixar e instalar o Passenger:

gem install passenger

Nginx

Nota: Normalmente, para baixar e instalar o Nginx, você poderia adicionar o repositório EPEL (como já fizemos) e obter o Nginx via yum. No entanto, para fazer o Nginx funcionar com o Passenger, seu código fonte deve ser compilado com os módulos necessários.

Execute o seguinte para começar a compilar o Nginx com o módulo nativo do Passenger:

passenger-install-nginx-module

Ao executar o comando, pressione Enter e confirme sua escolha de linguagem(s) (ou seja, Ruby, no nosso caso). Você pode usar as teclas de seta e a barra de espaço para selecionar somente Ruby, se desejar.

Use <space> to select.
If the menu doesn't display correctly, ensure that your terminal supports UTF-8.

 ‣ ⬢  Ruby
   ⬢  Python
   ⬢  Node.js
   ⬡  Meteor

No próximo passo, escolha Item 1:

1. Yes: download, compile and install Nginx for me. (recommended)
    The easiest way to get started. A stock Nginx 1.4.4 with Passenger
    support, but with no other additional third party modules, will be
    installed for you to a directory of your choice.

E pressione Enter para continuar.

Agora, o código fonte do Nginx será baixado, compilado e instalado com suporte ao Passenger.

Nota: Esta ação pode demorar um pouco – provavelmente mais do que se gostaria ou espera!

Criando o Script de Gerenciamento do Nginx

Após compilar o Nginx, para controlá-lo com facilidade, precisamos criar um script de gerenciamento simples.

Execute os seguintes comandos para criar o script:

nano /etc/rc.d/init.d/nginx

Copie e cole o conteúdo abaixo:

#!/bin/sh
. /etc/rc.d/init.d/functions
. /etc/sysconfig/network
[ "$NETWORKING" = "no" ] && exit 0

nginx="/opt/nginx/sbin/nginx"
prog=$(basename $nginx)

NGINX_CONF_FILE="/opt/nginx/conf/nginx.conf"

lockfile=/var/lock/subsys/nginx

start() {
    [ -x $nginx ] || exit 5
    [ -f $NGINX_CONF_FILE ] || exit 6
    echo -n $"Starting $prog: "
    daemon $nginx -c $NGINX_CONF_FILE
    retval=$?
    echo
    [ $retval -eq 0 ] && touch $lockfile
    return $retval
}

stop() {
    echo -n $"Stopping $prog: "
    killproc $prog -QUIT
    retval=$?
    echo
    [ $retval -eq 0 ] && rm -f $lockfile
    return $retval
}

restart() {
    configtest || return $?
    stop
    start
}

reload() {
    configtest || return $?
    echo -n $”Reloading $prog: ”
    killproc $nginx -HUP
    RETVAL=$?
    echo
}

force_reload() {
    restart
}

configtest() {
    $nginx -t -c $NGINX_CONF_FILE
}

rh_status() {
    status $prog
}

rh_status_q() {
    rh_status >/dev/null 2>&1
}

case "$1" in
start)
rh_status_q && exit 0
$1
;;
stop)
rh_status_q || exit 0
$1
;;
restart|configtest)
$1
;;
reload)
rh_status_q || exit 7
$1
;;
force-reload)
force_reload
;;
status)
rh_status
;;
condrestart|try-restart)
rh_status_q || exit 0
;;
*)
echo $"Usage: $0 {start|stop|status|restart|condrestart|try-restart|reload|force-reload|configtest}"
exit 2
esac

Pressione CTRL+X e confirme com Y para salvar e sair.

Defina o modo deste script de gerenciamento como executável:

chmod +x /etc/rc.d/init.d/nginx

Configurando o Nginx para Implantação de Aplicativos

Neste último passo da configuração de nossos servidores, precisamos criar um bloco de servidor Nginx, que se traduz aproximadamente nos hosts virtuais do Apache.

Como você pode se lembrar de ter visto durante a instalação do Passenger no Nginx, este procedimento consiste em adicionar um bloco de código ao arquivo de configuração do Nginx nginx.conf. Por padrão, a menos que você indique o contrário, este arquivo pode ser encontrado em /opt/nginx/conf/nginx.conf.

Digite o seguinte comando para abrir este arquivo de configuração para editá-lo com o editor de texto nano:

nano /opt/nginx/conf/nginx.conf

Como primeiro passo, encontre o nó http { e adicione o seguinte imediatamente após as diretivas passenger_root e passenger_ruby:

# Apenas para fins de desenvolvimento.
# Remova esta linha quando carregar um aplicativo real.
# Apenas para * TESTES *.
passenger_app_env development;

Role para baixo no arquivo e encontre server { ... Comente a localização padrão, ou seja:

..

#    location / {
#            root   html;
#            index  index.html index.htm;
#        }

..

E defina a raiz do seu aplicativo padrão:

# Defina a pasta onde você irá implantar sua aplicação.
# Estamos usando: /home/deployer/apps/my_app
root              /home/deployer/apps/my_app/public;
passenger_enabled on;

Pressione CTRL+X e confirme com Y para salvar e sair.

Execute o seguinte para recarregar o Nginx com a nova configuração da aplicação:

# !! Lembre-se de criar um script de gerenciamento do Nginx
#    seguindo o artigo principal de implantação do Rails para CentOS
#    vinculado no início desta seção.

/etc/init.d/nginx restart

Para verificar o status do Nginx, você pode usar:

/etc/init.d/nginx status

Observação: Para saber mais sobre o Nginx, consulte Como Configurar o Servidor Web Nginx em um VPS.

Baixando e Instalando o Capistrano

Uma vez que temos nosso sistema pronto, obter a versão mais recente do Capistrano, graças ao RubyGems, é fácil.

Você pode simplesmente usar o seguinte para obter a versão 3 do Capistrano:

gem install capistrano

Criando um Usuário de Sistema para Implantação

Neste passo, vamos criar um usuário do sistema CentOS para executar as ações de implantação. Este será o usuário que o Capistrano utilizará.

Observação: Para manter as coisas básicas, vamos criar um usuário deployer com privilégios necessários. Para uma configuração mais completa, considere usar o exemplo de grupos do tutorial de introdução ao Capistrano.

Crie um novo usuário do sistema deployer:

adduser deployer

Configure a senha do deployer:

passwd deployer

# Insira uma senha
# Confirme a senha

Edite o arquivo /etc/sudoers usando o editor de texto nano:

nano /etc/sudoers

Role o arquivo para baixo e encontre onde root está definido:

..

## A seção COMMANDS pode ter outras opções adicionadas a ela.
##
## Permitir que o root execute qualquer comando em qualquer lugar
root    ALL=(ALL)	ALL

..

Acrescente o seguinte logo após root ALL=(ALL) ALL:

deployer ALL=(ALL) ALL

Esta seção do arquivo /etc/sudoers deve ficar assim agora:

..

## A seção COMMANDS pode ter outras opções adicionadas a ela.
##
## Permitir que o root execute qualquer comando em qualquer lugar
root     ALL=(ALL)	ALL
deployer ALL=(ALL) ALL

..

Pressione CTRL+X e confirme com Y para salvar e sair.

Preparando Aplicações Rails para Implantação com Capistrano Baseado em Git

Uma vez que tenhamos nosso sistema pronto, com todas as aplicações necessárias configuradas e funcionando corretamente, podemos prosseguir com a criação de uma aplicação Rails exemplar para usar como amostra.

Na segunda etapa, vamos criar um repositório Git e enviar a base de código para um local central e acessível no Github para o Capistrano usar em implantações.

Nota: Aqui, estamos criando uma aplicação de exemplo. Para as implantações reais, você deve realizar estas ações por conta própria, após garantir que tudo esteja devidamente salvo – só por precaução! Além disso, observe que você precisará executar o Capistrano de um local diferente do servidor onde a aplicação precisa ser implantada.

Criando uma Aplicação Básica Ruby-On-Rails

Nota: O passo abaixo é para criar uma aplicação Rails substituta para experimentar o Capistrano.

Tendo o Ruby e o Rails já instalados, nos resta apenas um único comando para começar.

Execute o seguinte comando para fazer o Rails criar uma nova aplicação chamada my_app:

# Crie uma aplicação Rails de exemplo
rails new my_app

# Entre no diretório da aplicação
cd my_app

# Crie um recurso de exemplo
rails generate scaffold Task title:string note:text

# Crie um banco de dados de exemplo
RAILS_ENV=development rake db:migrate

Para testar se a sua aplicação está configurada corretamente e tudo está funcionando bem, entre no diretório do aplicativo e execute um servidor simples via rails s:

# Entre no diretório do aplicativo
cd my_app

# Execute um servidor simples
rails s

# Agora você deverá conseguir acessá-lo visitando: http://[o IP do seu droplet]:3000
# Para encerrar o processo do servidor,

# Pressione CTRL+C
# Criando um Repositório Git

Observação: Para aprender mais sobre como trabalhar com o Git, confira o tutorial Como Usar o Git Efetivamente nas páginas da comunidade da DigitalOcean.

Observação: Para seguir esta seção, você precisará de uma conta no Github. Alternativamente, você pode configurar um droplet para hospedar seu próprio repositório Git seguindo este artigo da DigitalOcean sobre o assunto. Se optar por fazê-lo, certifique-se de usar a URL relevante nos arquivos de implantação.

Vamos usar as instruções de exemplo fornecidas pelo Github para criar um repositório de origem.

Execute os seguintes comandos autoexplicativos dentro do diretório my_app para iniciar um repositório:

# !! Esses comandos devem ser executados em
#    sua máquina de desenvolvimento, de onde você irá
#    implantar em seu servidor.
#    As instruções podem variar ligeiramente dependendo de
#    sua escolha de sistema operacional.
#
#    Certifique-se de definir os caminhos corretos para a aplicação
#    caso contrário, o Nginx pode não ser capaz de localizá-la.

# Inicie o repositório
git init

# Adicione todos os arquivos ao repositório
git add .

# Faça o commit das mudanças
git commit -m "first commit"

# Adicione o link do seu repositório Github 
# Exemplo: git remote add origin [email protected]:[nome de usuário]/[nome do projeto].git
git remote add origin [email protected]:user123/my_app.git

# Crie uma chave RSA/SSH
# Siga as instruções na tela
ssh-keygen -t rsa

# Visualize o conteúdo da chave e adicione-a ao seu Github
# copiando e colando da sessão remota atual
# visitando: https://github.com/settings/ssh
# Para aprender mais sobre o processo,
# visite: https://help.github.com/articles/generating-ssh-keys
cat /root/.ssh/id_rsa.pub

# Configure suas informações do Github
# Username:
# Uso: git config --global user.name "[seu nome de usuário]"
git config --global user.name "user123"

# Email:
# Uso: git config --global user.email "[seu email]"
git config --global user.email "[email protected]"

# Envie o código fonte do projeto para sua conta do Github
git push -u origin master

Trabalhando com Capistrano para Automatizar Implantações

Como você se lembrará do nosso primeiro artigo sobre o Capistrano, o modo de começar a usar a biblioteca é instalando-a dentro do diretório do projeto. Nesta seção, veremos como fazer isso, seguido pela criação de arquivos necessários para configurar os servidores.

Instalando o Capistrano Dentro do Diretório do Projeto

Outro passo simples em nosso artigo é instalar os arquivos do Capistrano. O comando abaixo criará alguns diretórios e arquivos a serem usados pela ferramenta para a implantação.

Execute o seguinte para iniciar (ou seja, instalar) os arquivos do Capistrano:

cap install

# mkdir -p config/deploy
# criar config/deploy.rb
# criar config/deploy/staging.rb
# criar config/deploy/production.rb
# mkdir -p lib/capistrano/tasks
# Capified

Trabalhando com config/deploy.rb dentro do diretório do projeto

O arquivo deploy.rb contém argumentos e configurações relevantes para o(s) servidor(es) de implantação. Aqui, diremos ao Capistrano para qual(is) servidor(es) gostaríamos de nos conectar e implantar e como fazer isso.

Nota: Ao editar o arquivo (ou definir as configurações), você pode comentá-las ou adicionar novas linhas. Certifique-se de não ter algumas configurações de exemplo substituindo aquelas que você está adicionando.

Execute o seguinte para editar o arquivo usando o editor de texto nano:

nano config/deploy.rb

Adicione o seguinte bloco de código, modificando-o conforme suas próprias configurações:

# Defina o nome da aplicação
set :application, 'my_app'

# Defina onde o Capistrano pode acessar o repositório de origem
# set :repo_url, 'https://github.com/[nome de usuário]/[nome da aplicação].git'
set :scm, :git
set :repo_url, 'https://github.com/user123/my_app.git'

# Defina onde colocar o código da sua aplicação
set :deploy_to, "/home/deployer/apps/my_app"

set :pty, true

set :format, :pretty

# Defina as instruções pós-deploy aqui.
# Uma vez que o deploy estiver completo, o Capistrano
# começará a executá-las conforme descrito.
# Para aprender mais sobre a criação de tarefas,
# confira:
# http://capistranorb.com/

# namespace: deploy do

#   desc 'Reinicie a aplicação'
#   task :restart do
#     on roles(:app), in: :sequence, wait: 5 do
#       # Seu mecanismo de reinício aqui, por exemplo:
#       execute :touch, release_path.join('tmp/restart.txt')
#     end
#   end

#   after :publishing, :restart

#   after :restart, :clear_cache do
#     on roles(:web), in: :groups, limit: 3, wait: 10 do
#       # Aqui podemos fazer qualquer coisa como:
#       # dentro do release_path faça
#       #   execute :rake, 'cache:clear'
#       # end
#     end
#   end

# end

Pressione CTRL+X e confirme com Y para salvar e sair.

Trabalhando com config/deploy/production.rb Dentro do Diretório do Projeto

Nota: Semelhante ao deploy.rb, você precisará fazer algumas alterações no arquivo production.rb. É melhor modificar o código em vez de anexar o bloco abaixo.

Execute o seguinte para editar o arquivo usando o editor de texto nano:

nano config/deploy/production.rb

Insira as configurações do seu servidor, semelhantes às abaixo:

# Definir funções, usuário e endereço IP do servidor de implantação
# role :nome, %{[usuário]@[endereço IP]}
role :app, %w{[email protected]}
role :web, %w{[email protected]}
role :db,  %w{[email protected]}

# Definir servidor(es)
server '162.243.74.190', user: 'deployer', roles: %w{web}

# Opções SSH
# Veja a seção de exemplo comentada no arquivo
# para mais opções.
set :ssh_options, {
    forward_agent: false,
    auth_methods: %w(password),
    password: 'user_deployers_password',
    user: 'deployer',
}

Pressione CTRL+X e confirme com Y para salvar e sair.

Implantando no Servidor de Produção

Depois de concluirmos as configurações, é hora de implantar.

Execute o seguinte código em sua máquina de desenvolvimento para implantar no servidor de produção. Como definido nos arquivos acima, o Capistrano irá:

  • Conectar-se ao servidor de implantação

  • Baixe a fonte do aplicativo

  • Realize as ações de implantação (ou seja, reinicie a aplicação do passageiro)

cap production deploy

Para saber mais sobre o Capistrano e o que ele pode fazer, considere ler a documentação do Capistrano.

<div class=“autor”>Enviado por: <a
href=“https://twitter.com/ostezer”>O.S. Tezer</a></div>

Source:
https://www.digitalocean.com/community/tutorials/how-to-automate-ruby-on-rails-application-deployments-using-capistrano