Git + Github: uma introdução prática

Uma guia prático introdutório para que você entenda os bastidores dos seus primeiros comandos.

Figura 1 — Octopus. Fonte: imgbin

O Git foi criado por Linus Torvalds, para o controle de versões do kernel do Linux (antes versionado no BitKeeper) e hoje é disparadamente o versionador mais usado do mercado! Se quiser saber mais sobre como o Git mudou o versionamento de software o Hackernoon fez um artigo bem bacana sobre o assunto!

Mas… Como diria o próprio Linus Torvalds:

Talk is cheap. Show me the code.

Instalando o Git

Antes de mais nada, precisamos instalar o Git! Em uma distro Debian-like (Ubuntu, Linux Mint, Xubuntu…), execute:

$ sudo apt-get install git

Após a instalação, vamos verificar a versão instalada:

$ git --version

A saída deverá ser algo como git version 2.xx.y. Tudo certo até aí!

Definindo suas configurações globais

Agora iremos definir as configurações globais de nome e email do Git. Elas não serão usadas para fins de autenticação, e sim para melhor controle das alterações realizadas nos arquivos:

$ git config --global user.name "Seu Nome"
$ git config --global user.email "seu@email.com"

Para confirmar que as configurações foram registradas, execute:

$ git config --list

A saída deverá conter as informações recém cadastradas.

Extra: As configurações globais do Git ficam armazenadas em ~/.gitconfig. Caso queira visualizá-las, execute:

$ cat ~/.gitconfig

A saída será algo como:

[user]
 name = Seu Nome
 email = seu@email.com

Criando um repositório

Podemos criar um repositório de duas maneiras: pelo site do Github e localmente, pelo Git. Criaremos um pelo Git.

1. Crie um diretório para armazenar o nosso projeto hellogit:

$ mkdir hellogit

2. Uma vez criado o diretório, vamos inicializá-lo com o comando git init:

$ cd hellogit
$ git init

A saída será algo como:

Initialized empty Git repository in /home/user/hellogit/.git/

Observe que um diretório oculto (por isso o . no nome) chamado git foi criado, ele será o responsável pelo gerenciamento do repositório.

Definindo suas configurações locais

Em determinados casos você precisará definir configurações locais diferentes das suas globais (email de outro domínio, por exemplo). Para esses casos, temos a opção de configurar parâmetros somente para o repositório em questão:

1. Vá até o diretório desejado

$ cd hellogit

2. Execute o comando de configuração sem a flag — global:

$ git config user.email "outro@email.com"

Extra: As configurações locais de um repositório ficam armazenadas em .git/config. Caso queira visualizá-las, execute:

$ cat .git/config

A saída será algo como:

[user]
 email = outro@email.com

Adicionando arquivos ao repositório

Agora que já configuramos nossas informações e criamos um repositório, vamos de fato começar a usá-lo!

Antes de mais nada…

O comando git status nos mostrará o atual estado do nosso repositório:

$ git status

Saída:

On branch master
No commits yet
nothing to commit (create/copy files and use "git add" to track)

Pela saída podemos observar que estamos na branch master e nenhum commit foi realizado (não se preocupe com branches agora/já falaremos sobre commits)

Criando um arquivo

Vamos criar o arquivo README.md, que tradicionalmente armazena informações sobre o projeto do respositório (tecnologias usadas, como executar e etc):

$ touch README.md

Execute o comando git status novamente, agora seremos informados que existe um arquivo não rastreado pelo Git:

On branch master
No commits yet
Untracked files:
  (use "git add <file>..." to include in what will be committed)
README.md
nothing added to commit but untracked files present (use "git add" to track)

Adicionando o arquivo ao Git

Para que o Git passe a rastrear as alterações no arquivo README.md, execute:

$ git add README.md

Execute o comando git status novamente e verifique que o arquivo agora está sendo rastreado pelo Git:

On branch master
No commits yet
Changes to be committed:
  (use "git rm --cached <file>..." to unstage)
new file:   README.md

EXTRA: Você pode verificar o arquivo onde o Git armazena os arquivos rastreados executando:

$ cat .git/index

Essa área onde o Git armazena os arquivos rastreados é popularmente chamada de staging ou staging area.

Mas o que é staging area?

Quando falamos de staging area, estamos falando da área que armazena o que será rastreado pelo Git no próximo commit.

Seu primeiro commit

Uma vez em staging, podemos agora realizar um commit das alterações rastreadas.

Mas o que é um commit?

É o comando que salva as informações em staging no seu repositório local.

Vamos recapitular os passos até aqui:

1. git status nos mostra o status do(s) arquivo(s) (pendentes de rastreamento ou rastreados)
2. git add adiciona o(s) arquivo(s) não rastreados à area rastreada (staging)

Faremos agora nosso primeiro commit! Execute o comando:

$ git commit

Observe que um arquivo será aberto para que você insira uma mensagem no commit. Sem ela a ação não será concluída!

Insira a mensagem Initial commit e salve do arquivo:

GNU nano 2.9.3      /home/dev/hellogit/.git/COMMIT_EDITMSG
Initial commit
# Please enter the commit message for your changes. Lines starting
# with '#' will be ignored, and an empty message aborts the commit.
#
# On branch master
#
# Initial commit
#
# Changes to be committed:
#       new file:   README.md
#

Pronto! Você acaba de fazer seu primeiro commit!

Para visualizar o registro dele, execute:

$ git log

A saída será algo como:

commit 49324be62acc671d15c5f362b550535b463500b9 (HEAD -> master)
Author: User <user@mail.com>
Date:   Fri Jun 21 19:11:33 2019 -0300

Existe também uma maneira de abreviar o processo: inserindo a flag -m e a mensagem já no commit! Nosso exemplo anterior ficaria assim:

$ git commit -m "Initial commit"

Seu primeiro push

Agora que já fizemos o commit, podemos enviar o seu conteúdo ao nosso serviço de hospedagem de repositórios.

Github, Gitlab e Bitbucket: O que são?

São serviços de hospedagem de repositórios na nuvem e pelo nome dos dois primeiros, você já deve imaginar que eles fazem isso usando o Git (ou Mercurial, mas isso não vem ao caso agora). Simplificando: são gerenciadores de repositórios Git com interfaces gráficas web e serviços adicionais relacionados a gerenciamento de repositórios e equipes.

No nosso exemplo, usaremos o Github.

Criando uma conta no Github

O processo é bem simples: faça seu cadastro em https://github.com/join, optando pelo plano free (que é mais que suficiente para o nosso exemplo).

Criando seu primeiro repositório no Github

Na página inicialda sua conta recém-criada, na aba repositories, clique em New:

Figura 2— Botão “New” da aba “repositories” do Github

Crie o repositório hellogit:

Figura 3 — Criação o repositório “hellogit”

Pronto! Agora que você já tem uma conta e um repositório no Github, chegou a hora de relacionarmos eles ao nosso repositório local!

Configurando o remote

Agora iremos “mapear” o nosso repositório no Github ao nosso repositório local, em outras palavras, configuraremos o remote do nosso repositório!

Mas o que é remote?

Chamamos de remote o nosso repositório “correspondente” criado no serviço de hospedagem de repositórios. Em outras palavras, faremos com que o nosso hellogit local “aponte” para o hellogit que criamos no Github.

Se tudo deu certo, o repositório que você criou estará em:

https://github.com/seuusario/hellogit

acesse ele e observe o seguinte componente no canto superior direito:

Figura 4 — Botão “Clone or Download” do Github

Clique nele e você verá duas opções:

Figura 4— Diálogo do botão “Clone or Download” do Github

Escolha a opção Use HTTPS. Observe que a url foi alterada e agora utiliza o protocolo HTTPS:

Figura 5 — Diálogo do link “Use HTTPS” do Github

Não entraremos no mérito das diferenças entre SSH e HTTPS agora, mas saiba que são protocolos seguros de comunicação entre redes.

Copie a url exibida, ela deve se parecer com:

https://github.com/seuusuario/hellogit.git

Pois bem, de volta ao terminal! Execute o comando:

$ git remote -v

Como ainda não configuramos nosso remote, você não receberá nenhuma saída. Para configurar o remote, execute:

$ git remote add origin https://github.com/seuusuario/hellogit.git

Para termos certeza de que tudo deu certo, execute novamente:

$ git remote -v

A saída agora deverá ser:

origin https://github.com/seuusuario/hellogit.git (fetch)
origin https://github.com/seuusuario/hellogit.git (push)

Observação: origin é só o nome padrão do nosso remote.

Pronto! Já mapeamos o repositório, agora vamos enviar nosso código para lá!

Push

Agora executaremos o comando final do nosso processo! o comando push é o responsável por de fato enviar nossas alterações ao remote.

No terminal, execute:

$ git push origin master

Observação: master é a branch em que estamos, mas branches serão o assunto do próximo post ;)

Como estamos usando HTTPS, você precisará autenticar seu usuário no terminal. Se tudo deu certo, você receberá no terminal uma saída parecida com essa:

Counting objects: 3, done.
Writing objects: 100% (3/3), 276 bytes | 276.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0)
To github.com:seuusuario/hellogit.git
   49324be..9dd0152  master -> master

Agora vamos até o Github verificar se o arquivo está lá:

Figura 6— Exibição do primeiro push

Voilá! versionamos nosso arquivo o/

Um jeito mais fácil de começar um repositório

Agora que já entendemos o fluxo do Git, podemos explorar um jeito mais fácil de começar um repositório!

Para isso, vamos criar mais um repositório. Na aba repositories, clique em New:

Figura 7— Botão “New” da aba “repositories” do Github

Crie o repositório helloagaingit:

Figura 8— Criação do repositório “helloagaingit”

Pois bem, faremos agora o caminho inverso! Mapearemos o repositório criado no Github em nosso repositório local!

Copie a url do repositório helloagaingit:

https://github.com/seuusuario/helloagaingit.git

Agora vá até o seu diretório de preferência (~ é uma boa opção!) e execute o comando:

git clone https://github.com/seuusuario/helloagaingit.git

Observação: O comando git clone copia (ou clona) um repositório existente para sua máquina.

Após a execução do git clone, execute:

$ ls -la

Observe que o o respositório oculto .git estará lá! O Github inicializou o repositório para você. Além disso, não será preciso configurar o remote.

E é só isso! Observe que git add, git commit e git push funcionarão normalmente:

$ touch README.md
$ git add README.md
$ git commit -m "Initial commit"
$ git push origin master

Ufa! Terminamos! Você está livre para deletar os repositórios do seu Github.

Recapitulando…

git config — global: configura atributos globais.
git config: configura atributos locais.
git status: exibe o status atual do repositório.
git add: faz com que os arquivos sejam rastreados pelo Git.
git commit: salva as alterações no seu repositório local e as elenca para o próximo push.
git push: envia as alterações para o seu remote.
remote: repositório remoto que corresponde ao seu local.
git remote -v: configura o remote.
git clone: clona um repositório existente para a sua máquina.

Então é isso aí! Espero que tenham gostado!
No próximo entenderemos como as branches funcionam :)