diff --git a/cap04.Rmd b/cap04.Rmd
index b170c98d268af30d8cbf0492bf529b7a33d7758b..da1d94e091fe96328b5e126c0f73f7466fcc8bf2 100644
--- a/cap04.Rmd
+++ b/cap04.Rmd
@@ -34,7 +34,7 @@ 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*.
 
-## Repositório remoto pessoal
+# 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
@@ -178,7 +178,7 @@ ssh eu@111.22.333.44\
   "cat >> ~/.ssh/authorized_keys2" < ~/.ssh/id_rsa.pub
 ```
 
-## Repositório remoto coletivo
+# 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
@@ -221,24 +221,90 @@ 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*.
 
-<!---------------------------------------------------------------------- -->
+# Fluxo de trabalho com repositório remoto, do clone ao push 
 
-# Introdução #
+## Git clone 
 
-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.
+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.  Supondo que sua equipe de trabalho possue uma biblioteca Git **Teste Clone**, onde são armazenados todos os arquivos. Você pode clonar estes arquivos para o seu diretório de trabalho e assim modificá-los conforme deseja.
+
+
+**Exemplo:**
+```{r, engine="bash", 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="bash", eval=FALSE}
+git clone git@gitlab.c3sl.ufpr.br:pet-estatistica/TesteClone.git DirTeste
+```
+
+## Git Push 
+
+Após clonar e realizar contribuições ao projeto, você pode enviá-los para o repositório remoto. Estes arquivos, após o `Git push`, estarão prontos para serem integrados ao projeto com o `merge`.  
+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="bash", 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.
 
-Primeiramente será apresentado o comando `git remote`, este é usado para
+## Git Pull 
+
+Para obter todos os arquivos presentes no projeto, você pode importar os arquivos do branch `master`.
+Toda vez que você utilizar o `Git pull` a última versão de todos os arquivos estarão no seu diretório.
+Este comando é 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="bash", 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="bash", 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="bash", eval=FALSE}
+git diff master origin/master
+```
+
+
+# Listar branches locais/remotos
+  
+O comando `git remote`, este é usado para
 verificar quais repositórios estão configurados.
 
 **Exemplo:** para retornar a lista de repositórios:
@@ -257,7 +323,10 @@ armazanados:
 git remote -v
 ```
 
-## Adicionando repositórios remotos ##
+
+# Adicionar, renomear, deletar remote
+  
+## 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á
@@ -275,7 +344,7 @@ git remote -v
 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`.
@@ -285,7 +354,7 @@ comando `git remote show`, que retornará a URL e os `branches`.
 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
@@ -296,7 +365,7 @@ remoto. A seguir o repositório `MeuRepo`será renomeado para
 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`.
@@ -306,13 +375,36 @@ removido o repositório renomeado anteriormente `RenameRepo`.
  git remote rm RenameRepo
 ```
 
-**Protocolos Git**
+## Deletar ramos no servidor
 
-Há quatro tipos diferentes de protocolos Git (Local, Git, HTTP e SSH).
+Quando houver um branch que não está sendo utilizado ou está concluído, há a opção de excluí-lo do servidor.  
+Se for necessário apagar branches remotos, podemos utilizar o comando a seguir:
+
+**Exemplo:**
+```{r, engine="bash", eval=FALSE}
+git push origin --delete <branch>
+```
+
+
+## Clonar apenas um *branch*, *commit* ou *tag*.
+
+É possível clonar apenas um branch e não o repositório Git completo. Supondo que no repositório há um branch chamado `MeuBranch` dentro do repositório `MeuRepo`, clonaremos o branch. 
+
+**Exemplo:**
+```{r, engine="bash", eval=FALSE}
+git clone -b MeuBranch --single-branch git://sub.domain.com/MeuRepo.git
+```
+
+O Git ainda permite clonar um commit ou tag.
+
+**Exemplo:**
+```{r, engine="bash", eval=FALSE}
+# Para uma tag:
+git -e: //git.myproject.org/MyProject.git@v1.0#egg=MyProject
+# Para um commit:
+git -e: //git.myproject.org/MyProject.git@da39a3ee5e6b4b0d3255bfef95601890afd80709#egg=MyProject
+```
 
