Nesta aula, vamos mergulhar no Git, a ferramenta de controle de versão mais utilizada no mundo DevOps. O Git permite que equipes trabalhem simultaneamente em um projeto, mantendo um histórico completo de todas as alterações e facilitando a colaboração. Você aprenderá os conceitos essenciais e como executar o fluxo básico do Git no terminal.

Controle de versão é a prática de rastrear e gerenciar alterações no código-fonte. Com o Git, cada alteração é registrada, permitindo voltar a versões anteriores, comparar mudanças e colaborar sem conflitos. É uma habilidade fundamental para qualquer profissional de DevOps.

Por que controle de versão

Sem controle de versão, gerenciar alterações em um projeto de software é caótico. Imagine salvar arquivos com nomes como "projeto-final-v2-corrigido.py" e perder o que foi alterado. O controle de versão resolve isso ao manter um histórico completo e organizado de todas as modificações.

Os principais benefícios incluem:

  • Histórico completo: cada alteração é registrada com autor, data e mensagem explicativa.
  • Colaboração: várias pessoas podem trabalhar no mesmo projeto sem sobrescrever o trabalho umas das outras.
  • Rastreabilidade: é possível identificar quando e por que uma mudança foi feita, essencial para auditoria e debugging.
  • Branching e merging: permite desenvolver funcionalidades em paralelo e integrá-las de forma controlada.
  • Backup e recuperação: o repositório remoto serve como backup, e é fácil reverter para estados anteriores.

No contexto DevOps, o controle de versão é a base para pipelines de CI/CD, automação de deploys e garantia de que o código em produção seja rastreável.

Repositório

Um repositório Git é um diretório que contém todos os arquivos do projeto e o histórico de versões. Ele é armazenado em uma pasta oculta .git dentro do diretório do projeto. Existem dois tipos de repositórios: local (no seu computador) e remoto (em servidores como GitHub, GitLab ou Bitbucket).

Para iniciar um repositório local, use o comando git init. Isso cria a estrutura necessária para o Git começar a rastrear alterações. Exemplo:

cd meu-projeto
git init

Após a inicialização, você pode verificar o status do repositório com git status. Arquivos podem estar em três estados principais: modificado (modified), preparado (staged) ou consolidado (committed). O repositório remoto é sincronizado com o local através de comandos como git push e git pull.

Commits

Um commit é um snapshot do projeto em um determinado momento. Cada commit possui um hash único (SHA-1) que o identifica, além de autor, data e uma mensagem descritiva. Commits formam a linha do tempo do projeto.

Para fazer um commit, primeiro você precisa adicionar as alterações à área de preparação (staging area) com git add. Depois, cria o commit com git commit -m "mensagem". Exemplo:

git add arquivo.txt
git commit -m "Adiciona funcionalidade X"

Boas práticas para mensagens de commit: use o imperativo, seja claro e conciso, e referencie issues ou tarefas quando possível. Por exemplo: "Corrige bug no login" ou "Implementa endpoint de usuários".

Fluxo básico

O fluxo de trabalho básico do Git consiste em três etapas principais: modificar arquivos, preparar as alterações e consolidá-las em um commit. Esse ciclo se repete à medida que o projeto evolui.

Passo a passo:

  1. Modifique arquivos no diretório de trabalho (working directory).
  2. Use git add <arquivo> para mover as alterações para a área de preparação (staging area).
  3. Use git commit -m "mensagem" para criar um commit com as alterações preparadas.
  4. Repita os passos 1-3 conforme necessário.

Exemplo completo:

# Inicializar repositório
git init

# Criar um arquivo
echo "Hello, Git!" > arquivo.txt

# Verificar status
git status

# Adicionar à staging
git add arquivo.txt

# Commitar
git commit -m "Primeiro commit: adiciona arquivo.txt"

Após os commits locais, você pode enviá-los para um repositório remoto com git push e baixar alterações com git pull. Esse fluxo é a base para colaboração em equipe.

Boas práticas

  • Commits pequenos e atômicos: cada commit deve representar uma única alteração lógica.
  • Mensagens descritivas: facilita o entendimento do histórico.
  • Não commitar arquivos desnecessários: use .gitignore para ignorar binários, dependências, etc.
  • Commits frequentes: evite acumular muitas alterações antes de commitar.

Referências

Exercícios

  1. Inicialize um repositório Git em um diretório vazio chamado meu-projeto. Verifique o status.
  2. Crie um arquivo README.md com o texto "# Meu Projeto" e adicione-o à área de preparação. Faça um commit com a mensagem "Adiciona README inicial".
  3. Modifique o README.md adicionando uma linha "Este é um projeto de exemplo." Verifique o status e veja a diferença com git diff. Depois, prepare e commite a alteração.
  4. Crie um arquivo .gitignore que ignore todos os arquivos com extensão .log. Crie um arquivo debug.log e verifique se ele é ignorado pelo Git.
  5. Veja o histórico de commits com git log e identifique o hash do primeiro commit. Use git show <hash> para ver os detalhes.

✓ Resposta: 
mkdir meu-projeto
cd meu-projeto
git init
git status

✓ Resposta: 
echo "# Meu Projeto" > README.md
git add README.md
git commit -m "Adiciona README inicial"

✓ Resposta: 
echo "Este é um projeto de exemplo." >> README.md
git status
git diff
git add README.md
git commit -m "Adiciona descrição ao README"

✓ Resposta: 
echo "*.log" > .gitignore
touch debug.log
git status  # debug.log não aparece

✓ Resposta: 
git log  # copie o hash do primeiro commit (ex: a1b2c3d...)
git show a1b2c3d