Automatizando a instalação (deploy) e atualização de sites com Git.

Introdução

Existem diversas maneiras de automatizar o deploy de sites com git. O objetivo dessa página é explicar passo a passo como configurar um deploy automatizado usando somente o Git que é uma das maneiras mais simples, e utilizando o Github.

Você vai precisar que o servidor do seu site tenha:

Acesso SSH
Git instalado no servidor
Chave de segurança configurada

Automatizando o deploy com o Git

Um recurso muito útil para quem trabalha com sites e servidores, é o SSH (Secure Shell), que é uma forma de você acessar, remotamente, a linha de comando de um servidor e com isso fazer modificações e instalações direto no servidor, sem usar uma interface gráfica ou um painel de controle como o cPanel.

O SSH é como se fosse um acesso VNC (Virtual Network Connection) diretamente na linha de comando do servidor.

Para acessar o SSH de um servidor normalmente usamos o seguinte comando:

 $ ssh usuario@dominio

Após isso, é perguntado a sua senha de acesso do servidor e você está dentro e pode executar comandos do Linux para trabalhar na máquina. Sendo assim esse é nosso primeiro passo:

1º Passo: Acessar o seu servidor remotamente via ssh como no exemplo acima.

2º Passo: Se você não tiver o git instalado no seu servidor você precisará realizar a instalação do mesmo. Se você já tiver o git instalado pule para o próximo passo.

3º Passo: Uma vez logado no servidor, você deve navegar até a pasta raiz do seu projeto (Document Root), neste caso de exemplo, está localizado em /var/www/html/exemplodeploy/

 $  cd /var/www/html/exemplodeploy/

4º Passo: Crie um diretório, que em nosso exemplo será app.git, e entre nele usando o comando:

$ mkdir app.git && cd app.git

5º Passo: Uma vez dentro do diretório app.git, executamos o comando

$ git init --bare

Esse comando irá inicializar um repositório mínimo do Git, digo mínimo porque ele não possui todas as funcionalidades do Git, por exemplo, não será possível executar comandos como push e pull nele, a única e exclusiva funcionalidade desse repositório é receber os push do seu ambiente de desenvolvimento e manter sua aplicação atualizada com segurança no servidor.

6º Passo: Até aqui já temos boa parte do trabalho pronta. Todo repositório Git tem uma pasta chamada “hooks”, onde estão disponíveis scripts que serão chamados de acordo com determinadas ações. O “post-receive”, em especial, é executado assim que um repositório remoto recebe todos os dados de um push. A partir daí, basta escrever um pequeno script que copie estes arquivos para a pasta de produção. Oque vamos fazer agora é criar um arquivo chamado post-receive dentro do diretório hooks, então execute o comando:

$ nano hooks/post-receive

7º Passo:Veja no exemplo como fica o script, repare que o GIT_WORK_TREE é o local onde seu site/app ficará armazenado, seguido do comando git checkout -f

$ #!/bin/sh
GIT_WORK_TREE=/var/www/html/exemplodeploy git checkout -f

Um detalhe muito importante é que na primeira linha do post-receive deve ter o comentário #!/bin/sh para que esse arquivo seja executado corretamente. Ao preencher o post-receive como indica a imagem salve o documento com o atalho CTRL+o e em seguida para sair CTRL+x.

Explicando de forma simples o que ocorre e o papel do hook post-receive, é que esse post-receive trabalha como um espece observer e atua sempre que um novo post é recebido no diretório app.git, então sempre que você executar o comando git push deploy master (jajá vamos configurar isso), o post-receive vai pegar os arquivos e enviar para o diretório indicado no GIT_WORK_TREE e checar esse cara como versão atual a se trabalhar, vale lembrar que um repositório do tipo — bare não guarda as versões, por isso que se deve trabalhar com Github ou Bitbucket para fazer o versionamente, o repositório que criamos no servidor só é responsável em manter atualizado a ultima versão que é enviada pra ele.

8º Passo:Antes de fechar essa parte no servidor precisamos dar permissão de execução para o hook que criamos, então fazemos isso usando o comando:

$ sudo chmod +x hooks/post-receive.

Acabamos a parte do servidor, agora vamos para nosso ambiente local na qual estamos desenvolvendo. Navegue até o diretório do seu projeto e caso ainda não tenha iniciado um repositório git nele faça (git init), uma vez já com o git iniciado no projeto precisamos adicionar uma indicação remote nele, para isso use o comando abaixo (tudo na mesma linha) como se faz quando vamos adicionar o origin (Github/Bitbucket):

$ git remote add deploy usuario@dominio:/var/www/html/exemploydeploy/app.git

Uma vez isso feito basta fazer seu commit pro servidor da mesma forma que faz para Github, apenas substituindo origin por deploy e sempre indicando o branch master. Exemplo:

$ git add .
$ git commit -am “Commitando as alterações par ao servidor”
$ git push deploy master