-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 #
     
@@ -323,7 +415,7 @@ criar um repositório remoto chamado `MeuRepo` e o armazenar em um
 diretório `~/git`:
     
 **Exemplo:**
-    ```{r, engine="sh", eval=FALSE}
+```{r, engine="bash", eval=FALSE}
 # Para criar um diretório git na sua home:
 mkdir ~/git
 # Para criar um repositório git:
@@ -357,7 +449,7 @@ 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}
+```{r, engine="bash", eval=FALSE}
 scp -r MeuRepo.git usuario@git.example.com:/dir/git
 ```
 
@@ -375,7 +467,7 @@ segura da sua máquina com o servidor. Para isso começamos com o seguinte
 comando no terminal:
     
 **Exemplo:**
-    ```{r, engine="sh", eval=FALSE}
+```{r, engine="bash", eval=FALSE}
 ## Gerando uma chave ssh
 ssh-keygen -t rsa -C "usuario@email.com"
 ```
@@ -425,9 +517,11 @@ de alguns usuários, você pode salvá-las no arquivo `authorized_keys`,
 como no exemplo a seguir.
 
 **Exemplo:**
-```{r, engine="sh", eval=FALSE}
-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
+```{r, engine="bash", eval=FALSE}
+# chave do primeiro usuário
+cat /tmp/id_rsa1.pub >> ~/.ssh/authorized_keys
+# chave do segundo usuário
+cat /tmp/id_rsa2.pub >> ~/.ssh/authorized_keys
 ...
 ```
 
@@ -436,7 +530,7 @@ limpo (sem um diretório de trabalho) para eles. Como visto
 anteriormente:
 
 **Exemplo:**
-```{r, engine="sh", eval=FALSE}
+```{r, engine="bash", eval=FALSE}
 cd/dir/git
 mkdir NovoProjeto.git
 cd NovoProjeto.git
@@ -448,80 +542,3 @@ Agora os usuários, cujas chaves foram salvas no arquivo
 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="bash", 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="bash", 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="bash", 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="bash", 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="bash", eval=FALSE}
