cap04.tex

% \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}