cap04.Rmd

title: "4. Projetos remotos"
author: "PET Estatística"
date: "29/11/2015"
output:
    html_document:
        highlight: pygments
        toc: true
        theme: flatly
        keep_md: true

Introdução

Para colaborar em projetos coletivos no Git é preciso ter um repositório remoto. Este repositório conterá todo o histórico das versões dos arquivos editados. A seguir serão abordados como adicionar, remover e gerenciar repositórios remotos.

Primeiramente será apresentado o comando git remote, este é usado para verificar quais repositórios estão configurados.

Exemplo: para retornar a lista de repositórios:

git remote

No comando acima é possível visualizar o remoto padrão origin (URL SSH para onde será possível enviar os seus arquivos).

Exemplo: para retornar o nome dos repositórios com a URL onde foram armazanados:

git remote -v

Adicionando repositórios remotos

O comando git remote add adiciona um repositório remoto. No exemplo a seguir será adicionado um repositório chamado MeuRepo ao qual será vinculado a URL git@gitlab.c3sl.ufpr.br:pet-estatistica/apostila-git.git. Usaremos como exemplo o projeto Git Apostila-git.

Exemplo:

git remote add MeuRepo git@gitlab.c3sl.ufpr.br:pet-estatistica/apostila-git.git
# Quando executamos novamente o comando para obter a lista de repositórios:
git remote -v

Pare acessar localmente o branch master do projeto Apostila-git será usado MeuRepo/master.

Obtendo informações de um Remoto

Você pode acessar as informações de qualquer repositório remoto com o comando git remote show, que retornará a URL e os branches.

Exemplo:

git remote show origin

Renomeado Remotos

O comando git remote rename pode modificar o nome de um repositório remoto. A seguir o repositório MeuReposerá renomeado para RenameRepo.

Exemplo:

git remote rename MeuRepo RenameRepo

Removendo Remotos

Para remover remotos é utilizado o comando git remote rm, agora será removido o repositório renomeado anteriormente RenameRepo.

Exemplo:

 git remote rm RenameRepo

Protocolos Git

Há quatro tipos diferentes de protocolos Git (Local, Git, HTTP e SSH).

Nesta apostila será abordado apenas o Secure Shell (SSH). Por ser fácil de fazer a configuração do acesso deste protocolo aos servidores, este é o mais usual.

Criando um Repositório Git

Primeiramente é necessário ter acesso a um servidor Linux com chave SSH, no qual você poderá ter seus repositórios. É definido um diretório no qual será armazenado o repositório remoto. No próximo exemplo é preciso criar um repositório remoto chamado MeuRepo e o armazenar em um diretório ~/git:

Exemplo: ```{r, engine="sh", eval=FALSE}

Para criar um diretório git na sua home:

mkdir ~/git

Para criar um repositório git:

mkdir MeuRepo.git

Para definir MeuRepo como um repositório remoto:

git --bare init

As configurações do servidor estão completas. A partir você pode realizar os primeiros comandos para iniciar o repositório criado.


## Git no servidor

Primeiramente, para configurar o Git no Servidor e configurar os protocolos, clonaremos o repositório existente em um repositório limpo. 
**Observação:** você poderá colocar um repositório no Servidor se este não contém um diretório de trabalho. 

**Exemplo:**
```{r, engine="sh", eval=FALSE}
 git clone --bare MeuRepo MeuRepo.git

Acima foi criado um repositório limpo MeuRepo.git, no qual está armazenada a cópia de todos os arquivos do diretorio Git.

Após este primeiro passo o repositório limpo será colocado no Servidor e configurado os protolocos. No exemplo abaixo, supondo que você tem configurado um servidor git.servidor.com, e um diretório /dir/gitno qual você quer armazenar seus repositórios. Ao copiar o seu repositório limpo, você pode configurar seu novo repositório.

Exemplo: ```{r, engine="sh", eval=FALSE} scp -r MeuRepo.git usuario@git.example.com:/dir/git

Agora o repositório pode ser clonado por outros usuários, que podem ter acesso de escrita e de envio de arquivos `push` no diretório. 

    ```{r, engine="sh", eval=FALSE}
git clone usuario@git.example.com:/dir/git/MeuRepo.git

Configuração de Conexão SSH com Servidor

O Git possibilita ao usuário realizar uma chave SSH que fará uma conexão segura da sua máquina com o servidor. Para isso começamos com o seguinte comando no terminal:

