# Tutorial Git: Primeiros passos no sistema de controle de versões

O **desenvolvimento colaborativo de softwares** não ocorre apenas internamente, em empresas privadas. **Comunidades de código aberto**, com centenas ou milhares de voluntários (dependendo do tamanho do projeto), se encarregam da manutenção, otimização, desenvolvimento e modificação de softwares “públicos”. Projetos assim seriam inviáveis sem um **sistema de gerenciamento**, responsável por registrar todas as mudanças feitas por diferentes programadores.

Uma das soluções mais populares para gerenciar versões de programas é o Git, por ser gratuito e fácil de usar. Nosso **tutorial Git** apresenta todos os recursos básicos deste sistema de gerenciamento de software, **para que você comece a utilizá-lo com confiança**.

## O que é Git?

Git é um sistema de controle de versões desenvolvido pelo criador do Linux, Linus Thorvalds. Lançado em 2005, ele funciona sob a licença gratuita GNU GPLv2. No Git, embora cada projeto tenha um **repositório central**, todos os usuários envolvidos em um desenvolvimento fazem download de uma **cópia do diretório localmente**, no dispositivo próprio.

Cada cópia funciona como um backup completo do repositório, o que significa que desenvolvedores não precisam ficar o tempo todo conectados e podem trabalhar off-line. Além disso, essas cópias podem ser usadas para restaurar projetos, caso o repositório principal apresente falhas ou seja danificado. **Alterações** podem ser **compartilhadas com todos os demais membros de um projeto** a qualquer momento, e também incluídas no repositório central, quando necessário.

