Git
Chapters ▾ 2nd Edition

2.5 Fundamentos de Git - Trabalhando de Forma Remota

Trabalhando de Forma Remota

Para colaborar com qualquer projeto Git, você precisará saber como gerenciar seus repositórios remotos. Repositórios remotos são versões de seu repositório hospedado na Internet ou em uma rede qualquer. Você pode ter vários deles, cada um dos quais geralmente é ou somente leitura ou leitura/escrita. Colaborar com outras pessoas envolve o gerenciamento destes repositórios remotos, fazer pushing(atualizar) e pulling(obter) de dados para e deles quando você precisar compartilhar seu trabalho. Gerenciar repositórios remotos inclui saber como adicioná-los remotamente, remover aqueles que não são mais válidos, gerenciar vários branches(ramos) e definí-los como rastreados ou não e muito mais. Nesta seção, abordaremos algumas destas habilidades de gereciamento remoto.

Exibindo seus repositórios remotos

Para ver quais servidores remotos você configurou, você pode executar o comando git remote. Ele lista os nomes abreviados de cada repositório remoto manejado que você especificou. Se você clonou seu repositório, você deve pelo menos ver origin(origem) – que é o nome padrão dado pelo Git ao servidor que você clonou:

$ git clone https://github.com/schacon/ticgit
Cloning into 'ticgit'...
remote: Reusing existing pack: 1857, done.
remote: Total 1857 (delta 0), reused 0 (delta 0)
Receiving objects: 100% (1857/1857), 374.35 KiB | 268.00 KiB/s, done.
Resolving deltas: 100% (772/772), done.
Checking connectivity... done.
$ cd ticgit
$ git remote
origin

Você também pode especificar -v, que mostra as URLs que o Git tem armazenado pelo nome abreviado a ser usado para ler ou gravar naquele repositório remoto:

$ git remote -v
origin	https://github.com/schacon/ticgit (fetch)
origin	https://github.com/schacon/ticgit (push)

Se você tem mais de um repositório remoto, o comando lista todos eles. Por exemplo, um repositório com diversos repositórios remotos para trabalhar com vários colaboradores pode ser algo parecido com isto:

$ cd grit
$ git remote -v
bakkdoor  https://github.com/bakkdoor/grit (fetch)
bakkdoor  https://github.com/bakkdoor/grit (push)
cho45     https://github.com/cho45/grit (fetch)
cho45     https://github.com/cho45/grit (push)
defunkt   https://github.com/defunkt/grit (fetch)
defunkt   https://github.com/defunkt/grit (push)
koke      git://github.com/koke/grit.git (fetch)
koke      git://github.com/koke/grit.git (push)
origin    git@github.com:mojombo/grit.git (fetch)
origin    git@github.com:mojombo/grit.git (push)

Isto significa que nós podemos obter(pull) contribuições de qualquer um desses usuários muito facilmente. Nós podemos, adicionalmente, ter a permissão de atualizar(push) um ou mais destes, embora não possamos dizer isso nesse caso.

Note que estes repositórios remotos usam uma variedade de protocolos e nós falaremos mais sobre isso em Getting Git on a Server.

Adicionando Repositórios Remotos

Nós mencionamos e demos algumas demonstrações de como o comando clone implicitamente adiciona a origem(origin) remota para você. Aqui está como adicionar um novo repositório remoto explicitamente. Para adicionar um novo repositório Git remoto como um nome curto que você pode referenciar facilmente, execute git remote add <shortname> <url>:

$ git remote
origin
$ git remote add pb https://github.com/paulboone/ticgit
$ git remote -v
origin	https://github.com/schacon/ticgit (fetch)
origin	https://github.com/schacon/ticgit (push)
pb	https://github.com/paulboone/ticgit (fetch)
pb	https://github.com/paulboone/ticgit (push)

Agora você pode usar a string pb na linha de comando no lugar de uma URL completa. Por exemplo, se você quiser buscar toda a informação que Paul tem, mas você ainda não tem em seu repositório, você pode executar git fetch pb:

$ git fetch pb
remote: Counting objects: 43, done.
remote: Compressing objects: 100% (36/36), done.
remote: Total 43 (delta 10), reused 31 (delta 5)
Unpacking objects: 100% (43/43), done.
From https://github.com/paulboone/ticgit
 * [new branch]      master     -> pb/master
 * [new branch]      ticgit     -> pb/ticgit

O master branch(ramo mestre) do Paul agora está acessível localmente como pb/master – você pode fundí-lo(merge) dentro de uma de suas ramificações(branches) ou você pode checar fora da ramificação local se você quiser inspecioná-lo. (Nós abordaremos o que são ramificações(branches) e como usá-las mais detalhadamente em [ch03-git-branching]. )

Buscando e Obtendo de seus Repositórios Remotos

Como você viu, para obter dados de seus projetos remotos, você pode executar:

$ git fetch [remote-name]

O comando vai até aquele projeto remoto e extrai todos os dados daquele projeto que você ainda não tem. Depois que você faz isso, você deve ter como referência todos as ramificações(branches) daquele repositório remoto, que você pode mesclar(merge) com o atual ou inspecionar a qualquer momento.

