-
1. Primeiros Passos
- 1.1 Sobre Controle de Versão
- 1.2 Uma Breve História do Git
- 1.3 O que é Git?
- 1.4 A Linha de Comando
- 1.5 Instalando o Git
- 1.6 Configuração inicial do Git
- 1.7 Obtendo Ajuda
- 1.8 Resumo
-
2. Fundamentos do Git
-
3. Ramificação (Branching) no Git
-
4. Git no Servidor
- 4.1 Os Protocolos
- 4.2 Colocando o Git em um Servidor
- 4.3 Gerando a sua Chave Pública SSH
- 4.4 Configurando o Servidor
- 4.5 Git Daemon
- 4.6 Smart HTTP
- 4.7 GitWeb
- 4.8 GitLab
- 4.9 Opções de Hospedagem de Terceiros
- 4.10 Resumo
-
5. Git Distribuído
-
6. GitHub
-
7. Ferramentas do Git
- 7.1 Seleção de Revisão
- 7.2 Área de Stage Interativa
- 7.3 Fazendo Stash e Limpando
- 7.4 Assinando Seu Trabalho
- 7.5 Pesquisando (Searching)
- 7.6 Reescrevendo o Histórico
- 7.7 Reset Desmistificado
- 7.8 Merging Avançado
- 7.9 Rerere
- 7.10 Depurando com Git
- 7.11 Submódulos
- 7.12 Empacotando (Bundling)
- 7.13 Substituir (Replace)
- 7.14 Armazenamento de Credenciais
- 7.15 Resumo
-
8. Customizando o Git
- 8.1 Configuração do Git
- 8.2 Atributos do Git
- 8.3 Hooks do Git
- 8.4 Uma Política de Exemplo Imposta pelo Git
- 8.5 Resumo
-
9. Git e Outros Sistemas
- 9.1 Git como Cliente
- 9.2 Migrando para o Git
- 9.3 Resumo
-
10. Git Internals (Por Dentro do Git)
- 10.1 Encanamento e Porcelana (Plumbing and Porcelain)
- 10.2 Objetos do Git
- 10.3 Referências do Git
- 10.4 Arquivos de pacote (Packfiles)
- 10.5 Refspec
- 10.6 Protocolos de Transferência
- 10.7 Manutenção e Recuperação de Dados
- 10.8 Variáveis de Ambiente
- 10.9 Resumo
-
A1. Appendix A: O Git em Outros Ambientes
- A1.1 Interfaces Gráficas
- A1.2 Git no Visual Studio
- A1.3 Git no Visual Studio Code
- A1.4 Git no IntelliJ / PyCharm / WebStorm / PhpStorm / RubyMine
- A1.5 Git no Sublime Text
- A1.6 Git no Bash
- A1.7 Git no Zsh
- A1.8 Git no PowerShell
- A1.9 Resumo
-
A2. Appendix B: Incorporando o Git nos seus Aplicativos
- A2.1 Linha de Comando do Git
- A2.2 Libgit2
- A2.3 JGit
- A2.4 go-git
- A2.5 Dulwich
-
A3. Appendix C: Comandos do Git
- A3.1 Configuração e Ajustes
- A3.2 Obtendo e Criando Projetos
- A3.3 Snapshots Básicos
- A3.4 Branches e Merges
- A3.5 Compartilhando e Atualizando Projetos
- A3.6 Inspeção e Comparação
- A3.7 Depuração
- A3.8 Patches
- A3.9 E-mail
- A3.10 Sistemas Externos
- A3.11 Administração
- A3.12 Comandos de Encanamento
5.1 Git Distribuído - Fluxos de Trabalho Distribuídos
Agora que você tem um repositório Git remoto configurado como um ponto focal para todos os desenvolvedores compartilharem os seus códigos, e está familiarizado com os comandos básicos do Git em um fluxo de trabalho local, verá como utilizar alguns dos fluxos de trabalho distribuídos que o Git oferece.
Neste capítulo, você verá como trabalhar com o Git em um ambiente distribuído como contribuidor (contributor) e integrador (integrator). Ou seja, você aprenderá como contribuir com código para um projeto com sucesso e torná-lo o mais fácil possível para você e para o mantenedor do projeto, e também como manter um projeto com sucesso com vários desenvolvedores contribuindo.
Fluxos de Trabalho Distribuídos
Em contraste com os Sistemas de Controle de Versão Centralizados (CVCSs), a natureza distribuída do Git permite que você seja muito mais flexível na forma como os desenvolvedores colaboram em projetos. Em sistemas centralizados, cada desenvolvedor é um nó trabalhando de forma mais ou menos igual com um hub central. No Git, no entanto, todo desenvolvedor é potencialmente tanto um nó quanto um hub; ou seja, todo desenvolvedor pode contribuir com código para outros repositórios e manter um repositório público no qual outros podem basear o seu trabalho e para o qual podem contribuir. Isso apresenta uma vasta gama de possibilidades de fluxo de trabalho para o seu projeto e/ou equipe, então abordaremos alguns paradigmas comuns que aproveitam essa flexibilidade. Analisaremos os pontos fortes e as possíveis fraquezas de cada design; você pode escolher apenas um para usar, ou pode misturar e combinar (mix and match) recursos de cada um.
Fluxo de Trabalho Centralizado
Em sistemas centralizados, geralmente há um único modelo de colaboração — o fluxo de trabalho centralizado. Um hub central, ou repositório, pode aceitar código, e todos sincronizam o seu trabalho com ele. Um número de desenvolvedores são nós — consumidores daquele hub — e sincronizam com esse local centralizado.
Isso significa que, se dois desenvolvedores clonarem do hub e ambos fizerem alterações, o primeiro desenvolvedor a fazer o push das suas alterações de volta pode fazê-lo sem problemas. O segundo desenvolvedor deve fazer o merge do trabalho do primeiro antes de fazer o push das alterações, para não substituir as alterações do primeiro desenvolvedor. Esse conceito é tão verdadeiro no Git quanto no Subversion (ou em qualquer CVCS), e esse modelo funciona perfeitamente bem no Git.
Se você já estiver confortável com um fluxo de trabalho centralizado na sua empresa ou equipe, poderá continuar usando esse fluxo de trabalho com o Git facilmente. Basta configurar um único repositório e dar acesso de push a todos na sua equipe; o Git não permitirá que os usuários sobrescrevam os trabalhos uns dos outros.
Digamos que John e Jessica comecem a trabalhar ao mesmo tempo. John termina a sua alteração e faz o push para o servidor. Então, Jessica tenta fazer o push de suas alterações, mas o servidor as rejeita. Ela é informada de que está tentando fazer um push de alterações non-fast-forward e que não conseguirá fazê-lo até fazer o fetch e o merge. Este fluxo de trabalho é atraente para muitas pessoas porque é um paradigma com o qual muitos estão familiarizados e confortáveis.
Isso também não se limita a equipes pequenas. Com o modelo de ramificação (branching model) do Git, é possível que centenas de desenvolvedores trabalhem com sucesso em um único projeto através de dezenas de branches simultaneamente.
Fluxo de Trabalho do Gerente de Integração (Integration-Manager)
Como o Git permite que você tenha vários repositórios remotos, é possível ter um fluxo de trabalho em que cada desenvolvedor tem acesso de gravação ao seu próprio repositório público e acesso de leitura aos de todos os outros. Esse cenário geralmente inclui um repositório canônico que representa o projeto “oficial”. Para contribuir com esse projeto, você cria o seu próprio clone público do projeto e faz o push das suas alterações para ele. Então, você pode enviar uma solicitação ao mantenedor do projeto principal para fazer o pull das suas alterações. O mantenedor pode então adicionar o seu repositório como remoto, testar as suas alterações localmente, mesclá-las no branch dele e fazer o push de volta para o repositório dele. O processo funciona da seguinte forma (veja Fluxo de trabalho do Gerente de Integração (Integration-manager)):
-
O mantenedor do projeto faz o push para o seu repositório público.
-
Um contribuidor clona esse repositório e faz alterações.
-
O contribuidor faz o push para a sua própria cópia pública.
-
O contribuidor envia um e-mail ao mantenedor pedindo que ele faça o pull das alterações.
-
O mantenedor adiciona o repositório do contribuidor como um remoto e faz o merge localmente.
-
O mantenedor faz o push das alterações mescladas (merged changes) para o repositório principal.
Este é um fluxo de trabalho muito comum com ferramentas baseadas em hub como o GitHub ou GitLab, onde é fácil fazer um fork de um projeto e fazer o push das suas alterações para o seu fork para que todos vejam. Uma das principais vantagens dessa abordagem é que você pode continuar a trabalhar, e o mantenedor do repositório principal pode fazer o pull das suas alterações a qualquer momento. Os contribuidores não precisam esperar que o projeto incorpore as suas alterações — cada parte pode trabalhar no seu próprio ritmo.
Fluxo de Trabalho Ditador e Tenentes (Dictator and Lieutenants)
Esta é uma variante de um fluxo de trabalho de múltiplos repositórios. Geralmente é usado por projetos enormes com centenas de colaboradores; um exemplo famoso é o kernel do Linux. Vários gerentes de integração são responsáveis por certas partes do repositório; eles são chamados de tenentes (lieutenants). Todos os tenentes têm um gerente de integração conhecido como o ditador benevolente (benevolent dictator). O ditador benevolente faz o push do seu diretório para um repositório de referência do qual todos os colaboradores precisam fazer o pull. O processo funciona assim (veja Fluxo de trabalho do ditador benevolente (Benevolent dictator)):
-
Desenvolvedores regulares trabalham em seu branch de tópico e fazem o rebase do seu trabalho no topo da
master. O branchmasteré aquele do repositório de referência para o qual o ditador faz o push. -
Os tenentes mesclam (merge) os branches de tópico dos desenvolvedores em seu branch
master. -
O ditador mescla os branches
masterdos tenentes no branchmasterdo ditador. -
Finalmente, o ditador faz o push desse branch
masterpara o repositório de referência para que os outros desenvolvedores possam fazer o rebase nele.
Esse tipo de fluxo de trabalho não é comum, mas pode ser útil em projetos muito grandes ou em ambientes altamente hierárquicos. Ele permite que o líder do projeto (o ditador) delegue grande parte do trabalho e colete grandes subconjuntos de código em vários pontos antes de integrá-los.
Padrões para Gerenciar Branches de Código-Fonte
|
Note
|
Martin Fowler criou um guia "Patterns for Managing Source Code Branches" (Padrões para Gerenciar Branches de Código-Fonte). Este guia abrange todos os fluxos de trabalho comuns do Git e explica como/quando usá-los. Há também uma seção comparando frequências de integração altas e baixas. |
Resumo dos Fluxos de Trabalho
Estes são alguns fluxos de trabalho comumente usados que são possíveis com um sistema distribuído como o Git, mas você pode ver que muitas variações são possíveis para se adequar ao seu fluxo de trabalho particular do mundo real. Agora que você pode (esperamos) determinar qual combinação de fluxo de trabalho pode funcionar para você, abordaremos alguns exemplos mais específicos de como cumprir os papéis principais que compõem os diferentes fluxos. Na próxima seção, você aprenderá sobre alguns padrões comuns para contribuir com um projeto.