Como esse push/deploy pro repositório do tipo — bare só é permitido usando o branch master, sempre se trabalhar com outros branchs é importante fazer o merge com o master antes de realizar o deploy.

Automatizando o Deploy com o Github (Crontab e Webhooks)

Primeiramente deve criar uma conexão segura com o nosso servidor, para isso precisamos vincular uma chave ssh do servidor com a conta no github, para criar devemos usar o comando:

$ ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

Com a chave devidamente criada podemos registrar ela no perfil do Github, mas para isso precisamso acessar a chave ssh no servidor:

cd ~
cd .ssh
cat id_rsa.pub

Copie a saída do terminal, agora vamos registrar no github:

Acesse a sessão Settings no seu perfil do Github
Acesse a aba SHH GPG keys
Clique em New SSH key or Add SSH key

Adicione as informações obtidas no terminal do servidor nos campos adequados, e sua configuração estará pronta !

Feitos as configurações agora podemos clonar nossos repositórios

CronJob

Nosso servidor foi previamente configurado com o LAMP (Linux, Apache, MySQL and PHP)

Primeiro vamos clonar no servidor utilizando o ssh, diretamente na pasta de acesso do apache:

$ cd /var/www/html 
$ git clone git@github.com:joao-henrique/gcs-auto.git

Com isso já conseguimos ver os arquivos pelo servidor apache acessandoo browser:

$ ip.servidor/gcs-auto

Agora se fizemos qualquer alteração na nossa máquina local e submeter um push para o repositório do github podemos ter acesso no servidor.

Mas para isso precisamos atualizar manualmente o servidor com o comando:

$ git pull

Mas essa não é a intenção, precisamos automatizar isso de alguma maneira. Para isso vamos utilizar primeiramente o crontab. Mas o que é um crontab:

“O crontab é uma lista de comandos que você deseja executar em um horário regular”

Vamo usar para gerenciar nosso updates por agora. Com o comando abaixo vamos criar nossa task de atualização:

$ crontab -e

Selecione o editor de sua preferencia para editar. Vamos adicionar o trecho de codigo a seguir no arquivo crontab:

* * * * * cd /caminho/do/repo/ && git pull

Os asteriscos listados inicialmente determinam o tempo para a execução do arquivo, essa lista representa 1 minuto.

Então o que esse arquivo está fazendo : a cada 1 minuto ele acessa o repositório do github local e dá um pull.

Altere algum arquivo do seu repositório e dê push, aguarde um tempo e perceberá a atualização.

Webhooks

Agora vamos clonar outro repositório para ficar mais claro

Primeiro vamos clonar no servidor utilizando o ssh, diretamente na pasta de acesso do apache

$ cd /var/www/html 
$ git clone git@github.com:joao-henrique/gcs-webhook.git

Com isso já conseguimos ver os arquivos pelo servidor apache acessando:

$ ip.servidor/gcs-webhook

Agora se fizemos qualquer alteração na nossa máquina local e submeter um push para o repositório do github podemos ter acesso no servidor. Mas para isso precisamos atualizar manualmente o servidor com o comando:

$ git pull

Agora nós vamos utilizar o webhooks do github para atualizar nosso servidor.

Webhooks permitem construir ou criar integrações que são ativados a certos eventos GitHub.com . Quando um desses eventos é ativado , enviaremos uma requisição HTTP POST para URL configurado do webhook.

Com o nosso repositório devidamente clonado vamos adicionar uma pasta chamada deploy no servidor, é importante essa pasta está com acesso público pois esse arquivo será o gatilho para atualização do repositório

Para criar a pasta no servidor (A pasta deploy precisa estar dentro da pasta do projeto clonado do git)

$ mkdir /var/www/html/deploy

Agora dentro dessa pasta deploy precisamos criar o arquivo que vai receber o payload do github

$ nano /var/www/html/deploy/webhook.php

No arquivo vamos adicionar o seguinte trecho de código:

<!DOCTYPE html>
<html lang="pt-br">
<head>
<meta charset="utf-8"/>
<title>Usando GIT para atualizar arquivos</title>
</head>
<body>
	<pre>
	<?php
		$exec = shell_exec("git pull origin master 2>&1");
		echo $exec;
	?>
	</pre>
</body>
</html>

Com o arquivo no servidor agora precisamos configurar o github para disparar o gatilho a cada push no repositório.

Acesse seu repositório, no menu lateral esquerdo, clique em “Configurações”.

Na tela configurações clique em “Webhooks” e depois em “Add Webhook”

No campo “Title” adicione um nome de sua preferência e no campo “URL” adicione o endereço para a sua url que executa o comando de atualização, no meu caso a URL é “http://ip.servidor/deploy/webhook.php”

Pronto agora todo push no repositório nosso webhook será ativado e acionará o webhook.php que irá atualiza o servidor