Dica Uma das mais populares alternativas ao Git é o **Subversion**, também de código aberto. Ao contrário do Git, o **SVN** (ele também é conhecido assim) utiliza um **sistema de gerenciamento central**. Nosso artigo comparativo entre [SVN e Git](https://www.ionos.com/digitalguide/websites/web-development/svn-vs-git-comparing-version-control-systems/ "SVN vs. Git: Comparação entre sistemas de controle de versões") apresenta semelhanças e diferenças destes sistemas de controle de versões.

## Como instalar o Git?

Quem deseja aprender a gerenciar projetos de softwares com o Git precisa se familiarizar com ele primeiro. O Git está disponível para Windows, Unix/Linux e macOS, mas apresenta pequenas diferenças em cada plataforma. Após instalar a versão correta para o seu sistema operacional, você conseguirá controlar a solução de forma independente, usando linha de comando ou a interface gráfica do usuário.

Nota Para usar os comados apresentados neste tutorial Git, usuários do Windows precisarão executar o sistema de controle de versões por **Git-Bash**, o *shell* estilo Unix contido na instalação. Outra opção é controlar o software por linha de comando ou pelo terminal do Windows. Neste caso, a estrutura de parâmetros dos comandos funcionará de um jeito um pouco diferente (por exemplo, com aspas duplas ao invés de aspas simples).

[YouTube video](https://www.youtube.com/watch?v=Nv2rpfO4PY4)**Arquivos de instalação binários, guias para instalação de gerenciadores de pacotes (sistemas Unix) e edições portáteis prontas para uso** estão disponíveis para diferentes sistemas operacionais no [site oficial do projeto Git](https://git-scm.com/downloads "Site oficial do projeto Git"). Faça o download do pacote adequado ou use a opção correspondente no gerenciador de pacotes. Depois, siga as instruções do assistente de instalação. Se você optar pela edição portátil, o processo de instalação não precisará ser executado.

Dica Na [seção de download do site *git-scm.com*](https://git-scm.com/downloads/guis/ "Git-GUIs no Centro de Downloads de git-scm.com"), a comunidade Git disponibiliza diversas **interfaces gráficas alternativas** para o gerenciador de versões. Entre as opções, você encontrará clientes Git para **Android** e **iOS**, possibilitando o uso da solução de código aberto em dispositivos móveis.

## Tutorial Git passo a passo

Depois de instalar o Git no seu dispositivo, você poderá usar o sistema de controle de versões para gerenciar seus projetos de software. Assim como com qualquer outra ferramenta, você terá de **aprender os principais comandos e funções** do Git para aproveitar ao máximo suas possibilidades. Por isso, nosso tutorial Git ensinará você a **configurar o Git** e apresentará as **principais instruções de linha de comando**, para facilitar a criação e a manutenção de repositórios.

Nota Especialistas da Associação Alemã de Cibersegurança (*Deutsche Gesellschaft für Cybersicherheit*) descobriram que um erro no Git, mais precisamente no sistema de administração de versões do repositório, permite que **arquivos *.git* sejam acessados publicamente por navegadores**. Isso é possível sempre que um repositório Git está localizado no diretório raiz (*webroot*) de um servidor. Por isso, usuários **não devem salvar arquivos *.git* no diretório raiz**. Alternativamente, servidores web devem ser configurados para que arquivos *.git* não possam ser acessados por outros usuários. Mais informações sobre vulnerabilidades e problemas de segurança do Git podem ser encontradas no site [Perforce](https://www.perforce.com/blog/vcs/how-secure-git "Quão seguro é o Git? — Perforce"). Apesar de relativamente antiga, uma publicação do Internetwache.org apresenta [soluções para corrigir problemas de segurança do Git](https://en.internetwache.org/dont-publicly-expose-git-or-how-we-downloaded-your-websites-sourcecode-an-analysis-of-alexas-1m-28-07-2015/ "Não exponha seu Git publicamente — Análise de caso em Internetwache.org").

### Crie ou clone um repositório Git

O repositório Git é o diretório central de um projeto, assim como o principal ponto de encontro entre todos os usuários que participam do desenvolvimento dele. É a partir do repositório que o gerenciamento completo de versões é realizado. Por isso, sua primeira tarefa no nosso tutorial Git será **criar um repositório central**. Se você já estiver participando de um projeto de desenvolvimento colaborativo gerenciado com o Git, poderá **clonar o repositório central** (em forma de cópia de trabalho).

Se quiser configurar o gerenciador de versões ou instalar ferramentas para aprender a trabalhar com o Git, você precisará criar um novo repositório. Para fazer isso, alterne para o **repositório local desejado** no seu dispositivo, usando o comando `cd` (***c**hange **d**irectory*):

```bash
cd caminho para diretório desejado
```

Depois, execute o comando abaixo para **gerar um repositório Git**:

```bash
git init
```

[![Imagem: Git-Bash: troca de diretório e geração de repositório](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/8/1/csm_git-tutorial-1_8ddb81ffec.webp "Git-Bash: troca de diretório e geração de repositório")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-1.jpg) Git-Bash: troca de diretório e criação de repositório Se o repositório Git do seu projeto já existir, você só precisará do **endereço web** ou do **endereço de rede** dele para criar uma **cópia de trabalho** no seu computador. Para isso, use o comando `git clone`:

```bash
git clone https://um-teste.site/repositorio-git
```

Nota O Git oferece suporte a vários protocolos de transmissão. Como alternativa ao [HTTPS](https://www.ionos.com/digitalguide/websites/website-creation/how-do-i-convert-my-site-to-ssl-and-https/ "Como converter um site para SSL e HTTPS") do exemplo, você também pode usar [SSH](https://www.ionos.com/pt-br/digitalguide/servidor/ferramentas/o-que-e-ssh-protocolo-ssh/ "SSH") para acessar um repositório (desde que possua a autorização para fazer isso).

### Verifique o status do repositório e adicione novos arquivos para controlar versões

Organização eficiente do repositório de trabalho é um dos pilares mais importantes do Git. A solução permite que você proponha **alterações e adições** a um projeto, para que sejam adotadas como “commits”, e também que acesse **informações sobre ajustes feitos por outros usuários**. Você pode verificar o status atual da sua cópia de trabalho executando o seguinte comando:

```bash
git status
```

No caso de um repositório recém-criado, ou se o repositório central e sua cópia de trabalho forem idênticas, você receberá uma mensagem informando que não há novas alterações no projeto (“No commits yet”). Além disso, o Git avisará que você ainda não enviou nenhuma alteração para o próximo *commit* (“nothing to commit”).

[![Imagem: Git-Bash: verificação do status do repositório Git](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/d/b/csm_git-tutorial-2_7400b70e7d.webp "Git-Bash: verificação do status do repositório Git")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-2.jpg) Git-Bash: verificação do status do repositório Git Para **adicionar um novo arquivo ao gerenciamento de versões** ou **enviar um arquivo revisado para o próximo *commit***, adicione o comando `git add` ao arquivo em questão (ele deve estar contido no repositório de trabalho). Nosso tutorial Git adicionará um arquivo de texto chamado “Test”, como exemplo:

```bash
git add Test.txt
```

Se você realizar uma verificação de status do repositório novamente, o arquivo do exemplo será apontado como potencial candidato à **próxima atualização oficial** do projeto (“Changes to be committed”):

[![Imagem: Git-Bash: verificação de status após alteração da cópia de trabalho](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/e/d/csm_git-tutorial-3_e2f3c6923a.webp "Git-Bash: verificação de status após alteração da cópia de trabalho")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-3.jpg) Git-Bash: verificação de status após alteração da cópia de trabalho ### Confirme alterações por *commit* e inclua-as no *HEAD*

Todas as alterações que você envia ao gerenciador de versões (conforme descrito na seção anterior) precisam ser confirmadas por meio de um *commit*, para que sejam **incluídas no *HEAD***. O*HEAD*é um tipo de índice que se baseia no último*commit*efetivado pelo seu ambiente de trabalho atual no Git (também chamado de*branch*). Use o comando a seguir neste passo:

```bash
git commit
```

Nota Antes de inserir o comando, sempre verifique se todas as alterações destinadas ao *commit* foram marcadas corretamente (usando `git add`). Do contrário, elas serão ignoradas, mesmo que estejam presentes no repositório da cópia de trabalho.

Depois de executar o comando, o **Git iniciará automaticamente o editor** que você selecionou durante o processo de instalação, ou o editor padrão do sistema de gerenciamento de versões. Neste momento, você poderá adicionar um **comentário** ao *commit* planejado. As linhas incluídas, separadas por ponto e vírgula, não serão exibidas posteriormente. Assim que você **fechar o editor**, o Git criará o *commit*:

[![Imagem: Tutorial Git: resultado no Git-Bash depois de executado o comando “git commit”](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/0/8/csm_git-tutorial-4_fd7dfd4d17.webp "Tutorial Git: resultado no Git-Bash depois de executado o comando “git commit”")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-4.jpg) Resultado no Git-Bash depois de executado o comando “git commit” Como é possível observar na captura de tela, você receberá um resumo sobre o *commit* depois de executar o comando `git commit`. Entre colchetes serão exibidos **nome do *branch***(que, nesse caso, chama-se*master*, já que nosso repositório de trabalho também é o repositório central) que adotou as alterações, e**soma de verificação (*checksum*) SHA-1**do*commit*(no caso,*c0fdc90*). Na sequência, o comentário escolhido (“Test”, no nosso exemplo) será exibido, assim como informações específicas sobre alterações feitas.

### Edite ou reverta *commits* gerados

Caso você adote alterações na forma de *commits*, é possível editá-las e até removê-las. Por exemplo, edições podem ser necessárias caso você gere um *commit* antes da hora, esquecendo-se de arquivos ou ajustes importantes. Neste caso, você deverá fornecer arquivos novos ou editados **retroativamente**, usando o comando `git add`, e repetir sua entrada no repositório central. Para fazer isso, adicione o trecho `--amend` ao comando padrão:

```bash
git commit --amend
```

No entanto, se você deseja **retirar o *commit*** mais recente, deverá usar o seguinte comando:

```bash
git reset --soft HEAD~1
```

Ele reverterá o último *commit* incluído no HEAD. Os arquivos nele contidos serão **revertidos** ao status de alterações planejadas (“Planned changes for the next commit”). Para **excluir** permanentemente os arquivos, insira o comando abaixo:

```bash
git reset --hard HEAD~1
```

### Acesse o histórico de *commits*

Vale a pena aprender a gerenciar projetos com o Git, justamente por causa de seus recursos de versionamento. Uma das grandes vantagens deste sistema de código aberto é que você consegue visualizar **as últimas alterações feitas no repositório**. Para fazer isso, execute o seguinte comando:

```bash
git log
```

O comando `git log` lista os *commits* gerados em ordem cronológica inversa e exibe, por padrão, a **verificação de soma SHA-1**, o **autor** (nome e endereço de e-mail) e a **data do *commit***. Além disso, os**comentários** também podem ser visualizados, fornecendo a você e aos demais usuários informações importantes sobre cada uma das alterações.

Você já aprendeu, com este tutorial Git, a gerar um *commit* simples, com o comentário “Test”. Essas informações serão apresentadas da seguinte forma:

[![Imagem: Tutorial Git: histórico de commits com uma entrada](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/8/8/csm_git-tutorial-5_748b3e97fd.webp "Tutorial Git: histórico de commits com uma entrada")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-5.jpg) Tutorial Git: histórico de commits com uma entrada O comando *log* também pode ser modificado por diversos parâmetros. A tabela a seguir apresenta algumas opções úteis:

<table>
  <thead>
    <tr>
      <th><strong>Parâmetro de comando *git log</strong>*</th>
      <th><strong>Descrição</strong></th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>*-p*</td>
      <td>Exibe as alterações contidas em um *commit*.</td>
    </tr>
    <tr>
      <td>*-2*</td>
      <td>Lista apenas os dois últimos *commits*.</td>
    </tr>
    <tr>
      <td>*–stat*</td>
      <td>Adiciona estatísticas a cada entrada, informando quais arquivos foram alterados e quantas linhas foram adicionadas ou removidas.</td>
    </tr>
    <tr>
      <td>*–pretty*</td>
      <td>Altera o formato do resultado; diversos formatos disponíveis.  
Ex.: O formato *–pretty=online* lista todos os *commits* em uma única linha.</td>
    </tr>
    <tr>
      <td>*–abbrev-commit*</td>
      <td>Exibe apenas os primeiros caracteres de uma soma de verificação SHA-1.</td>
    </tr>
    <tr>
      <td>*–relative-date*</td>
      <td>Exibe a data de uma alteração em formato relativo (por exemplo, “duas semanas atrás”).</td>
    </tr>
  </tbody>
</table>

### Inclua *commits* no repositório central

Com este tutorial Git você já aprendeu como salvar alterações como um *commit* no HEAD do repositório local. No entanto, para que o *commit* seja incluído no **repositório central**, mais um passo deve ser tomado. Insira o comando a seguir:

```bash
git push origin master
```

O **Git adicionará automaticamente todos os *commits* gerados ao *master*, nome do repositório central** — antes eles só existiam na sua cópia de trabalho. Se você substituir a palavra “master” no código acima pelo nome de outro *branch*, os arquivos serão enviados a ele.

### *Tagging*: Cria, exclua e liste *tags* no Git

Assim como outros sistemas de controle de versões, o Git oferece um recurso de *tagging* que permite **marcar como importantes, pontos selecionados no histórico de um repositório**. Essas *tags* costumam ser usadas para sinalizar lançamentos de um software (por exemplo, versão 1.0, 2.0, 3.0 e assim por diante), para que elas sejam facilmente acessadas, principalmente em projetos maiores. O Git suporta dois tipos de *tags*:

- ***Tags* “anotadas”**: Salvas como objetos independentes no banco de dados. Incluem soma de verificação própria, mensagem de *tagging*, data, nome e endereço de e-mail do autor, bem como assinatura GNU Privacy Guard (GPG) opcional.
- ***Tags* “leves”**: Agem como *branches* e servem apenas como referência para um *commit*. Adequadas para marcações temporárias ou quando não se deseja salvar informações adicionais.

Você pode criar ***tags* “anotadas”** no Git usando o comando `git tag -a` no respectivo *commit*. Ao adicionar o parâmetro `-m` como sufixo, você poderá escrever a **mensagem de *tagging***que quiser, diretamente na linha de comando (entre aspas retas). Neste tutorial Git, geramos o*commit*“Test” e vamos vinculá-lo a uma*tag*com a mensagem “*tag* de exemplo”:

```bash
git tag -a Test -m "tag de exemplo"
```

Nota Ao adicionar o parâmetro `-m` à criação de uma *tag*, o Git abrirá automaticamente o editor para que você insira a mensagem de *tagging* que preferir.

Ao criar ***tags* “leves”**, você utilizará abordagem similar. No entanto, só será preciso usar o comando básico `git tag`, sem a adição de qualquer outro parâmetro ao *commit* desejado. Nosso tutorial Git utilizará este comando da seguinte forma:

```bash
git tag Test
```

Se houver *tags* no seu repositório, você poderá exibi-las com o comando `git tag` e os parâmetros opcionais `-l` e `--list`:

```bash
git tag
git tag -l
git tag --list
```

[![Imagem: Tutorial Git: lista de tags existentes no repositório](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/3/4/csm_git-tutorial-6_b5d46d48aa.webp "Tutorial Git: lista de tags existentes no repositório")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-6.jpg) O comando “git tag” exibe a tag criada anteriormente para o commit “Test” Para **excluir uma *tag* do repositório de trabalho local**, use a cadeia de comandos `git tag -d`. Assim excluímos nossa *tag* “Test”:

```bash
git tag -d Test
```

*Tags* precisam ser transferidas manualmente para o repositório central. Para fazer isso, informe o nome da *tag* e o comando `git push origin`. Em vez de digitar o nome da *tag*, você pode adicionar o parâmetro `--tags`, que transportará todas as *tags* geradas para o repositório.

```bash
git push origin --tags
```

### Crie, gerencie e exclua *branches*

*Branches* usados neste tutorial Git correspondem a **versões de trabalho individuais do repositório central**. O repositório central, por sua vez, também é classificado como um *branch*, neste caso chamado de “master”. É por esses *branches* que o Git oferece a base perfeita para o desenvolvimento de funções e recursos isolados, combinando-os somente em estágios posteriores. Ao processo de combinação dá-se o nome de “**merge**” (mesclar).

É muito fácil **criar um *branch***novo. Você só precisa usar a instrução `git branch` e inserir o nome desejado. Para criar um exemplo de*branch*chamado***test\_branch***, insira o comando abaixo:

```bash
git branch test_branch
```

Depois, você poderá alternar para esse *branch* quando quiser, usando o comando `git checkout`:

```bash
git checkout test_branch
```

[![Imagem: Tutorial Git: alternar entre branches no Git-Bash](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/f/0/csm_git-tutorial-7_6aebff405d.webp "Tutorial Git: alternar entre branches no Git-Bash")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-7.jpg) Depois de alternar entre branches, o Git exibirá a mensagem: “Switched to branch” Se você quiser fazer *merge* em *branches*, use o comando `git merge`. Antes, insira o comando `checkout`, para alternar para o repositório que integrará o outro *branch*. Depois, execute o comando de *merge*, juntamente com o nome do *branch* a ser mesclado. No nosso tutorial Git, **mesclaremos ao repositório central** a versão de trabalho “test\_branch”:

```bash
git checkout master
git merge test_branch
```

Depois de fazer o *merge*, você não precisará de determinados *branches* anteriores. Exclua-os, se for o caso. Para fazer isso, adicione o comando `git branch -d` ao *branch* a ser descartado. Nosso tutorial Git excluirá o exemplo “test\_branch”, executando o comando a seguir:

```bash
git branch -d test_branch
```

**Para efetuar um processo de exclusão** de um *branch*, você necessariamente terá de estar em um *branch* diferente. É por esse motivo que alternaremos para o repositório central antes de executarmos o comando, conforme mostra a captura de tela abaixo:

[![Imagem: Alternar e remover branches pelo Git-Bash](https://www.ionos.com/pt-br/digitalguide/fileadmin/_processed_/3/6/csm_git-tutorial-8_a15d6804b1.webp "Alternar e remover branches pelo Git-Bash")](https://www.ionos.com/pt-br/digitalguide/fileadmin/DigitalGuide/Screenshots_2020/git-tutorial-8.jpg) O Git confirma a exclusão do branch com a mensagem: “Deleted branch...”  Dica Nosso Digital Guide tem artigo específico sobre *branches* do Git. Aprenda a [renomear um *branch* local ou remoto](https://www.ionos.com/digitalguide/websites/web-development/renaming-a-git-branch/ "Renomear branch no Git")”.


This is a markdown version of: [https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/tutorial-git/](https://www.ionos.com/pt-br/digitalguide/sites-de-internet/desenvolvimento-web/tutorial-git/) for AI/LLM consumption.