Skip to content
Snippets Groups Projects
Commit cb9dd46b authored by Ângela Luiza Cunha Legey's avatar Ângela Luiza Cunha Legey
Browse files

Merge branch 'issue#62' into 'devel' 

Issue#62

Esse ramo traz contribuições no capítulo 4 - Repositórios Remotos e plano de atividades da semana 7.

See merge request !48
parents 0962e672 13ee0a12
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
cap04.Rmd
+ 357
− 84
View file @ cb9dd46b
--- ---
title: "4. Projetos remotos" title: "Projetos Remotos"
author: "PET Estatística" author: "PET Estatística UFPR"
date: "29/11/2015" graphics: yes
header-includes: \usepackage{menukeys}
output: output:
html_document: pdf_document:
highlight: pygments template: template.tex
highlight: default
toc: true toc: true
theme: flatly toc_depth: 2
keep_md: true keep_tex: true
number_sections: true
--- ---
\chapter{Projetos Remotos}
Nos capítulos anteriores descrevemos como instalar o Git e ter projetos
versionados. No entanto, o uso do Git até então foi apenas local. Os
arquivos eram mantidos na sua máquina de trabalho e disponíveis só para
você.
## Introdução Os recursos do Git, como o desenvolvimento em *branches*, permite que
vários segmentos sejam conduzidos de forma independente e no futuro,
quando apropriado, reunidos em um único *branch*. Isso é exatamente o
que precisamos para trabalhar em equipe, certo? Se cada colaborador
pudesse ter um ramo separado do projeto para trabalhar, todos poderiam
trabalhar simultâneamente. Quando oportuno, bastaria fazer merges para
reunir o trabalho. A questão é: como deixar o projeto disponível para os
colaboradores?
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. A resposta é simples: mantenha o projeto em um servidor onde os
colaboradores tenham acesso. Isso inclusive vai permitir que você acesse
o projeto de várias outras máquinas, como o *notebook* de casa e o
desktop do *escritório*.
Primeiramente será apresentado o comando `git remote`, este é usado para verificar quais repositórios estão configurados. ## Repositório remoto pessoal
O repositório remoto serve de centro do seu repositório Git. Como ele
está em um servidor que você tem acesso, você pode compartilhar o
repositório com outras máquinas, clonado de lá. Ele serve como *backup*
do repositório.
Aqui não se trabalha em colaboração mas o processo permite acessar o
repositório, transferir arquivos de várias máquinas suas.
```{r, engine="bash", eval=FALSE}
## Autenticar no servidor (logar).
ssh eu@servidor
## Verificar se a máquina tem o Git, se não instalar.
git --version
## Criar um diretório para conter o projeto.
mkdir -p ~/meusProjetos/meu1repo
cd ~/meusProjetos/meu1repo
## Começar um projeto Git remoto. Note a opção --bare.
git --bare init
```
Apenas isso precisa ser feito no servidor. Você não cria nenhum arquivo
pelo servidor. Inclusive, muitos dos comandos Git, como `git status` não
funcionam para repositório iniciados com a opção `git --bare init`.
Caso queira, você também pode usar `git init`. A diferença entre eles é
só onde ficam os arquivos do versionamento. Com `git init`, um diretório
oculto `.git/` é o repositório Git e os arquivos de trabalho, como o
`README.md`, ficam ao lado dele na estrutura de diretório. Com `git
--bare init` o conteúdo do repositório Git fica na raíz. Essa última
opção é justamente para criar repositórios remotos que vão justamente
manter a parte repositório e não os arquivos.
\begin{verbatim}
git init git --bare init
. .
|-- .git |-- branches
| |-- branches |-- config
| |-- config |-- description
| |-- description |-- HEAD
| |-- HEAD |-- hooks
| |-- hooks |-- info
| |-- info |-- objects
| |-- objects +-- refs
| +-- refs
+-- README.md
\end{verbatim}
Uma vez iniciado o repositório no servidor, todo trabalho passa ser
local. É a vez de adicionar o endereço do diretório no servidor e
transferir arquivos.
```{r, engine="bash", eval=FALSE}
## Agora na sua máquina local, adicione o endereço do remoto.
git remote add eu@server:~/meusProjetos/meu1repo
## Exibir os endereços remotos.
git remote -v
```
Esse endereço pode ter IP, porque na realidade, todo servidor tem um
IP. Por exemplo, o servidor do <github.com> tem o IP
192.30.252.129. Para saber o IP é só dar um *ping* no endereço.
```{r, engine="bash", eval=FALSE}
ping github.com
ping gitlab.com
ping google.com
ping cran.r-project.org
```
Normalmente, servidores de escritório não tem um endereço nominal,
apenas o IP (numérico). É necessário registrar domínio para ter
nominal.
```{r, engine="bash", eval=FALSE}
## Agora na sua máquina local, adicione o endereço do remoto.
git remote add eu@111.22.333.44:~/meusProjetos/meu1repo
```
Nesse processo, toda transferência de arquivos vai pedir senha do seu
usuário no servidor. Para facilitar, pode-se trabalhar com chaves
públicas.
O arquivo `id_rsa.pub` é a sua chave pública. O `id_rsa` é o seu
par. RSA é o tipo de encriptação. O nome e caminho do arquivo e a
encriptação podem ser outros, depende do que você escolher ao gerar o
par de chaves. Normalmente usa-se RSA e as chaves são criadas no
diretório `~/.ssh`.
```{r, engine="bash", eval=FALSE}
## Exibir chaves públicas.
cat ~/.ssh/id_rsa.pub
## Caso não tenha, gerar.
ssh-keygen -t rsa -C "eu@dominio.com"
```
No servidor, o arquivo `authorized_keys2` contém as chaves públicas das
máquinas com acesso permitido sem senha. Esse arquivo nada mais é que
uma coleção de chaves. O conteúdo dele são as chaves das suas máquinas,
ou das máquinas de outros usuários, conteúdo do `id_rsa.pub`, uma
embaixo da outra, conforme o exemplo abaixo\footnote{O Flash foi o
primeiro a transferir as chaves para o servidor porque ele é mais
rápido}.
```{r, engine="bash", eval=FALSE}
## `authorized_keys` do servidor da Liga da Justiça.
ssh-rsa IyBUrjvUdSMY... flash@justiceleague.org
ssh-rsa AAAAB3NzaC1y... batman@justiceleague.org
ssh-rsa Mdju17IdXhSd... superman@justiceleague.org
```
```{r, engine="bash", eval=FALSE}
## Logar no servidor
ssh eu@111.22.333.44
## Criar o diretório/arquivo para as chaves públicas.
mkdir ~/.ssh
> authorized_keys2
```
Agora é preciso transferir o conteúdo do seu arquivo local `id_rsa.pub`
para o `authorized_keys2` que fica no servidor. O jeito mais simples de
fazer isso é com transferência *scp* mas a instrução *ssh* abaixo também
resolve.
```{r, engine="bash", eval=FALSE}
## Transfere arquivo para diretório temporário.
scp ~/.ssh/id_rsa.pub eu@111.22.333.44:/tmp
## Cola o conteúdo do *.pub no final do authorized_keys.
ssh eu@111.22.333.44\
"cat /tmp/id_rsa.pub ~/.ssh/authorized_keys"
## Faz os dois passos anteriores de uma vez só.
ssh eu@111.22.333.44\
"cat >> ~/.ssh/authorized_keys2" < ~/.ssh/id_rsa.pub
```
## Repositório remoto coletivo
A única diferença é recomendamos você criar um novo usuário e adicionar
as chaves públicas de todos os membros. Evite adicionar chaves públicas
para usuários na sua conta porque isso expõe seus documentos, alguma
operação desastrosa por parte de alguém pode comprometê-los. Por isso,
crie um usuário, por exemplo `gitusers`, para na conta manter o
repositório remoto.
Solicite que os colaboradores gerem as chaves públicas e te enviem o
arquivo `id_rsa.pub`. Depois você adiciona cada chave ao
`authorized_keys` da conta `gitusers`. Com chaves autorizadas, os
colaboradores podem transferir arquivos, podem logar no servidor mas
não podem instalar nada, a menos que você passe a senha do usuário
`gitusers`. Para crias usuários no servidor, você precisa de
privilégios de *admin*.
```{r, engine="bash", eval=FALSE}
## Logar na servidora.
ssh eu@servidor
## No servidor, criar uma conta para o projeto.
sudo adduser gitusers
```
Vamos assumir que você têm os arquivos `*.pub` dos colaboradores no
diretório `/chaves` devidamente identificados pelo nome deles. O comando
abaixo acrescenta as chaves deles uma embaixo da outra no
`authorized_keys`.
```{r, engine="bash", eval=FALSE}
## Entra no diretório com os arquivos *.pub.
## Existem várias: angela.pub, jhenifer.pub, ...
cd chaves
## Juntar as chaves em um único arquivo.
cat *.pub > todos.pub
## Copiar o conteúdo do arquivo pro authorized_keys2.
ssh gitusers@111.22.333.44\
"cat >> ~/.ssh/authorized_keys2" < todos.pub
```
A fazer:
1. Fluxo de trabalho com repositório remoto, do *clone* ao *push*;
2. Listar branches locais/remotos;
3. Adicionar *remote*, renomear, deletar;
4. Adicionar mais de uma url para o mesmo *origin*;
5. Deletar ramos no servidor;
6. Clonar apenas um *branch*, *commit* ou *tag*.
<!---------------------------------------------------------------------- -->
# 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: **Exemplo:** para retornar a lista de repositórios:
```{r, engine="bash", echo=TRUE} ```{r, engine="bash", eval=FALSE}
git remote git remote
``` ```
No comando acima é possível visualizar o remoto padrão **origin** (URL SSH para onde será possível enviar os seus arquivos). 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: **Exemplo:** para retornar o nome dos repositórios com a URL onde foram
armazanados:
```{r, engine="bash", echo=TRUE} ```{r, engine="bash", echo=TRUE, eval=FALSE}
git remote -v git remote -v
``` ```
## Adicionando repositórios remotos ##
### 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á
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**. vinculado a URL
`git@gitlab.c3sl.ufpr.br:pet-estatistica/apostila-git.git`. Usaremos
como exemplo o projeto Git **Apostila-git**.
**Exemplo:** **Exemplo:**
```{r, engine="bash", echo=TRUE} ```{r, engine="bash", echo=TRUE, eval=FALSE}
git remote add MeuRepo git@gitlab.c3sl.ufpr.br:pet-estatistica/apostila-git.git 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: # Quando executamos novamente o comando para obter a lista de repositórios:
git remote -v git remote -v
``` ```
Pare acessar localmente o branch master do projeto **Apostila-git** será usado `MeuRepo/master`. Pare acessar localmente o branch master do projeto **Apostila-git** será
usado `MeuRepo/master`.
### Obtendo informações de um Remoto ## 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`. 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:** **Exemplo:**
```{r, engine="bash", echo=TRUE} ```{r, engine="bash", echo=TRUE, eval=FALSE}
git remote show origin git remote show origin
``` ```
### Renomeado Remotos ## Renomeado Remotos ##
O comando `git remote rename` pode modificar o nome de um repositório remoto. A seguir o repositório `MeuRepo`será renomeado para `RenameRepo`. O comando `git remote rename` pode modificar o nome de um repositório
remoto. A seguir o repositório `MeuRepo`será renomeado para
`RenameRepo`.
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
git remote rename MeuRepo RenameRepo git remote rename MeuRepo RenameRepo
``` ```
### Removendo Remotos ## Removendo Remotos ##
Para remover remotos é utilizado o comando `git remote rm`, agora será removido o repositório renomeado anteriormente `RenameRepo`. Para remover remotos é utilizado o comando `git remote rm`, agora será
removido o repositório renomeado anteriormente `RenameRepo`.
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
git remote rm RenameRepo git remote rm RenameRepo
``` ```
...@@ -77,12 +310,17 @@ Para remover remotos é utilizado o comando `git remote rm`, agora será removid ...@@ -77,12 +310,17 @@ Para remover remotos é utilizado o comando `git remote rm`, agora será removid
Há quatro tipos diferentes de protocolos Git (Local, Git, HTTP e SSH). 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. 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 # 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. Primeiramente é necessário ter acesso a um servidor Linux com chave SSH,
No próximo exemplo é preciso criar um repositório remoto chamado `MeuRepo` e o armazenar em um diretório `~/git`: 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:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="sh", eval=FALSE}
...@@ -94,39 +332,47 @@ mkdir MeuRepo.git ...@@ -94,39 +332,47 @@ mkdir MeuRepo.git
git --bare init 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. 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 #
## Git no servidor Primeiramente, para configurar o Git no Servidor e configurar os
protocolos, clonaremos o repositório existente em um repositório limpo.
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
**Observação:** você poderá colocar um repositório no Servidor se este não contém um diretório de trabalho. não contém um diretório de trabalho.
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
git clone --bare MeuRepo MeuRepo.git 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. 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. Após este primeiro passo o repositório limpo será colocado no Servidor e
No exemplo abaixo, supondo que você tem configurado um servidor `git.servidor.com`, e um diretório `/dir/git`no qual você quer armazenar seus repositórios. Ao copiar o seu repositório limpo, você pode configurar seu novo repositório. configurado os protolocos. No exemplo abaixo, supondo que você tem
configurado um servidor `git.servidor.com`, e um diretório `/dir/git`no
qual você quer armazenar seus repositórios. Ao copiar o seu repositório
limpo, você pode configurar seu novo repositório.
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="sh", eval=FALSE}
scp -r MeuRepo.git usuario@git.example.com:/dir/git 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. 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} ```{r, engine="bash", eval=FALSE}
git clone usuario@git.example.com:/dir/git/MeuRepo.git git clone usuario@git.example.com:/dir/git/MeuRepo.git
``` ```
# Configuração de Conexão SSH com Servidor #
## 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
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: comando no terminal:
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="sh", eval=FALSE}
...@@ -134,42 +380,49 @@ O Git possibilita ao usuário realizar uma chave SSH que fará uma conexão segu ...@@ -134,42 +380,49 @@ O Git possibilita ao usuário realizar uma chave SSH que fará uma conexão segu
ssh-keygen -t rsa -C "usuario@email.com" 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 deste comando, será possível alterar o diretório onde será
A partir disso, são criados dois arquivos no diretório, o `id_rsa` e o `id_rsa.pub`. salva a chave SSH. O usuário tem a opção de permanecer com o diretório
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. 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: Para visualizar a chave basta digitar o seguinte comando:
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
cat ~/.ssh/id_rsa.pub cat ~/.ssh/id_rsa.pub
``` ```
A chave está no arquivo `id_rsa.pub`. O usuário deve copiar o texto deste arquivo na íntegra. 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](https://gitlab.c3sl.ufpr.br/profile/keys) e clicar em [Add SSH Key](https://gitlab.c3sl.ufpr.br/profile/keys/new). É 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 gerar a conexão ssh com o servidor, deve visitar o site [https://gitlab.c3sl.ufpr.br/profile/keys](https://gitlab.c3sl.ufpr.br/profile/keys) e clicar em [Add SSH Key](https://gitlab.c3sl.ufpr.br/profile/keys/new). É 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: Para checar a configuração da sua máquina com o sevidor basta realizar o
seguinte comando:
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
ssh -T git@gitlab.c3sl.ufpr.br ssh -T git@gitlab.c3sl.ufpr.br
``` ```
**Configurando o servidor** **Configurando o servidor**
Agora será abordado como configurar o acesso SSH do ponto de vista do servidor. Agora será abordado como configurar o acesso SSH do ponto de vista do
Você precisa criar um usuário Git e um diretório `.ssh` para este usuário. servidor. Você precisa criar um usuário Git e um diretório `.ssh` para
este usuário.
**Exemplo:** criar usuário e diretório. **Exemplo:** criar usuário e diretório.
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
sudo adduser git sudo adduser git
su git su git
cd cd
mkdir .ssh 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. 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:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="sh", eval=FALSE}
...@@ -178,76 +431,96 @@ cat /tmp/id_rsa2.pub >> ~/.ssh/authorized_keys # chave do segundo usuário ...@@ -178,76 +431,96 @@ 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: 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:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="sh", eval=FALSE}
cd/dir/git cd/dir/git
mkdir NovoProjeto.git mkdir NovoProjeto.git
cd NovoProjeto.git cd NovoProjeto.git
git –bare init 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`. 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 #
## Comandos clone, push, pull e fetch ## Git clone ##
### 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
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. para realizar colaborações em um projeto que queira participar. Você
Você terá acesso a todos os arquivos e poderá verificar as diferentes versões destes. terá acesso a todos os arquivos e poderá verificar as diferentes versões
No exemplo abaixo temos uma bibliotaca Git, chamada **TesteClone**, que será clonado da seguinte forma: destes. No exemplo abaixo temos uma bibliotaca Git, chamada
**TesteClone**, que será clonado da seguinte forma:
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="sh", eval=FALSE}
git clone git@gitlab.c3sl.ufpr.br:pet-estatistica/TesteClone.git 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. 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`: 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:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
git clone git@gitlab.c3sl.ufpr.br:pet-estatistica/TesteClone.git DirTeste git clone git@gitlab.c3sl.ufpr.br:pet-estatistica/TesteClone.git DirTeste
``` ```
## Git Push ##
### 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
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. o servidor remoto. No exemplo abaixo enviaremos a ramificação `Branch
No exemplo abaixo enviaremos a ramificação `Branch Master` para o servidor chamado `origin`: Master` para o servidor chamado `origin`:
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
git push origin master 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. É 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 ## 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. 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:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
git pull origin master git pull origin master
``` ```
### Git fetch ## 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. 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:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
git fetch origin master git fetch origin master
``` ```
Para verificar as modificações realizadas entre versões de um arquivo basta utilizar o comando `git diff`: Para verificar as modificações realizadas entre versões de um arquivo
basta utilizar o comando `git diff`:
**Exemplo:** **Exemplo:**
```{r, engine="sh", eval=FALSE} ```{r, engine="bash", eval=FALSE}
git diff master origin/master git diff master origin/master
``` ```
......
plano.md
+ 12
− 1
View file @ cb9dd46b
...@@ -171,5 +171,16 @@ ...@@ -171,5 +171,16 @@
+ Quem se interessar: Pensar numa capa para a apostila, fazer esboço, + Quem se interessar: Pensar numa capa para a apostila, fazer esboço,
*brainstorm*. *brainstorm*.
7. 2015-12-08: 7. 2015-12-08:
+ Alcides: Terminar de corrigir o cap 5 (**pendencia**) e colocar o
dicionário de termos em um ambiente LaTex apropriado.
+ Alessandra: Fazer adequações no capítulo 4 e depois de sexta
corrigir o capítulo 6.
+ Ângela: Corrigir o capítulo de RStudio.
+ Daniel: Concluir todas as **pendências** (RStudio e *Cheat Sheet*),
disponibilizar o capítulo de RStudio o quanto antes para Ângela.
+ Eduardo: Expandir o exemplo de rotinas e depois de sexta corrigir o
capítulo 3.
+ Jhenifer: Concluir correção no capítulo 6 (**pendencia**).
+ Gabriel: Disponibilizar o capítulo 3 para o Eduardo até sexta.
+ Walmes: Juntar todos os capítulos e gerar a Apostila Git.
8. 2015-12-15: Apostila Git concluída! 8. 2015-12-15: Apostila Git concluída!
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment