Elf Blog

Este post irá descrever de forma mais completa o que a gem gploy faz, acredito que não será um post grande pois a gem não faz tanta coisa assim. Gploy é uma RubyGem que pode ser usada para configurar seu projeto Ruby on Rails e seu servidor para realizar deploy usando git. De forma alguma quero tentar substituir ou algo assim gems muito melhores e eficientes como o Imploy ou o locarails, até mesmo pois essas fazem o trabalho de outra forma.

Resumo

Gploy é uma Gem Ruby simples para configurar e fazer deploy de apps Rails, essa gem foi escrita por min(Edipo), o codigo não esta elegente como deveria, mas estou trabalhando nisso .

O que preciso ter.

Se faz necessário o uso de git para controle de versão de seu projeto Rails, o que acredito que seja praticamente impossível alguem do Rails não esta usando git para versionamento, você também precisa um servidor web(sério?) que rode Ruby on Rails, até agora somente testei na locaweb, pois essa gem faz o uso de uma estrutura de pasta em particular que é encontrada nos servidores da locaweb(mas imagino que outros servidores não são diferentes disso), outra coisa muito importante é que, novamente, até o momento, essa gem faz o uso de um repositório git no mesmo servidor que irá esta hospedada a aplicação, então seu servidor também precisa ter suporte a git. Dito isso, a estrutura de pasta que o gploy usa é a seguinte:

~/repos -> Repositorio git
~/rails_app -> Onde fica seu projeto de produção
~/public_html -> Aqui irá ser criado um link simbólico com a aplicação.

Logo a pasta repos poderá ser substituída por qualquer uma de sua preferencia atras de uma configuração adicional.

Que arquivos são usados

Os comandos gploy -c e gploy -pr geram dois arquivos, config/config.yaml e config/post-receive respectivamente. O primeiro é um arquivo yaml que guarda as informação do seu servidor, nome da app e origin(git).

Acho que não tem muito o que falar sobre esse arquivo ele é auto-explicativo, apenas tome cuidado com a ultima linha(origin) caso você já tenha no seu git um origin configurado use outro nome. Caso você tenha um key ssh configurada para seu servidor na sua maquina e não necessite senha simplesmente deixa essa opção em branco.

O segundo arquivo é o post-receive que é um hook do git, basicamente falando é um arquivo que é executado sempre que o repositório em questão sofre algum tipo de ação, no nosso caso é quando ele recebe um push, esse arquivo se parece com isso:

Esse conteúdo é o que é gerado pelo gploy, também acho que é auto-explicativo o que ele faz, caso você tenha mais tarefas para serem executadas quando você der um novo deploy simplesmente coloque ela nesse arquivo usando o env -i na frente como os demais.

Como a gem Trabalha.

A forma como a gem trabalha é bem simples, o que ela faz é usar um pouco do poder do git ao seu favor, basicamente é:

→ Se projeto não estiver versionado então inicio um repositório git localmente e faça o primeiro commit.
→ Adiciona a url remota configurada no config.yml ao git
→ Faz um git push
→ Faz um clone dentro do servidor da pasta repos para rails_app
→ Adiciona a url “remota” dentro do servidor
→ Cria o link simbólico entre public_html e rails_app
→ Cria diretório tmp na aplicação caso não existir
→ Faz upload do arquivo de hook configurado anteriormente
→ Roda Migrations e Restart Servidor

Isso é o que acontece quando você executa gploy -s. Nesse momento seu projeto esta no ar, se tudo aconteceu como o esperado.

Novos Deploys.

Toda vez que você quiser atualizar seu projeto em produção simplesmente faça gpoy -d, ele irá ir até a branch master e fazer um simples push.

Quando usar essa gem?

Eu não recomendaria usar ela para algum projeto real no qual você possa perder dinheiro se o mesmo não estiver ok no ar. Mas acredito que se você esta desenvolvendo algo mais simples e quiser simplesmente colocar em produção para testes externos, ou até mesmo para colocar em produção sistemas ou Web Sites mais simples e que não precisem ficar 24/7 online acredito que possa vir a ser útil, eu até mesmo uso em algumas coisas que estão online.

Logs

O gploy mantem arquivo de log bem simples, ele simplesmente informa qual comando foi executado e se o mesmo foi feito localmente ou remotamente, você pode encontrar esse arquivo dentro da pasta logs do seu projeto Rails.

Testes

Essa gem não tem cobertura 100% de testes unitários, basicamente o que mantenho até o momento são 22 testes usando Rspec. Obviamente não esta tudo testado com esse numero, mas por hora já me ajuda a não ter muita dor de cabeça na hora de mexer no código do projeto. Abaixo o resultado gerado pelo Rcov para a cobertura de testes dessa gem.

