Instalar SSH e Git em Linux (Integração contínua parte 2)

Neste segundo artigo da série “Como criar um servidor de integração continua” vamos instalar o Git e SSH num servidor com Linux Mint.

Vamos mostrar como configurar estes serviços numa máquina de desenvolvimento Windows e, no final, como submeter alterações do projeto para o repositório Git do servidor de integração continua.

O artigo está dividido nos seguintes temas:

Instalação e criação de repositório Git no servidor Linux
Instalação de SSH e criação do par de chaves RSA no servidor Linux
Instalação e configuração do Git e SSH no Windows
Criação do projeto e push para o servidor

1. Instalação e criação de repositório Git no servidor Linux

Começamos pela instalação do Git com o comando
```
sudo apt-get install git
```
Agora vamos criar o repositório na pasta /home/user/git. Podes optar por outra localização se preferires. Com os comandos abaixo vamos criar a pasta e iniciar o repositório.
```
mkdir /home/user/git
mkdir /home/user/git/testproject.git/
cd /home/user/git/testproject.git/
sudo chown -R user /home/user/git/testproject.git
sudo git --bare init
```
Importa referir que o “user” é o nome do utilizador do servidor e deves alterar este nome pelo nome do teu utilizador. O comando chown muda o owner da pasta e garante que o teu utilizador terá permissões para fazer alterações aos ficheiros.
Terminamos com a configuração do utilizador do Git. Embora não seja essencial, nem seja provável efetuares alterações ao repositório diretamente no servidor, é preferível fazer a configuração do nome de utilizador e email para o Git.
```
git config --global user.name "user"
git config --global user.email geeks@geekalicious.pt
```

Com estes comandos ficamos com o Git instalado e criámos o repositório central.

2. Instalação de SSH e criação do par de chaves RSA no servidor Linux

O objetivo é programar numa máquina Windows e submeter as alterações para o repositório Git do servidor. Para enviar as alterações do Git para o servidor, é necessário criar uma ligação ao Git através de um dos vários protocolos disponíveis. O protocolo mais comum é o SSH e é isso que vamos instalar.

Executar o comando para instalar SSH
```
sudo apt-get install openssh-server
```
O SSH necessita de uma chave RSA que é criada com o comando seguinte
```
ssh-keygen -t rsa
```
Este comando pede a localização e o nome do ficheiro para chave, tendo eu optado por deixar o valor por defeito (_/home/user/.ssh/idrsa). Em relação à palavra-chave introduz uma à tua escolha
Vamos verificar se o serviço está a ser executado
```
ps -e  | grep [s]sh-agent
```
Se o serviço estiver a ser executado, deves ver o resultado do comando semelhante a

Caso contrário, deves iniciar o serviço através do comando
```
ssh-agent /bin/bash
```
Agora adicionamos a identidade RSA ao agente de autenticação através do comando
```
ssh-add ~/.ssh/id_rsa
```
E garantimos que a identidade foi associada com sucesso através do comando
```
ssh-add -l
```
Se tudo correu bem, deverá ser apresentada uma informação semelhante a
Adicionamos o utilizador da máquina à configuração do SSH
```
sudo gedit /etc/ssh/sshd_config
```
No editor é necessário adicionar a linha seguinte. Nota que o user é o nome do utilizador que tenho e deve ser alterado pelo que estás a usar
```
AllowUsers user
```
Depois de guardares o ficheiro é necessário reiniciar o serviço através do comando
```
sudo /etc/init.d/ssh restart
```
Agora que já temos instalado o SSH, vamos testar a ligação através de um computador a correr Windows. Para isso vamos usar o PuTTY. Na computador Windows, descarrega e executa o ficheiro de instalação em vez de descarregar ficheiros avulso. Isto porque iremos precisar do putty.exe, puttygen.exe, pageant.exe e plink.exe.

Recomendo que a seja feita para um caminho sem espaços (ex: c:\programas\putty).

Depois de instalado, vamos testar a ligação através do putty.exe onde basta apenas introduzir o endereço IP ou nome do servidor

Será apresentada uma mensagem a perguntar se queres adicionar a chave à cache do PuTTY onde deves responder afirmativamente.
Verificamos que o SSH está instalado e conseguimos aceder ao servidor. Contudo, quando estamos a desenvolver, não queremos estar constantemente a introduzir o utilizador e password a cada push para o Git.

Para ultrapassar este incómodo, vamos criar um par de chaves que será usado para fazer a autenticação de forma “automática”. Vamos usar o PuTTYgen para gerar uma chave
Agora, novamente no servidor Linux, acedemos à pasta .ssh do utilizador e adicionamos ao ficheiro _authorizedkeys o conteúdo da chave pública criada pelo PuTTYgen. Para o efeito, usamos o comando
```
cd ~/.ssh/
echo «chave-puttygen» >> authorized_keys
```
Para usarmos esta chave no PuTTY é necessário, no PuTTYgen, guardar a chave privada. Para o efeito, devemos preencher os campos Key passphrase e Confirm passphrase e carregar no botão Save private key.

Convém guardar também a chave pública uma vez que apenas é possível fazer a autenticação com o par chave pública / chave privada.

No Windows (Vista, 7 e 8) guarda a chave em _c:\users\«user».ssh\idrsa, onde «user» é o nome de utilizador do computador Windows.
Vamos fazer uma nova ligação ao servidor com o PuTTY, mas desta vez vamos usar a chave privada para fazer a autenticação. Para isso, executamos o PuTTy e acedemos à opção Connection » SSH » Auth. No campo Private key file for authentication selecionamos o ficheiro _idrsa guardado no passo anterior.