-git diff master origin/master
-```
-
-
diff --git a/cap04.pdf b/cap04.pdf
new file mode 100644
index 0000000000000000000000000000000000000000..db28b3e844fa029f721f66b304bbf8f11b26a1b6
Binary files /dev/null and b/cap04.pdf differ
diff --git a/cap04.tex b/cap04.tex
new file mode 100644
index 0000000000000000000000000000000000000000..741ec52bb06381e641b5ecc0ee3aec285b10d922
--- /dev/null
+++ b/cap04.tex
@@ -0,0 +1,805 @@
+% \documentclass[
+%   ]{article}
+
+\documentclass[
+  a5paper,
+  pagesize,
+  9pt,
+  % bibtotoc,
+  pointlessnumbers,
+  normalheadings,
+  % DIV=9,
+  twoside=false
+]{book}
+
+\usepackage[brazil]{babel}
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+
+\usepackage[sc]{mathpazo}
+% \usepackage{palatino}
+% \linespread{1.05} 
+\usepackage[scaled=0.85]{beramono}
+
+%-----------------------------------------------------------------------
+
+\usepackage{amssymb, amsmath}
+\usepackage{ifxetex, ifluatex}
+
+\usepackage{fixltx2e} % provides \textsubscript
+\ifnum 0\ifxetex 1\fi\ifluatex 1\fi=0 % if pdftex
+  \usepackage[T1]{fontenc}
+  \usepackage[utf8]{inputenc}
+\else % if luatex or xelatex
+  \ifxetex
+    \usepackage{mathspec}
+    \usepackage{xltxtra,xunicode}
+  \else
+    \usepackage{fontspec}
+  \fi
+  \defaultfontfeatures{Mapping=tex-text,Scale=MatchLowercase}
+  \newcommand{\euro}{€}
+\fi
+
+% use upquote if available, for straight quotes in verbatim environments
+\IfFileExists{upquote.sty}{\usepackage{upquote}}{}
+% use microtype if available
+\IfFileExists{microtype.sty}{%
+\usepackage{microtype}
+\UseMicrotypeSet[protrusion]{basicmath} % disable protrusion for tt fonts
+}{}
+
+
+
+
+
+
+\usepackage{color}
+\usepackage{fancyvrb}
+\newcommand{\VerbBar}{|}
+\newcommand{\VERB}{\Verb[commandchars=\\\{\}]}
+\DefineVerbatimEnvironment{Highlighting}{Verbatim}{commandchars=\\\{\}}
+% Add ',fontsize=\small' for more characters per line
+\usepackage{framed}
+\definecolor{shadecolor}{RGB}{248,248,248}
+\newenvironment{Shaded}{\begin{snugshade}}{\end{snugshade}}
+\newcommand{\KeywordTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{\textbf{{#1}}}}
+\newcommand{\DataTypeTok}[1]{\textcolor[rgb]{0.13,0.29,0.53}{{#1}}}
+\newcommand{\DecValTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{{#1}}}
+\newcommand{\BaseNTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{{#1}}}
+\newcommand{\FloatTok}[1]{\textcolor[rgb]{0.00,0.00,0.81}{{#1}}}
+\newcommand{\CharTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{{#1}}}
+\newcommand{\StringTok}[1]{\textcolor[rgb]{0.31,0.60,0.02}{{#1}}}
+\newcommand{\CommentTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{\textit{{#1}}}}
+\newcommand{\OtherTok}[1]{\textcolor[rgb]{0.56,0.35,0.01}{{#1}}}
+\newcommand{\AlertTok}[1]{\textcolor[rgb]{0.94,0.16,0.16}{{#1}}}
+\newcommand{\FunctionTok}[1]{\textcolor[rgb]{0.00,0.00,0.00}{{#1}}}
+\newcommand{\RegionMarkerTok}[1]{{#1}}
+\newcommand{\ErrorTok}[1]{\textbf{{#1}}}
+\newcommand{\NormalTok}[1]{{#1}}
+
+
+
+\usepackage{graphicx}
+\makeatletter
+\def\maxwidth{\ifdim\Gin@nat@width>\linewidth\linewidth\else\Gin@nat@width\fi}
+\def\maxheight{\ifdim\Gin@nat@height>\textheight\textheight\else\Gin@nat@height\fi}
+\makeatother
+% Scale images if necessary, so that they will not overflow the page
+% margins by default, and it is still possible to overwrite the defaults
+% using explicit options in \includegraphics[width, height, ...]{}
+\setkeys{Gin}{width=\maxwidth,height=\maxheight,keepaspectratio}
+
+\ifxetex
+  \usepackage[setpagesize=false, % page size defined by xetex
+              unicode=false, % unicode breaks when used with xetex
+              xetex]{hyperref}
+\else
+  \usepackage[unicode=true]{hyperref}
+\fi
+
+\hypersetup{breaklinks=true,
+            bookmarks=true,
+            pdfauthor={PET Estatística UFPR},
+            pdftitle={Projetos Remotos},
+            colorlinks=true,
+            citecolor=blue,
+            urlcolor=blue,
+            linkcolor=magenta,
+            pdfborder={0 0 0}}
+\urlstyle{same}  % don't use monospace font for urls
+
+
+
+\setlength{\parindent}{0pt}
+\setlength{\parskip}{6pt plus 2pt minus 1pt}
+\setlength{\emergencystretch}{3em}  % prevent overfull lines
+
+\setcounter{secnumdepth}{5}
+
+
+%%% Use protect on footnotes to avoid problems with footnotes in titles
+\let\rmarkdownfootnote\footnote%
+\def\footnote{\protect\rmarkdownfootnote}
+
+%%% Change title format to be more compact
+\usepackage{titling}
+
+% Create subtitle command for use in maketitle
+\newcommand{\subtitle}[1]{
+  \posttitle{
+    \begin{center}\large#1\end{center}
+    }
+}
+
+\setlength{\droptitle}{-2em}
+
+  \title{Projetos Remotos}
+  \pretitle{\vspace{\droptitle}\centering\huge}
+  \posttitle{\par}
+
+  \author{PET Estatística UFPR}
+  \preauthor{\centering\large\emph}
+  \postauthor{\par}
+
+  \date{}
+  \predate{}\postdate{}
+
+\usepackage{menukeys}
+
+\begin{document}
+
+\maketitle
+
+
+{
+\hypersetup{linkcolor=black}
+\setcounter{tocdepth}{2}
+\tableofcontents
+}
+
+
+
+\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ê.
+
+Os recursos do Git, como o desenvolvimento em \emph{branches}, permite
+que vários segmentos sejam conduzidos de forma independente e no futuro,
+quando apropriado, reunidos em um único \emph{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?
+
+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 \emph{notebook} de casa e o
+desktop do \emph{escritório}.
+
+\section{Repositório remoto pessoal}\label{repositorio-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
+\emph{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.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Autenticar no servidor (logar).}
+\KeywordTok{ssh} \NormalTok{eu@servidor}
+
+\CommentTok{## Verificar se a máquina tem o Git, se não instalar.}
+\KeywordTok{git} \NormalTok{--version}
+
+\CommentTok{## Criar um diretório para conter o projeto.}
+\KeywordTok{mkdir} \NormalTok{-p ~/meusProjetos/meu1repo}
+\KeywordTok{cd} \NormalTok{~/meusProjetos/meu1repo}
+
+\CommentTok{## Começar um projeto Git remoto. Note a opção --bare.}
+\KeywordTok{git} \NormalTok{--bare init}
+\end{Highlighting}
+\end{Shaded}
+
+Apenas isso precisa ser feito no servidor. Você não cria nenhum arquivo
+pelo servidor. Inclusive, muitos dos comandos Git, como
+\texttt{git status} não funcionam para repositório iniciados com a opção
+\texttt{git -\/-bare init}.
+
+Caso queira, você também pode usar \texttt{git init}. A diferença entre
+eles é só onde ficam os arquivos do versionamento. Com
+\texttt{git init}, um diretório oculto \texttt{.git/} é o repositório
+Git e os arquivos de trabalho, como o \texttt{README.md}, ficam ao lado
+dele na estrutura de diretório. Com \texttt{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.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Agora na sua máquina local, adicione o endereço do remoto.}
+\KeywordTok{git} \NormalTok{remote add eu@server:~/meusProjetos/meu1repo}
+
+\CommentTok{## Exibir os endereços remotos.}
+\KeywordTok{git} \NormalTok{remote -v}
+\end{Highlighting}
+\end{Shaded}
+
+Esse endereço pode ter IP, porque na realidade, todo servidor tem um IP.
+Por exemplo, o servidor do tem o IP 192.30.252.129. Para saber o IP é só
+dar um \emph{ping} no endereço.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{ping} \NormalTok{github.com}
+\KeywordTok{ping} \NormalTok{gitlab.com}
+\KeywordTok{ping} \NormalTok{google.com}
+\KeywordTok{ping} \NormalTok{cran.r-project.org}
+\end{Highlighting}
+\end{Shaded}
+
+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.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Agora na sua máquina local, adicione o endereço do remoto.}
+\KeywordTok{git} \NormalTok{remote add eu@111.22.333.44:~/meusProjetos/meu1repo}
+\end{Highlighting}
+\end{Shaded}
+
+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 \texttt{id\_rsa.pub} é a sua chave pública. O \texttt{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 \texttt{\textasciitilde{}/.ssh}.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Exibir chaves públicas.}
+\KeywordTok{cat} \NormalTok{~/.ssh/id_rsa.pub}
+
+\CommentTok{## Caso não tenha, gerar.}
+\KeywordTok{ssh-keygen} \NormalTok{-t rsa -C }\StringTok{"eu@dominio.com"}
+\end{Highlighting}
+\end{Shaded}
+
+No servidor, o arquivo \texttt{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
+\texttt{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}.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## `authorized_keys` do servidor da Liga da Justiça.}
+\KeywordTok{ssh-rsa} \NormalTok{IyBUrjvUdSMY... flash@justiceleague.org}
+\KeywordTok{ssh-rsa} \NormalTok{AAAAB3NzaC1y... batman@justiceleague.org}
+\KeywordTok{ssh-rsa} \NormalTok{Mdju17IdXhSd... superman@justiceleague.org}
+\end{Highlighting}
+\end{Shaded}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Logar no servidor}
+\KeywordTok{ssh} \NormalTok{eu@111.22.333.44}
+
+\CommentTok{## Criar o diretório/arquivo para as chaves públicas.}
+\KeywordTok{mkdir} \NormalTok{~/.ssh}
+ \KeywordTok{>} \KeywordTok{authorized_keys2}
+\end{Highlighting}
+\end{Shaded}
+
+Agora é preciso transferir o conteúdo do seu arquivo local
+\texttt{id\_rsa.pub} para o \texttt{authorized\_keys2} que fica no
+servidor. O jeito mais simples de fazer isso é com transferência
+\emph{scp} mas a instrução \emph{ssh} abaixo também resolve.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Transfere arquivo para diretório temporário.}
+\KeywordTok{scp} \NormalTok{~/.ssh/id_rsa.pub eu@111.22.333.44:/tmp}
+
+\CommentTok{## Cola o conteúdo do *.pub no final do authorized_keys.}
+\KeywordTok{ssh} \NormalTok{eu@111.22.333.44\textbackslash{}}
+  \StringTok{"cat /tmp/id_rsa.pub ~/.ssh/authorized_keys"}
+
+\CommentTok{## Faz os dois passos anteriores de uma vez só.}
+\KeywordTok{ssh} \NormalTok{eu@111.22.333.44\textbackslash{}}
+  \StringTok{"cat >> ~/.ssh/authorized_keys2"} \KeywordTok{<} \NormalTok{~/.ssh/id_rsa.pub}
+\end{Highlighting}
+\end{Shaded}
+
+\section{Repositório remoto coletivo}\label{repositorio-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 \texttt{gitusers}, para na conta manter o
+repositório remoto.
+
+Solicite que os colaboradores gerem as chaves públicas e te enviem o
+arquivo \texttt{id\_rsa.pub}. Depois você adiciona cada chave ao
+\texttt{authorized\_keys} da conta \texttt{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 \texttt{gitusers}. Para crias usuários no servidor, você precisa
+de privilégios de \emph{admin}.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Logar na servidora.}
+\KeywordTok{ssh} \NormalTok{eu@servidor}
+
+\CommentTok{## No servidor, criar uma conta para o projeto.}
+\KeywordTok{sudo} \NormalTok{adduser gitusers}
+\end{Highlighting}
+\end{Shaded}
+
+Vamos assumir que você têm os arquivos \texttt{*.pub} dos colaboradores
+no diretório \texttt{/chaves} devidamente identificados pelo nome deles.
+O comando abaixo acrescenta as chaves deles uma embaixo da outra no
+\texttt{authorized\_keys}.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Entra no diretório com os arquivos *.pub.}
+\CommentTok{## Existem várias: angela.pub, jhenifer.pub, ...}
+\KeywordTok{cd} \NormalTok{chaves}
+
+\CommentTok{## Juntar as chaves em um único arquivo.}
+\KeywordTok{cat} \NormalTok{*.pub }\KeywordTok{>} \NormalTok{todos.pub}
+
+\CommentTok{## Copiar o conteúdo do arquivo pro authorized_keys2.}
+\KeywordTok{ssh} \NormalTok{gitusers@111.22.333.44\textbackslash{}}
+  \StringTok{"cat >> ~/.ssh/authorized_keys2"} \KeywordTok{<} \NormalTok{todos.pub}
+\end{Highlighting}
+\end{Shaded}
+
+\section{Fluxo de trabalho com repositório remoto, do clone ao
+push}\label{fluxo-de-trabalho-com-repositorio-remoto-do-clone-ao-push}
+
+\subsection{Git clone}\label{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. Supondo que sua equipe de trabalho possue uma biblioteca Git
+\textbf{Teste Clone}, onde são armazenados todos os arquivos. Você pode
+clonar estes arquivos para o seu diretório de trabalho e assim
+modificá-los conforme deseja.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{clone git@gitlab.c3sl.ufpr.br:pet-estatistica/TesteClone.git}
+\end{Highlighting}
+\end{Shaded}
+
+Desta forma você terá um diretório \texttt{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 \texttt{TesteClone} em
+um diretório diferente do padrão Git, que no próximo exemplo
+denominaremos de \texttt{DirTeste}:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{clone git@gitlab.c3sl.ufpr.br:pet-estatistica/TesteClone.git DirTeste}
+\end{Highlighting}
+\end{Shaded}
+
+\subsection{Git Push}\label{git-push}
+
+Após clonar e realizar contribuições ao projeto, você pode enviá-los
+para o repositório remoto. Estes arquivos, após o \texttt{Git push},
+estarão prontos para serem integrados ao projeto com o
+\texttt{merge}.\\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 \texttt{Branch Master} para o servidor chamado
+\texttt{origin}:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{push origin master}
+\end{Highlighting}
+\end{Shaded}
+
+É importante ressaltar que se dois usuários clonarem ao mesmo tempo,
+realizarem modificações e enviarem os arquivos atualizados ao
+repositório utilizando o \texttt{Git push}, as modificações do usuário
+que realizou o push por último serão desconsideradas.
+
+\subsection{Git Pull}\label{git-pull}
+
+Para obter todos os arquivos presentes no projeto, você pode importar os
+arquivos do branch \texttt{master}. Toda vez que você utilizar o
+\texttt{Git pull} a última versão de todos os arquivos estarão no seu
+diretório. Este comando é 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.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{pull origin master}
+\end{Highlighting}
+\end{Shaded}
+
+\subsection{Git fetch}\label{git-fetch}
+
+Assim como o comando \texttt{Git pull}, o \texttt{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.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{fetch origin master}
+\end{Highlighting}
+\end{Shaded}
+
+Para verificar as modificações realizadas entre versões de um arquivo
+basta utilizar o comando \texttt{git diff}:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{diff master origin/master}
+\end{Highlighting}
+\end{Shaded}
+
+\section{Listar branches
+locais/remotos}\label{listar-branches-locaisremotos}
+
+O comando \texttt{git remote}, este é usado para verificar quais
+repositórios estão configurados.
+
+\textbf{Exemplo:} para retornar a lista de repositórios:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{remote}
+\end{Highlighting}
+\end{Shaded}
+
+No comando acima é possível visualizar o remoto padrão \textbf{origin}
+(URL SSH para onde será possível enviar os seus arquivos).
+
+\textbf{Exemplo:} para retornar o nome dos repositórios com a URL onde
+foram armazanados:
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{remote -v}
+\end{Highlighting}
+\end{Shaded}
+
+\section{Adicionar, renomear, deletar
+remote}\label{adicionar-renomear-deletar-remote}
+
+\subsection{Adicionando repositórios
+remotos}\label{adicionando-repositorios-remotos}
+
+O comando \texttt{git remote add} adiciona um repositório remoto. No
+exemplo a seguir será adicionado um repositório chamado \textbf{MeuRepo}
+ao qual será vinculado a URL
+\texttt{git@gitlab.c3sl.ufpr.br:pet-estatistica/apostila-git.git}.
+Usaremos como exemplo o projeto Git \textbf{Apostila-git}.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{remote add MeuRepo git@gitlab.c3sl.ufpr.br:pet-estatistica/apostila-git.git}
+\CommentTok{# Quando executamos novamente o comando para obter a lista de repositórios:}
+\KeywordTok{git} \NormalTok{remote -v}
+\end{Highlighting}
+\end{Shaded}
+
+Pare acessar localmente o branch master do projeto \textbf{Apostila-git}
+será usado \texttt{MeuRepo/master}.
+
+\subsection{Obtendo informações de um
+Remoto}\label{obtendo-informacoes-de-um-remoto}
+
+Você pode acessar as informações de qualquer repositório remoto com o
+comando \texttt{git remote show}, que retornará a URL e os
+\texttt{branches}.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{remote show origin}
+\end{Highlighting}
+\end{Shaded}
+
+\subsection{Renomeado Remotos}\label{renomeado-remotos}
+
+O comando \texttt{git remote rename} pode modificar o nome de um
+repositório remoto. A seguir o repositório \texttt{MeuRepo}será
+renomeado para \texttt{RenameRepo}.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{remote rename MeuRepo RenameRepo}
+\end{Highlighting}
+\end{Shaded}
+
+\subsection{Removendo Remotos}\label{removendo-remotos}
+
+Para remover remotos é utilizado o comando \texttt{git remote rm}, agora
+será removido o repositório renomeado anteriormente \texttt{RenameRepo}.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{git} \NormalTok{remote rm RenameRepo}
+\end{Highlighting}
+\end{Shaded}
+
+\subsection{Deletar ramos no servidor}\label{deletar-ramos-no-servidor}
+
+Quando houver um branch que não está sendo utilizado ou está concluído,
+há a opção de excluí-lo do servidor.\\Se for necessário apagar branches
+remotos, podemos utilizar o comando a seguir:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{push origin --delete }\KeywordTok{<}\NormalTok{branch}\KeywordTok{>}
+\end{Highlighting}
+\end{Shaded}
+
+\subsection{Clonar apenas um \emph{branch}, \emph{commit} ou
+\emph{tag}.}\label{clonar-apenas-um-branch-commit-ou-tag.}
+
+É possível clonar apenas um branch e não o repositório Git completo.
+Supondo que no repositório há um branch chamado \texttt{MeuBranch}
+dentro do repositório \texttt{MeuRepo}, clonaremos o branch.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{clone -b MeuBranch --single-branch git://sub.domain.com/MeuRepo.git}
+\end{Highlighting}
+\end{Shaded}
+
+O Git ainda permite clonar um commit ou tag.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# Para uma tag:}
+\KeywordTok{git} \NormalTok{-e: //git.myproject.org/MyProject.git@v1.0#egg=MyProject}
+\CommentTok{# Para um commit:}
+\KeywordTok{git} \NormalTok{-e: //git.myproject.org/MyProject.git@da39a3ee5e6b4b0d3255bfef95601890afd80709#egg=MyProject}
+\end{Highlighting}
+\end{Shaded}
+
+\section{Criando um Repositório Git}\label{criando-um-repositorio-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 \texttt{MeuRepo} e o armazenar em um
+diretório \texttt{\textasciitilde{}/git}:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# Para criar um diretório git na sua home:}
+\KeywordTok{mkdir} \NormalTok{~/git}
+\CommentTok{# Para criar um repositório git:}
+\KeywordTok{mkdir} \NormalTok{MeuRepo.git}
+\CommentTok{# Para definir MeuRepo como um repositório remoto:}
+\KeywordTok{git} \NormalTok{--bare init}
+\end{Highlighting}
+\end{Shaded}
+
+As configurações do servidor estão completas. A partir você pode
+realizar os primeiros comandos para iniciar o repositório criado.
+
+\section{Git no servidor}\label{git-no-servidor}
+
+Primeiramente, para configurar o Git no Servidor e configurar os
+protocolos, clonaremos o repositório existente em um repositório limpo.
+\textbf{Observação:} você poderá colocar um repositório no Servidor se
+este não contém um diretório de trabalho.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+ \KeywordTok{git} \NormalTok{clone --bare MeuRepo MeuRepo.git}
+\end{Highlighting}
+\end{Shaded}
+
+Acima foi criado um repositório limpo \texttt{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 \texttt{git.servidor.com}, e um diretório
+\texttt{/dir/git}no qual você quer armazenar seus repositórios. Ao
+copiar o seu repositório limpo, você pode configurar seu novo
+repositório.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{scp} \NormalTok{-r MeuRepo.git usuario@git.example.com:/dir/git}
+\end{Highlighting}
+\end{Shaded}
+
+Agora o repositório pode ser clonado por outros usuários, que podem ter
+acesso de escrita e de envio de arquivos \texttt{push} no diretório.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{git} \NormalTok{clone usuario@git.example.com:/dir/git/MeuRepo.git}
+\end{Highlighting}
+\end{Shaded}
+
+\section{Configuração de Conexão SSH com
+Servidor}\label{configuracao-de-conexao-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:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{## Gerando uma chave ssh}
+\KeywordTok{ssh-keygen} \NormalTok{-t rsa -C }\StringTok{"usuario@email.com"}
+\end{Highlighting}
+\end{Shaded}
+
+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 \texttt{id\_rsa} e o \texttt{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:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{cat} \NormalTok{~/.ssh/id_rsa.pub}
+\end{Highlighting}
+\end{Shaded}
+
+A chave está no arquivo \texttt{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
+\href{https://gitlab.c3sl.ufpr.br/profile/keys}{\url{https://gitlab.c3sl.ufpr.br/profile/keys}}
+e clicar em \href{https://gitlab.c3sl.ufpr.br/profile/keys/new}{Add SSH
+Key}. É necessário escrever um título para a sua nova chave, no campo
+\texttt{key} colar o texto copiado do arquivo \texttt{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:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{ssh} \NormalTok{-T git@gitlab.c3sl.ufpr.br}
+\end{Highlighting}
+\end{Shaded}
+
+\textbf{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 \texttt{.ssh}
+para este usuário.
+
+\textbf{Exemplo:} criar usuário e diretório.
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{sudo} \NormalTok{adduser git}
+\KeywordTok{su} \NormalTok{git}
+\KeywordTok{cd}
+\KeywordTok{mkdir} \NormalTok{.ssh}
+\end{Highlighting}
+\end{Shaded}
+
+Agora, você terá um arquivo chamado \texttt{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
+\texttt{authorized\_keys}, como no exemplo a seguir.
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\CommentTok{# chave do primeiro usuário}
+\KeywordTok{cat} \NormalTok{/tmp/id_rsa1.pub }\KeywordTok{>>} \NormalTok{~/.ssh/authorized_keys}
+\CommentTok{# chave do segundo usuário}
+\KeywordTok{cat} \NormalTok{/tmp/id_rsa2.pub }\KeywordTok{>>} \NormalTok{~/.ssh/authorized_keys}
+\KeywordTok{...}
+\end{Highlighting}
+\end{Shaded}
+
+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:
+
+\textbf{Exemplo:}
+
+\begin{Shaded}
+\begin{Highlighting}[]
+\KeywordTok{cd/dir/git}
+\KeywordTok{mkdir} \NormalTok{NovoProjeto.git}
+\KeywordTok{cd} \NormalTok{NovoProjeto.git}
+\KeywordTok{git} \NormalTok{-bare init}
+\end{Highlighting}
+\end{Shaded}
+
+Agora os usuários, cujas chaves foram salvas no arquivo
+\texttt{authorized\_keys} podem compartilhar arquivos no repositório com
+os comando \texttt{git init}, \texttt{git add}, \texttt{git commit},
+\texttt{git remote add} e \texttt{git push origin master}. %%---------------------------------------------------------------
+
+\end{document}