Exemplo: ```{r, engine="sh", eval=FALSE}

Gerando uma chave ssh

ssh-keygen -t rsa -C "usuario@email.com"

A partir deste comando, será possível alterar o diretório onde será salva a chave SSH. O usuário tem a opção de permanecer com o diretório padrão, para isso basta apertar Enter.
A partir disso, são criados dois arquivos no diretório, o `id_rsa` e o `id_rsa.pub`.
Após escolher o diretório onde serão salvos os arquivos, você terá a opção de digitar uma senha ou deixar o espaço em branco.

Para visualizar a chave basta digitar o seguinte comando:
    
**Exemplo:**
    ```{r, engine="sh", eval=FALSE}
cat ~/.ssh/id_rsa.pub

A chave está no arquivo id_rsa.pub. O usuário deve copiar o texto deste arquivo na íntegra. Para gerar a conexão ssh com o servidor, deve visitar o site https://gitlab.c3sl.ufpr.br/profile/keys e clicar em Add SSH Key. É necessário escrever um título para a sua nova chave, no campo key colar o texto copiado do arquivo id_rsa.pub e adicionar sua nova chave.

Para checar a configuração da sua máquina com o sevidor basta realizar o seguinte comando:

Exemplo: ```{r, engine="sh", eval=FALSE} ssh -T git@gitlab.c3sl.ufpr.br

 
 
**Configurando o servidor** 
 
Agora será abordado como configurar o acesso SSH do ponto de vista do servidor.
Você precisa criar um usuário Git e um diretório `.ssh` para este usuário.

**Exemplo:** criar usuário e diretório.
    ```{r, engine="sh", eval=FALSE}
sudo adduser git
su git
cd
mkdir .ssh

Agora, você terá um arquivo chamado authorized_keys onde será adicionado uma chave pública de algum desenvolvedor. Após obter chaves de alguns usuários, você pode salvá-las no arquivo authorized_keys, como no exemplo a seguir.

Exemplo:

cat /tmp/id_rsa1.pub >> ~/.ssh/authorized_keys # chave do primeiro usuário 
cat /tmp/id_rsa2.pub >> ~/.ssh/authorized_keys # chave do segundo usuário
...

Depois de armazenar as chaves dos usuários, basta criar um repositório limpo (sem um diretório de trabalho) para eles. Como visto anteriormente:

Exemplo:

cd/dir/git
mkdir NovoProjeto.git
cd NovoProjeto.git
git –bare init

Agora os usuários, cujas chaves foram salvas no arquivo authorized_keys podem compartilhar arquivos no repositório com os comando git init, git add, git commit, git remote add e git push origin master.

Comandos clone, push, pull e fetch

Git clone

Este comando é usado para clonar um repositório do servidor remoto para um servidor local, caso você queira copiar um repositório que já existe para realizar colaborações em um projeto que queira participar. Você terá acesso a todos os arquivos e poderá verificar as diferentes versões destes. No exemplo abaixo temos uma bibliotaca Git, chamada TesteClone, que será clonado da seguinte forma:

Exemplo: ```{r, engine="sh", eval=FALSE} git clone git@gitlab.c3sl.ufpr.br:pet-estatistica/TesteClone.git

Desta forma você terá um diretório `TesteClone` em seu computador, onde estarão todos os arquivos do projeto nele.

Você também terá a opção de clonar o repositório `TesteClone` em um diretório diferente do padrão Git, que no próximo exemplo denominaremos de `DirTeste`:
    
**Exemplo:**
    ```{r, engine="sh", eval=FALSE}
git clone git@gitlab.c3sl.ufpr.br:pet-estatistica/TesteClone.git DirTeste

Git Push

Usado para transferência de arquivos entre repositório local e o servidor remoto. Como o nome já diz, o comando empurra os arquivos para o servidor remoto. No exemplo abaixo enviaremos a ramificação Branch Master para o servidor chamado origin:

Exemplo: ```{r, engine="sh", eval=FALSE} git push origin master

É importante ressaltar que se dois usuários clonarem ao mesmo tempo, realizarem modificações e enviarem os arquivos atualizados ao repositório utilizando o `Git push`, as modificações do usuário que realizou o push por último serão desconsideradas. 

### Git Pull

Também utilizado para transferência de arquivos. O comando puxa os arquivos do servidor remoto para o repositório local e faz o merge do mesmo, fundindo a última versão com a versão atualizada.

**Exemplo:**
    ```{r, engine="sh", eval=FALSE}
git pull origin master

Git fetch

Assim como o comando Git pull, o Git fetch transfere arquivos do repositório remoto para o local, porém ele não realiza automaticamente o merge dos arquivos transferidos, o usuário deve fazer o merge manualmente.

Exemplo: ```{r, engine="sh", eval=FALSE} git fetch origin master

Para verificar as modificações realizadas entre versões de um arquivo basta utilizar o comando `git diff`:
    
**Exemplo:**
```{r, engine="sh", eval=FALSE}
git diff master origin/master