Ainda nas configurações do PuTTY vamos definir o utilizador que deve ser assumido na sessão, para evitarmos o preenchimento do nome de utilizador. Navegamos até Connection » Data e colocamos o nome do utilizador no campo Auto-login username
Assumindo que as definições foram corretamente definidas, quando abrires a sessão do PuTTY deve ser apresentada uma mensagem semelhante a
Resta alterar as permissões do ficheiro _authorizedkeys no servidor, para que fique apenas de leitura pelo dono do ficheiro, através do comando
```
chmod 400 authorized_keys
```
Por fim, é possível aceitar apenas ligações SSH através da chave e impedir tentativas de login com utilizador e password. Se quiseres fazer essa alteração deves alterar as configurações do SSH, usando o comando
```
sudo gedit /etc/ssh/sshd_config
```
No editor aberto, altera as opções de acordo com a informação abaixo
```
PasswordAuthentication no
UsePAM no
```

3. Instalação e configuração do Git e SSH no Windows

Na secção anterior já demos inicio à configuração do SSH no Windows, nomeadamente com a instalação do PuTTY e criação de chaves RSA. Falta a instalação do Git e algumas configurações, que vamos analisar agora.

Para instalar o Git, começa por descarregar a última versão. Na instalação é importante selecionares a opção “Use Git from the Windows Command Prompt”
Depois de instalado o Git adiciona, nas Variáveis de Ambiente do Windows. a variável GIT_SSH com o caminho do plink.exe, incluído no PuTTY.

Enquanto estás neste ecrã, adiciona também as pastas bin do Git e a pasta de instalação do PuTTY à variável de ambiente PATH. Por exemplo: ;C:\programs_\PuTTY\;C:\programs_\git\bin\.

Nota: Caso tenhas uma Firewall ou solução de segurança All In One deves garantir que todos os ficheiros do Git se encontram nos Ficheiros Confiáveis. Se não o fizeres, é provável que ocorram alguns erros, mesmo que o Git não esteja a ser bloqueado, como por exemplo cannot spawn ssh: No such file or directory
Está na altura de testar a ligação SSH ao servidor, através da linha de comandos, com:
```
ssh –T user@192.168.56.102
```
Onde “user” é o nome de utilizador do servidor e “192.168.56.102” é o endereço IP. Ajusta estes valores de acordo com as tuas necessidades. Se tudo correu bem, deves ver a seguinte informação:
Agora vamos fazer a ligação com o plink.exe e com a chave carregada no pageant.exe. O objetivo é conseguirmos fazer a autenticação por SSH sem necessidade de password nem a palavra-passe da chave.

Para isso, vamos começar por executar o Pageant (localizado na pasta de instalação do PuTTY) e vamos carregar a chave:

Deves introduzir a palavra-passe da chave e ficas com a chave carregada no Pageant.
Testamos então a ligação com o plink:
```
plink user@192.168.56.102
```
Garantimos, portanto, que está tudo a funcionar corretamente. Isto é, podemos fazer ligações SSH sem necessidade de introduzir utilizador ou password nem a palavra-passe da chave, desde que o Pageant esteja a ser executado e a chave esteja carregada.

4. Criação do projeto e push para o servidor

Vamos criar o projeto para submeter (fazer push) para o repositório Git criado na primeira secção. O projeto PHP que vamos criar, sobre a framework Laravel 5.0, será usado nos restantes artigos da série.

Vamos criar o projeto através do Composer, que é um gestor de dependências para PHP. Assumimos que já tens instalado o Composer em Windows.
```
composer create-project laravel/laravel testproject –prefer-dist
```
Com este comando será criada uma pasta chamada testproject na localização onde te encontras, com o código da framework Laravel.
Agora vamos criar o repositório Git na pasta do projeto, no meu caso c:\webapps\testproject. Depois do repositório criado, fazemos o primeiro commit com a mensagem “First commit”.
```
cd C:\webapps\testproject>
git init
git add .
git commit -am "First commit"
```
Neste momento o projeto encontra-se no repositório local mas não está ainda no repositório central (que criámos na secção 1).
Antes de ser possível fazer push temos de adicionar o repositório remoto, através do comando abaixo. Lembra-te de ter o Pageant ligado, com a chave carregada, conforme indicado nos passos finais da secção anterior.
```
git remote add origin ssh://user@192.168.56.102/home/user/git/testproject.git
```
Onde:
- user é o nome de utilizador do servidor
- 192.168.56.102 é o endereço IP do servidor
- /home/user/git/testproject.git/ é o caminho do repositório no servidor, de acordo com a localização onde o mesmo foi criado (ver secção 1)
Agora sim, vamos enviar as alterações do repositório local para o repositório do servidor. Para isso executamos o comando:
```
git push origin master
```
E deves ver um resultado semelhante a

Finalmente, após instalação do Git e SSH no servidor, a criação de chaves RSA, a instalação do Git na máquina Windows e a criação de repositórios, é possível fazer push para o repositório do servidor. E isto sem a necessidade de introduzir o utilizador e password ou a palavra-passe da chave RSA cada vez que pretendemos fazer push.

No próximo artigo vamos dizer como instalar o Redmine e como associar o repositório Git ao Redmine para vermos o histórico de alterações. Além disso, vamos conseguir fechar tarefas do Redmine através dos commits no Git.

Este artigo faz parte da série Como criar um servidor de integração contínua