Tutoriais & Notícias

Guia simplificado Git – instalação e comandos

8 min read
Guia simplificado Git - instalação e comandos 5

O que é o Git?

Então, o que é Git em poucas palavras? Esta é um artigo importante para absorver e entender os fundamentos de como ele funciona, usar o Git efetivamente provavelmente será muito mais fácil para você. Conforme você aprende o Git, tente limpar sua mente das coisas que você pode saber sobre outros VCSs (Version Control System), como CVS, Subversion ou Perforce - isso ajudará a evitar sutis confusões ao usar a ferramenta. Embora a interface do usuário do Git seja bastante semelhante a esses outros VCSs, o Git armazena e pensa nas informações de uma maneira muito diferente, e entender essas diferenças ajudará a evitar confusões durante o uso.

Para isso temos o Git que é um sistema de controle de versão muito eficaz, neste artigo irei mostar como é facil preparar um ambiente de desenvolvimento e instalar o Git no Linux.

Todo o processo de instalação e utilização do Git é por terminal de comando (CLI), desta forma você deve estar familiarizado com o terminal do linux.

Instalando no Linux

Se você deseja instalar as ferramentas básicas do Git no Linux por meio de um instalador binário, geralmente é possivel faze-lô através da ferramenta de gerenciamento de pacotes que acompanha sua distribuição. Se você estiver em alguma distribuição que utilize o RPM, RHEL, Fedora ou CentOS, poderá usar dnf.

$ sudo dnf install git-all

Se você estiver em alguma distribuição baseada no Debian, como ubuntu e linux mint, utilize o apt.

$ sudo apt install git-all

Instalando a partir do código-fonte

Algumas pessoas podem achar útil instalar o Git a partir da fonte, porque você obterá a versão mais recente. Os instaladores binários tendem a ficar um pouco atrasados, embora, como o Git tenha amadurecido nos últimos anos, isso tenha feito menos diferença.

Se você deseja instalar o Git a partir da fonte, você precisa das seguintes bibliotecas das quais o Git depende: autotools, curl, zlib, openssl, expat e libiconv. Por exemplo, se você estiver em um sistema que possui dnf(como o Fedora) ou apt-get(como um sistema baseado no Debian), você pode usar um destes comandos para instalar as dependências mínimas para compilar e instalar os binários do Git:

$ sudo dnf install dh-autoreconf curl-devel expat-devel gettext-devel \
  openssl-devel perl-devel zlib-devel
$ sudo apt-get install dh-autoreconf libcurl4-gnutls-dev libexpat1-dev \
  gettext libz-dev libssl-dev

Para poder adicionar a documentação em vários formatos (doc, html, info), são necessárias estas dependências adicionais:

$ sudo dnf install asciidoc xmlto docbook2X
$ sudo apt-get install asciidoc xmlto docbook2x

Se você estiver usando uma distribuição baseada no Debian (Debian/Ubuntu/Linux Mint ou derivados), também precisará do install-info pacote:

$ sudo apt-get install install-info

Se você estiver usando uma distribuição baseada em RPM (derivados do Fedora/RHEL ou CentOS), também precisará do getopt pacote (que já está instalado em uma distribuição baseada em Debian):

$ sudo dnf install getopt

Além disso, se você estiver usando derivados do Fedora/RHEL ou CentOS, precisará fazer isso:

$ sudo ln -s /usr/bin/db2x_docbook2texi /usr/bin/docbook2x-texi

Quando você tiver todas as dependências necessárias, poderá ir em frente e pegar o tarball de lançamento marcado mais recente de vários lugares. Você pode obtê-lo no site kernel.org, em https://www.kernel.org/pub/software/scm/git , ou no espelho no site do GitHub, em https://github.com/git/git / releases . Geralmente é um pouco mais claro qual é a versão mais recente na página do GitHub, mas a página do kernel.org também possui assinaturas de versão se você deseja verificar o seu download.

Em seguida, compile e instale:

$ tar -zxf git-2.8.0.tar.gz
$ cd git-2.8.0
$ make configure
$ ./configure --prefix=/usr
$ make all doc info
$ sudo make install install-doc install-html install-info

Depois disso, você também pode obter o Git via Git para atualizações:

$ git clone git://git.kernel.org/pub/scm/git/git.git

Fundamentos do Git - Obtendo um repositório Git

Obtendo um repositório Git

Você normalmente obtém um repositório Git de duas maneiras:

  1. Você pode pegar um diretório local que atualmente não está sob controle de versão e transformá-lo em um repositório Git, ou;

  2. Você pode clonar um repositório Git existente de outro lugar.

Em qualquer um dos casos, você acaba de criar um repositório Git em sua máquina local, pronto para trabalhar.

Inicializando um repositório em um diretório existente

Se você possui um diretório de projeto que atualmente não está sob controle de versão e deseja começar a controlá-lo com o Git, primeiro você precisa ir para o diretório desse projeto:

$ cd /home/$user/my_project

e digite:

$ git init

Isso cria um novo subdiretório chamado .git que contém todos os seus arquivos de repositório necessários - um esqueleto do repositório Git. Neste ponto, nada no seu projeto ainda é rastreado.

Se você deseja iniciar o controle de arquivos existentes da versão (em vez de um diretório vazio), provavelmente deve começar a rastrear esses arquivos e fazer uma confirmação inicial. Você pode fazer isso com o comando git add que especifica os arquivos que você deseja rastrear, seguidos por git commit:

$ git add *.c
$ git add LICENSE
$ git commit -m 'versão inicial do projeto'

Clonando um Repositório Existente

Você pode clonar um repositório com git clone <url>. Por exemplo, se você deseja clonar a biblioteca vinculável do Git chamada libgit2, pode fazer o seguinte:

$ git clone https://github.com/libgit2/libgit2

Isso cria um diretório chamado libgit2, inicializa um .git diretório dentro dele, extrai todos os dados desse repositório e faz check-out de uma cópia de trabalho da versão mais recente. Se você entrar no novo libgit2 diretório que acabou de ser criado, verá os arquivos do projeto, prontos para serem usados.

Se você deseja clonar o repositório em um diretório chamado algo diferente de libgit2, é possível especificar o novo nome do diretório como um argumento adicional:

$ git clone https://github.com/libgit2/libgit2 mylibgit

Esse comando faz a mesma coisa que o anterior, mas o diretório de destino é chamado mylibgit.

Exemplo Básico Branching e Merging

Vamos seguir um exemplo simples de branching e merging com um fluxo de trabalho que você pode usar no mundo real. Você seguirá estas etapas:

  1. Trabalhe em um site.
  2. Crie um branch em que você está trabalhando.
  3. Faça algum trabalho nesse branch.

Nesse estágio, você receberá uma chamada informando que outro problema é crítico e que precisa de um hotfix. Você fará o seguinte:

  1. Mude para o seu branch de produção.
  2. Crie um Branching para adicionar o hotfix.
  3. Depois de testado, mescle o Branch de hotfix e coloque para produção.
  4. Volte ao projeto original e continue trabalhando.

Básico de Branching

Primeiro, digamos que você esteja trabalhando no seu projeto e que já tenha alguns commit.

Guia simplificado Git - instalação e comandos 6
Um histórico de consolidação simples.

Você decidiu que vai trabalhar na edição 53 em qualquer sistema de rastreamento de problemas que sua empresa use. Para criar um Branching e alternar para ela ao mesmo tempo, você pode executar o git checkout com a -b opção:

$ git checkout -b iss53
Switched to a new branch "iss53"

Este é um atalho para:

$ git branch iss53
$ git checkout iss53
Guia simplificado Git - instalação e comandos 7
Criando um novo ponteiro branching.

Você trabalha no seu site e faz algumas confirmações. Fazer isso move a iss53 para frente, porque você a registrou (ou seja, você está apontando para ela):

$ vim index.html
$ git commit -a -m 'added a new footer [issue 53]'
Guia simplificado Git - instalação e comandos 8
A iss53 braching avançou com seu trabalho.

Agora você recebe a ligação dizendo que há um problema no site e precisa corrigi-lo imediatamente. Com o Git, você não precisa implantar sua correção juntamente com as iss53 alterações feitas e não precisa se esforçar muito para reverter essas alterações antes de poder aplicar a correção ao que está em produção. Tudo o que você precisa fazer é voltar para o seu master branch.

No entanto, antes de fazer isso, observe que, se o diretório de trabalho ou a área de armazenamento temporário apresentarem alterações não confirmadas que entrem em conflito com o ramo que você está fazendo check-out, o Git não permitirá que você troque de ramo. É melhor ter um estado de funcionamento limpo quando você alternar o branching. Existem maneiras de contornar isso (ou seja, esconder e confirmar alterações) no qual vamos abordar mais adiante, em Esconder e Limpar. Por enquanto, vamos supor que você tenha confirmado todas as suas alterações, para poder voltar ao seu master branch:

$ git checkout master
Switched to branch 'master'

Neste ponto, o diretório de trabalho do projeto é exatamente como era antes de você começar a trabalhar no problema #53 e pode se concentrar no seu hotfix. Este é um ponto importante a ser lembrado: quando você alterna o braching, o Git redefine seu diretório de trabalho para parecer com a última vez que você confirmou essa ramificação. Ele adiciona, remove e modifica arquivos automaticamente para garantir que sua cópia de trabalho tenha a aparência da ramificação no seu último commit.

Em seguida, você tem um hotfix para fazer. Vamos criar um hotfix branch no qual você trabalha até que seja concluído:

$ git checkout -b hotfix
Switched to a new branch 'hotfix'
$ vim index.html
$ git commit -a -m 'fixed the broken email address'
[hotfix 1fb7853] fixed the broken email address
 1 file changed, 2 insertions(+)
Guia simplificado Git - instalação e comandos 9
hotfix baseada em master

Você pode executar seus testes, verifique se o hotfix é o que deseja e, finalmente, mesclar o hotfix branch novamente no master branch para implantar na produção. Você faz isso com o git merge:

$ git checkout master
$ git merge hotfix
Updating f42c576..3a0874c
Fast-forward
 index.html | 2 ++
 1 file changed, 2 insertions(+)

Você notará a frase "avanço rápido" nessa mesclagem. Como o commit C4 apontado pelo brach em que você mesclou o hotfix e estava diretamente à frente do commit em que C2, o Git simplesmente move o ponteiro para frente. Para expressar essa outra maneira, quando você tenta mesclar um commit com um commit que pode ser alcançado seguindo o histórico do primeiro commit, o Git simplifica as coisas movendo o ponteiro para frente porque não há trabalho divergente para mesclar juntos - isso é chamado de " avanço rápido ".