Funcionalidades Futuras.

Ainda não tenho nada certo para novas funcionalidades do gploy, o que pretendo implementar é um forma de poder deixar para o usuário escolher qual pasta quer usar para repositório(ou seja, se quiser mudar o nome de repos para qualquer outro), também uma forma simples de usar seu repositório do github, já que o mesmo suporta hooks.

Conclusão

Esta é uma RubyGem simples mas que pode ser útil em certas situações, caso você tenha gostado, faça um fork do projeto no github e sugira modificações e correções de bugs. E quem tiver acesso a outros servidores que não sejam da locaweb por favor entre em contato para que possamos realizar alguns testes, mas penso que a estrutura seja a mesma praticamente.

Links:
Source Code: http://github.com/edipofederle/gploy/
RubyGems: http://rubygems.org/gems/gploy

Git Documentation: http://git-scm.com/documentation

Olá pessoal, a algum tempo já postei aqui como fazer para instalar e configurar o GIT
no Ubuntu Linux, e disse que haveria mais sobre o git aqui no blog, pois bem passou maior
tempão e não postei nada sobre o GIT, pois bem, aqui estou, nesse segundo post sobre git vamos dar uma olhada
no básico do git, vamos criar um “projeto” de “mentira” para simularmos o uso básico do git.

1 – Começando…

Para começar vamos criar um diretório para armazenar nosso “projeto”, vamos chamar esse
diretório de ‘demo’, dentro dele vamos criar uma pasta libs uma log e alguns arquivos,
então vamos para o nosso bom o velho terminal.

OBS: Estou rodando no Ubuntu, caso você seja do mundo Windows recomendo seguir os
passos do ótimo post do Fábio Akita sobre como montar um ambiente de programacão
Ruby/Rails no Windows, esse inclue o GIT.

Bem dito isso … no terminal:

mkdir demo
cd demo
mkdir libs logs
touch file1.rb file2.rb file3.rb file4.rb

Bom acho que não prescisa nem explicar… criamos as pastas com mkdir e alguns arquivo com
o touch, bom nosso diretório demo esta assim:

.
|– file1.rb
|– file2.rb
|– file3.rb
|– file4.rb
|– libs
`– logs

2 directories, 4 files

2 – O arquivo .gitignore.

Esse arquivo é de grande importância nele podemos definir o que queremos que o git ignore
por exemplo, arquivos de log (nossa pasta log, por exemplo) não necessita de controle de
versão, um pasta que contém algumas imagem usada no projeto idem e assim por diante,
aqui entra seus critérios do que você não quer que o git controle.

No meu caso eu costumo ainda adicionar um linha para ele ignorar os arquivos temp(~),
que o editor(gvim, gedit…) cria.

Tendo isso em mente podemos criar nosso .gitignore.

touch .gitignore
gvim .gitignore

Acima criamos o arquivo .gitignore e abrimos ele com o gvim e digitamos o seguinte:

log/*.*
*.rb~

OBS1: Isso não é nada “mundo real” como não estou criando um projeto de verdade não irei
ter arquivo de log (.log) de verdade, então simplesmente mandei ele ignorar tudo dentro
da pasta log/, apenas para demonstração.

3 – Inicializando o GIT…

Agora vamos colocar o GIT em ação para inicializar o repositório git usamos o comando
git init… então na pasta demo ….

git init

você irá receber a seguinte mensagem:
Initialized empty Git repository in /home/edipo/Desktop/demo/.git/

Tudo OK, nosso repositório foi inicializado.

Agora se você der um ls -la(lista arquivos incluindo ocultos) irá ter algo assim:

ls -la
total 32
drwxr-xr-x  5 edipo edipo  4096 2009-02-20 00:52 .
drwxr-xr-x 11 edipo edipo  4096 2009-02-20 00:20 ..
-rw-r–r–  1 edipo edipo     0 2009-02-20 00:21 file1.rb
-rw-r–r–  1 edipo edipo     0 2009-02-20 00:21 file2.rb
-rw-r–r–  1 edipo edipo     0 2009-02-20 00:21 file3.rb
-rw-r–r–  1 edipo edipo     0 2009-02-20 00:21 file4.rb
drwxr-xr-x  7 edipo edipo  4096 2009-02-20 00:52 .git
-rw-r–r–  1 edipo edipo     0 2009-02-20 00:34 .gitignore
drwxr-xr-x  2 edipo edipo  4096 2009-02-20 00:20 libs
drwxr-xr-x  2 edipo edipo  4096 2009-02-20 00:20 logs

4 – Adicionando os arquivos ao git…

Agora que já temos nossos arquivos, incluindo o .gitignore e nosso repositório inicializado
podemos adicionar nossos arquivos ao git, para fazer isso você usa o comando git add .

o .(ponto) do comando quer dizer TODOS arquivos, mas você também pode adicionar somente um
usando por exemplo git add nome_arquivo.

Bom vamos ver em que estado estamos agora, para isso temo o camando git status que nós diz
como as coisas estão:

git status
#         On branch master
#
# Initial commit
#
# Changes to be committed:
#   (use “git rm –cached <file>…” to unstage)
#
#       new file: .gitignore
#       new file: file1.rb
#       new file: file2.rb
#       new file: file3.rb
#       new file: file4.rb
#

e ai está temos nossos novos arquivos, agora pricisamos fazer o primeiro commit para isso
usamos o comando git commit -m -a ‘mensagem’, bom -m quer dizer que queremos colocar
uma mensagem e -a todos os arquivos, você pode também usar somente  commit -a
ai ele irá abrir seu editor de texto padrão então você adiciona sua mensagem no arquivo
que será aberto, então:

git commit -a

o vim será aberto digito ‘i’ para ir para o modo de edição e digito a mensagem “Primeiro
Commit” dou ESC e para sair e salvar, pronto vou receber o seguinte no terminal:

git commit -a
Created initial commit 3825061: Primeiro Commit
1 files changed, 2 insertions(+), 0 deletions(-)
create mode 100644 .gitignore
create mode 100644 file1.rb
create mode 100644 file2.rb
create mode 100644 file3.rb
create mode 100644 file4.rb

Ok está ai os arquivos, agora podemos usar o comando git log para ver como estão as coisas:

git log
commit 382506110486d1d89de8debbe8ef54f0bd83d8c2
Author: edipo <edipofederle@gmail.com>
Date:   Fri Feb 20 12:46:23 2009 -0300

Primeiro Commit

Então ai está o nosso primeir o commit.

5 – Modificações…

Bom legal até agora, vamos agora modificar alguns arquivo para a ver como o git age.

vim file1.rb
i

vamos criar uma simples classe Ruby nesse arquivo, coloque o seguinte ou qualquer outra
coisa que você queira.

[sourcecode="ruby"]

class File1
def hello(name)
puts “Hello #{name}.”
end
end

[/sourcecode]salve o arquivo, voltando ao terminal usamos o git status para ver se algo mudou..

git status
# On branch master
# Changed but not updated:
#   (use “git add <file>…” to update what will be committed)
#
#       modified:   file1.rb
#
no changes added to commit (use “git add” and/or “git commit -a”)

Bom, ai está o nosso arquivo que fizemos a mudança, antes de dar um commit precisamos adicioná-lo então…

git add file1.rb

agora rodando o git status temos:

git status
# On branch master
# Changes to be committed:
#   (use “git reset HEAD <file>…” to unstage)
#
#       modified:   file1.rb
#

Vamos fazer mais uma mundaça agora no arquivo file2.rb, vamos colocar algo simples nele como isso:

[sourcecode="ruby"]

class File2
def sum(x,y)
x + y
end
end

[/sourcecode]Ok, agora que alteramos outro arquivos vamos usar o comando git status para ver como estão as coisas:

git status
# On branch master
# Changes to be committed:
#   (use “git reset HEAD <file>…” to unstage)
#
#       modified:   file1.rb
#
# Changed but not updated:
#   (use “git add <file>…” to update what will be committed)
#
#       modified:   file2.rb

Agora o git nos diz que temos dois arquivos modificados mas somente um( file1.rb) para ser ‘committed’, então
agora damos um:

git commit

ele irá abrir o seu editor com o seguinte conteudo:

# Please enter the commit message for your changes.
3 # (Comment lines starting with ‘#’ will not be included)
4 #
5 # Committer: edipo <edipofederle@gmail.com>
6 #
7 # On branch master
8 # Changes to be committed:
9 #   (use “git reset HEAD <file>…” to unstage)
10 #
11 # modified:   file1.rb
12 #
13 # Changed but not updated:
14 #   (use “git add <file>…” to update what will be committed)
15 #
16 # modified:   file2.rb

No inicio do arquivo digite a mensagem do commit, – Commit somente para file1.rb nao para file2.rb”

salve, e você irá receber a seguinte mensagem:

Created commit bc36724: Apenas Commit do file1.rb nao do file2.rb
1 files changed, 5 insertions(+), 0 deletions(-)

e dando um git status temos:

git status
# On branch master
# Changed but not updated:
#   (use “git add <file>…” to update what will be committed)
#
#       modified:   file2.rb
#
no changes added to commit (use “git add” and/or “git commit -a”)

Então temos o file2.rb que ainda nao foi add, vamos fazer mais alguma modificação em algum arquivo.

e dadando um git status agora temos os dois arquivos que foram modificados:

git status
# On branch master
# Changed but not updated:
#   (use “git add <file>…” to update what will be committed)
#
#       modified:   file2.rb
#       modified:   file3.rb

se dermos um git commit iremos receber a mesma acima:

git commit
# On branch master
# Changed but not updated:
#   (use “git add <file>…” to update what will be committed)
#
#    modified:   file2.rb
#    modified:   file3.rb
#
no changes added to commit (use “git add” and/or “git commit -a”)

Agora temos duas modificações vamos fazer um commit adicionando todos(dois) arquivos, para isso:

commit -a

a opcão -a é para add todos arquivos, deixamos ele assim:

1 Adicionando todas as modificacoes
2 # Please enter the commit message for your changes.
3 # (Comment lines starting with ‘#’ will not be included)
4 #
5 # Committer: edipo <edipofederle@gmail.com>
6 #
7 # On branch master
8 # Changes to be committed:
9 #   (use “git reset HEAD <file>…” to unstage)
10 #
11 # modified:   file2.rb
12 # modified:   file3.rb
13 #

recebemos o seguinte ao salvar o arquivo:

Created commit 6c010c9: Adicionando todas as modificacoes
2 files changed, 10 insertions(+), 0 deletions(-)

Ok, ai esta, agora vamo ver como ta nosso log:

git log
commit 6c010c9a8168c5c4978125e57eab7f82b795e82b
Author: edipo <edipofederle@gmail.com>
Date:   Fri Feb 20 22:37:30 2009 -0300

Adicionando todas as modificacoes

commit bc36724bdfd5411466f27d72ce9dede1164478a3
Author: edipo <edipofederle@gmail.com>
Date:   Fri Feb 20 22:13:37 2009 -0300

Apenas Commit do file1.rb nao do file2.rb

commit 382506110486d1d89de8debbe8ef54f0bd83d8c2
Author: edipo <edipofederle@gmail.com>
Date:   Fri Feb 20 12:46:23 2009 -0300

Primeiro Commit

Bom é isso nesse post, já deu para perceber o quão legal é o git, e como ele deixa as coisas organizadas, obviamente isso nao é um projeto real, e estamos “desenvolvendo” sozinhos, mas para fins de aprendizado creio que já deu para pegar algo, no próximo post iremos dar uma olhada em branchs e merges, é isso ai pessoal, espero que venha a ajudar alguem, por favor se alguem achar algum erro nesse post faza-me saber deixando um comentário, e se você
gostou tembém deixe um comentário, até mais pessoal e usem o GIT

Este é um post rápido de como você deve proceder na hora de instalar o GIT em sua maquina, nesse iremos baixar do site do git e fazer a compilação no Ubuntu Linux, então vamos lá.

1 – Baixar os fontes do site.

2 – Descompactar.

3 – ./configure . . . make . . . sudo make install

4 – Configurações.

5 – Configurando o usuario.

6 – Algumas modificações ( Opcional )

1 – Baixar os fontes do site . . . .

No terminal você pode usar o wget ou o curl para baixar(usei o curl, caso nao o tenha, sudo apt-get install curl)

curl -f http://kernel.org/pub/software/scm/git/git-1.6.0.1.tar.bz2

2 – Descompactando . . . .

tar xvjf git-1.6.0.1

cd git-1.6.0.1

3 – Compilando e instalando . . . .

Como costumo deixar todos os programar que compilo no mesmo diretório irie usar a opção -prefix=/usr/local/

./configure -prefix=/usr/local/

make

sudo make install

4 – Configurando . . .

Vá para a pasta home . . .

cd

gedit .profile

nesse arquivo vamos fazer com que a instalação do git seja encontrada, coloque o seguinte conteudo nele:

export PATH=”/usr/local/bin:$PATH”

feche o editor e e carregue as alteracoes com . . .

source .profile

verifique se tudo deu certo com um

git –version

=> git version 1.6.0.

5 – Configurando o usuario.

git config –global user.name “Seu nome Aqui”

git config –global user.email “Seu Email Aqui”

6 – Algumas modificações ( Opcional ) . . .

Não vem ao caso aqui nesse post falar sobre o uso propriamente dito do GIT, mas obviamente ele possue comando e como você pode criar alias para comandos do Linux por exemplo você tambem pode criar para o GIT, não irei criar nenhum alias aqui, mas vou deixar a sintaxe do comando caso o queira fazer.

git config –global alias.<comando_atalho> <comando_original>

OBS: sem os <>.

Bom, com isso a ultima versão do GIT esta instalada no seu Linux, no proximo post veremos alguns testes com o GIT.