Se você clonar um repositório, o comando automaticamente adiciona àquele repositório remoto com o nome origin. Então, git fetch origin busca qualquer novo trabalho que tenha sido enviado para aquele servidor desde que você o clonou ou fez a última busca(fetch). É importante notar que o comando git fetch só baixa os dados para o seu repositório local - ele não é automaticamente mesclado(merge) com nenhum trabalho seu ou modificação que você esteja trabalhando atualmente. Você deve mesclá-los manualmente dentro de seu trabalho quando você estiver pronto.

Se o branch atual é configurando para rastrear um branch remoto (veja a próxima seção e [ch03-git-branching] para mais informação), você pode usar o comando git pull para buscar(fetch) e então mesclar(merge) automaticamente aquele branch remoto dentro do seu branch atual. Este pode ser um fluxo de trabalho mais fácil e mais confortável para você, e por padrão, o comando git clone automaticamente configura a sua master branch local para rastrear a master branch remota ou qualquer que seja o nome do branch padrão no servidor de onde você o clonou. Executar git pull comumente busca os dados do servidor de onde você originalmente clonou e automaticamente tenta mesclá-lo dentro do código que você está atualmente trabalhando.

Pushing to Your Remotes

Quando você tem seu projeto em um ponto que deseja compartilhar, é necessário enviá-lo para o servidor remoto. O comando para isso é simples: git push [remote-name] [branch-name]. Se você quiser enviar sua ramificacão (branch) master para o servidor origin (novamente, a clonagem geralmente configura ambos os nomes para você automaticamente), então você pode executar isso para enviar quaisquer commits feitos para o servidor:

$ git push origin master

Este comando funciona apenas se você clonou de um servidor ao qual você tem acesso de escrita (write-access) e se ninguém mais utilizou o comando push nesse meio-tempo. Se você e outra pessoa clonarem o repositório ao mesmo tempo e ela utilizar o comando push e, em seguida, você tentar utilizar, seu envio será rejeitado. Primeiro você terá que atualizar localmente, incorporando o trabalho dela ao seu, só assim você poderá utilizar o comando push. Veja [ch03-git-branching] para informações mais detalhadas sobre como enviar para servidores remotos.

Inspecionando o Servidor Remoto

Se você quiser ver mais informações sobre um servidor remoto em particular, você pode usar o comando git remote show [nome-remoto]. Ao executar este comando com um nome abreviado específico, como origin, obterá algo assim:

$ git remote show origin
* remote origin
  Fetch URL: https://github.com/schacon/ticgit
  Push  URL: https://github.com/schacon/ticgit
  HEAD branch: master
  Remote branches:
    master                               tracked
    dev-branch                           tracked
  Local branch configured for 'git pull':
    master merges with remote master
  Local ref configured for 'git push':
    master pushes to master (up to date)

Ele lista a URL para o repositório remoto, bem como as informações de rastreamento do branch. O comando, de forma útil, comunica que se você estiver no branch master e executar git pull, ele irá mesclar (merge) automaticamente no branch master do servidor após buscar (fetch) todas as referências remotas. Ele também lista todas as referências remotas recebidas.

Esse é um exemplo simples que você provavelmente encontrará. Quando você usa o Git mais intensamente, no entanto, pode ver muito mais informações com git remote show:

$ git remote show origin
* remote origin
  URL: https://github.com/my-org/complex-project
  Fetch URL: https://github.com/my-org/complex-project
  Push  URL: https://github.com/my-org/complex-project
  HEAD branch: master
  Remote branches:
    master                           tracked
    dev-branch                       tracked
    markdown-strip                   tracked
    issue-43                         new (next fetch will store in remotes/origin)
    issue-45                         new (next fetch will store in remotes/origin)
    refs/remotes/origin/issue-11     stale (use 'git remote prune' to remove)
  Local branches configured for 'git pull':
    dev-branch merges with remote dev-branch
    master     merges with remote master
  Local refs configured for 'git push':
    dev-branch                     pushes to dev-branch                     (up to date)
    markdown-strip                 pushes to markdown-strip                 (up to date)
    master                         pushes to master                         (up to date)

Este comando mostra para qual ramificação (branch) é enviada automaticamente quando você executa git push enquanto em certas ramificações. Ele também mostra quais branches remotos do servidor você ainda não tem, quais você tem que foram removidos do servidor e várias branches locais que são capazes de se fundir automaticamente com seu branch de rastreamento remoto quando você executa git pull.

Removendo e Renomeando Remotes

Você pode utilizar o git remote rename para alterar o nome curto de servidores remotos. Por exemplo, se você deseja renomear pb para` paul`, você pode fazer isso com git remote rename:

$ git remote rename pb paul
$ git remote
origin
paul

Vale a pena mencionar que isso muda todos os nomes de ramificações de rastreamento remoto também. O que costumava ser referenciado em pb/master agora está em paul/master.

Se você quiser remover um servidor remoto por algum motivo - e você anteriormente moveu o servidor ou não está mais usando um em particular, ou talvez um contribuidor não esteja mais contribuindo - você pode usar git remote remove ou git remote rm:

$ git remote remove paul
$ git remote
origin