Como usar o Git e o GitHub em projetos já existentes?

Veja o vídeo também:

Tutorial Básico: Como usar o Git e o GitHub no seu projeto.

O Git é um sistema de controle de versão distribuído e um sistema de gerenciamento de código fonte, criado por Linus Torvalds pai e também criador do sistema operacional Linux.

Já o GitHub é um repositório remoto e online para o controle de códigos com planos gratuitos, e planos pagos caso queira deixar seus projetos privados.

Ou seja, Git e GitHub são duas coisas completamente diferentes mas que trabalham em conjunto, tenha isso em mente.

Uma boa opção gratuita caso queira um repositório remoto que deixe seus projetos privados é o bitbucket, mas talvez falaremos dele em um outra postagem.

1 – Instalando o Git e usando o Git Bash.

O ambiente que usaremos é o Windows 8.1 64bits.

Acesse o site do Git para fazer o download do instalador no endereço abaixo:

https://git-scm.com/downloads

Vamos usar uma ferramenta chamada Git Bash (que foi instalada junto com o Git) para executar os comandos do Git.

Para verificar se a instalação do Git foi correta, vamos executar um primeiro comando que é verificar a versão do Git.

git --version

Vamos iniciar duas configurações básicas no Git, cadastrar o nome do autor e o email do autor.

Cadastre seu nome:

git config --global user.name "seu nome aqui"

Cadastre seu email:

git config --global user.email "seu email aqui"

2 – Se cadastrando no GitHub

Para se cadastrar no GitHub vamos acessar o link abaixo:

https://github.com/

Clique na opção Sign Up, informe um usuário (username), informe seu email, e cadastre uma senha de no mínimo 7 dígitos, misturando letras e números (não coloque caracteres especiais como: @#$%).

Escolha a opção de plano Gratuita (Free – Unlimited public repositories for free.)

Verifique no email que você cadastrou e ative sua conta.

3 – Criando o seu repositório local

Agora, vamos iniciar novamente o Git Bash e adicionar um dos nossos projetos no repositório local.

Para você entender o nosso contexto, temos um projeto chamado “ProjetoTeste”, é um projeto Java utilizando Maven e a nossa IDE é o Eclipse (a IDE acaba sendo irrelevante já que é um project Maven e pode ser importado em qualquer IDE – netbeans, eclipse, etc..), mas esse é o nosso ambiente de desenvolvimento básico.

A partir de agora vamos fazer o controle de versão desse projeto já existente, que inicialmente não estava sendo feito.

Mais uma vez lembrando que estamos utilizando o Windows 8.1, e nosso projeto se encontra no diretório:

C:ambiente_desenvolvimentoprojetosProjetoTeste

Iniciamos o Git Bash, e navegamos pela linha de comando até o diretório do nosso projeto “ProjetoTeste”.

No nosso caso:

cd ambiente_desenvolvimento/projetos/ProjetoTeste

Agora que navegamos pelo prompt do Git Bash para dentro do diretório que queremos controlar, executamos o seguinte comando:

git init

Veja na imagem a seguir, no próprio Git Bash, ao lado do diretório que queremos controlar, apareceu de azul a palavra (master) entre parenteses, isso significa a branch padrão do git e que agora essa pasta/diretório esta sendo monitorada pelo Git.

Agora, para verificarmos a situação dos arquivos dentro desse diretório ProjetoTeste podemos da o seguinte comando:

git status

Com o comando git status, verificamos que aparecem alguns arquivos e até mesmo outras pastas dentro do diretório que estamos monitorando, e na imagem acima eles aparecem de vermelho, isso quer dizer que esses arquivos ainda não estão sendo monitorados ou trackeados, e temos que informar ao Git quais arquivos queremos que ele monitore a partir de agora, no nosso caso vamos monitorar todos, e para fazer isso executamos o seguinte comando:

git add .
git status

Perceba que executamos o comando git add . (espaço ponto final), esse espaço ponto final é um coringa que quer dizer adicione tudo,  e após adicionar todos os arquivos para serem monitorados, perceba que não nos é mostrado nada na tela do git bash, por esse motivo executamos novamente o comando git status, para vermos o status atual do nosso diretório monitorado.

Após ver o status dos nossos arquivos, percebemos que eles estão na cor verde (como mostra a figura acima), ou seja, estão sendo trackeados/monitorados pelo git a partir de agora, porém eles ainda não estão dentro do nosso repositório git local (que fica no seu próprio computador, em uma pasta (provavelmente oculta) chamada .git, dentro do diretório que você está monitorando como mostra a figura abaixo).

Para que nós enviemos agora esses arquivos para nosso repositório local, devemos fazer um commit desses arquivos com o seguinte comando:

git commit -m "commit inicial"

Esse comando faz o envio para o repositório local do git que está em nossos computadores, o parametro (-m) significa que queremos enviar uma mensagem explicando do que se trata esse commit para que possamos identificar do que se trata cada commit, e entre aspas duplas você informa a mensagem, no nosso caso informamos que esse é o commit inicial do projeto.

Verifique a mensagem do commit e veja que no exemplo acima ele “commitou” 15 arquivos, e os nomes dos arquivos não estão mais de vermelho ou verde, estão na cor branca.

Agora, vamos executar novamente o comando git status.

A mensagem de status que nos é informado após o commit é:

On branch master: Estamos na branch master.
Nothing to commit: Não tem mais nada a ser commitado no momento.
Working tree clean: Nosso diretório está limpo/vazio, ou sem mudanças até o momento.

Observação: Caso você queira adicionar os arquivos e commitar em um único comando, poderíamos commitar direto acrescentando o parametro -a (de adicionar) e ficaria da seguinte maneira:

git commit -a -m "commitando e adicionando juntos"

4 – Ignorar arquivos específicos no Git

Este é um caso onde podemos determinar que o Git não monitore determinados arquivos ou pastas dentro do diretório que ele esteja monitorando, um exemplo bem comum são as pastas libs, resources ou de outras bibliotecas que são controladas pelos maven, sem a necessidade que o Git monitore-as.

Apenas para um exemplo didático, criamos dentro do nosso projeto um arquivo chamado arquivoignorado.txt  e uma pasta chamada pastaignorada onde dentro dela tem outro arquivo chamado ignorado.txt, conforme a imagem a seguir.

Criamos esses dois arquivos, porém se executarmos um comando git status verificamos que esses arquivos não estão sendo ignorados pelo monitoramento do git conforme a imagem a seguir.

Para que possamos informar ao Git que ignore e não monitore esses arquivos ou pastas, devemos criar dentro do diretório que está sendo monitorado, no nosso exemplo o diretório ProjetoTeste, um arquivo chamado “.gitignore” (com o ponto na frente), e dentro desse arquivo escrever os nomes dos arquivos a serem ignorados, incluindo o próprio arquivo .gitignore conforme você pode ver na imagem a seguir.

Nesse momento, ao verificar novamente o status do git no nosso diretório, pelo comando git status, verificamos que esses arquivos não estão mais sendo observados pelo git no nosso projeto, conforme imagem a seguir.

5 – Sincronizando com o GitHub (Repositório Remoto)

Conforme o passo 2 você já deve ter se cadastrado no GitHub, mas antes, ainda no Git vamos gerar um chave de segurança para que você tenha acesso do seu computador local ao GitHub. Executamos o seguinte comando e em seguida damos Enter sem preencher nada até finalizar.

ssh-keygen

Como você pode verificar na imagem acima, foram criados duas chaves dentro da minhas pasta de usuário do windows e dentro outr diretporio chamado .ssh que contém as chaves, vamos entrar nesse diretório e verificar os arquivos que estão lá (no meu caso: C:/Users/haylson/.ssh/ conforme imagem abaixo):

Verifique se a sua pasta .ssh não está oculta, e deve conter os dois arquivos acima dentro dela (id_rsa e id_rsa.pub).

O que vai interessar para nós é o arquivo id_rsa.pub, abra ele com um bloco de notas, e copie todo o código gerado nele, que será algo como na imagem a seguir.

Agora acesse seu GitHub, procure a opções Settings > SSH and GPG keys > Clique em New SSH key, em Title você pode colocar um titulo qualquer como o nome do seu computador, e na opção Key cole todo o conteúdo que você copiou do arquivo id_rsa.pub, e logo em seguida clique no botão verde “Add SSH Key” conforme imagem a seguir.

Chave SSH criada no GitHub

6 – Criando um novo Repositório Remoto

Agora criamos um Repositório dentro do GitHub, na opção New repository, e chamaremos ele de “meugithub”, colocamos uma descrição qualquer, descrevendo do que se trata o repositório, marcamos a opção Public para repositório público, já que esta é a opção gratuita (para colocar a opção Private/Privado você tem que pagar um plano mensal no Github, por isso desconsideramos essa opção nesse momento), e clicamos em Create repository como mostramos na imagem a seguir:

Na tela seguinte, nos aparece algumas opções como: criar um repositório do zero, criar um repositório existente, ou importar código de outro repositório como mostra a imagem a seguir.

Como queremos criar um repositório de um projeto já existente em nosso computador, o ProjetoTeste, vamos na segunda opção “or push an existing repository from the command line”, colocamos na opção SSH e copiamos o código gerado que devemos utilizar no Git Bash para integrar nosso repositório local com o nosso repositório online criado no github.

Abrimos novamente o Git Bash, navegamos até a pasta do nosso projeto ProjetoTeste (que foi criado nosso repositório local) e executamos o código que nos foi gerado dentro do GitHub apontando para o nosso repositório online que acabamos de criar.

No nosso exemplo o comando ficou assim (no seu caso deve mudar o endereço do seu repositório criado):

git remote add origin github.com/haymartins/meugithub.git
git push -u origin master

E finalmente o projeto está sincronizando com o repositório remoto no GitHub.

Git Flow

Configuração inicial (aplica apenas a primeira vez):

 git flow init 

Which branch should be used for bringing forth production releases?
[Qual branch deve ser usada para trazer liberações de produção?]– development
– master
Branch name for production releases: [master] => Enter
[Nome da branch para versões de produção]

Which branch should be used for integration of the “next release”?
[Qual branch deve ser usada para integração do “próximo release”?]– development
Branch name for “next release” development: [] => “digitar” development
[Nome da branch para a “proxima versao” de desenvolvimento]

How to name your supporting branch prefixes?
Feature branches? [feature/]Bugfix branches? [bugfix/]Release branches? [release/]Hotfix branches? [hotfix/]Support branches? [support/]Version tag prefix? [] v- (padrão v-)
Hooks and filters directory? [D:/ambiente_desenvolvimento/workspace/nome-projeto/.git/hooks]

Usando os comandos do Git Flow:

*** Criando Novas branchs (Exemplos) ***

 git flow feature start <nome-branch> 

git flow feature start [nome-da-branch-a-ser-criada]git flow bugfix start [nome-da-branch-a-ser-criada]git flow hotfix start [nome-da-branch-a-ser-criada]git flow release start [nome-da-branch-a-ser-criada]

 

[Termos]feature: uma funcionalidade nova.
bugfix: correção de bug que ainda nao foi pra produção.
hotfix: correção de bug em produção.
release: liberação de uma nova release.

*** Finalizando uma branch ***

 git flow feature finish <nome-branch> 

git flow feature finish [nome-da-branch-a-ser-criada]git flow bugfix finish [nome-da-branch-a-ser-criada]git flow hotfix finish [nome-da-branch-a-ser-criada]git flow release finish [nome-da-branch-a-ser-criada]

• Se der merge, corrigir, commitar e dar um push, depois um pull para atualizar a development.

*** Remover Git Flow ***

git config –remove-section “gitflow.path”
git config –remove-section “gitflow.prefix”
git config –remove-section “gitflow.branch”

Stage or Unstage

Para começar a rastrear arquivos, ou colocar no estado stage, fazemos:

 git add . 

 git add nome-arquivo 

Para reverter, colocar um arquivo que está stage, para o estado unstage:

 git reset HEAD <nome-arquivo> 

Resetar um arquivo

Descartar todas as alterações feitas em todos os arquivos alterados:

 git checkout -- . (hífen, hífen, espaço depois ponto final)

Descartar alterações de apenas um arquivo específico:

 git checkout -- <caminho/nome-do-arquivo> 

Outros Comandos:

Criar uma branch local:

 git checkout -b nome-branch-local 

Listar todas as branchs locais:

 git branch

Listar Branchs remotas:

 git branch -r 

Listar Todas as Branchs remotas e locais:

 git branch -a 

Empurrando/Enviando seu branch local para a branch remota (devem ter o mesmo nome):

 git push origin nome-da-branch-remota 

Interface gráfica padrão do Git:

 gitk 

Lista de Logs de commits criados linha a linha resumido:

 git log --oneline 

Amend (– -amend) – adiciona o seu commit atual a outro commit anterior, caso tenha esquecido:

 git commit --amend -m "aqui deve ter o mesmo texto do commit anterior, usar seta pra cima se for o caso" 

Criar uma branch sendo cópia de outra branch

 git checkout -b [nome-da-nova-branch-a-ser-criada] [nome-da-branch-que-deseja-copiar]

Criando uma branch remota (e efetuando o push da branch local ao mesmo tempo)
Obs: dê preferência a usar o mesmo nome da [branch-local]

 git push -u origin [nome-branch-remota] 

Criando uma branch remota (e efetuando o push da branch local)
Obs: com o mesmo nome da [branch-local]

 git push --set-upstream origin [nome-branch-remota-mesmo-nome-da-local] 

Realizando Merge entre duas branchs

git checkout <branch-principal> (ex: dese, homol ou master por exemplo)
git pull (faz o pull da branch-principal para atualizar)
git merge <branch_feature> (é a branch que voce criou/alterou algo)
* ou substituindo o passo acima, você pode dar um checkout pra sua branch da atividade e puxar a 
branch principal para ela, caso queira só atualizar sua branch com a master sem mexer na master, 
continuando com os seguintes passos:
git checkout <sua-branch>
git merge <branch-principal>
(caso dê conflitos aqui, seguir os passos abaixo) 
-- alterar manualmente os arquivos, resolvendo os conflitos. 
git add . 
git commit -m "mensagem" (exemplo de mensagem: merge de branch a com branch b)
--------------- Uma segunda Forma -------------------
git checkout <branch-principal> (ex: dese, homol ou master por exemplo)
git pull (faz o pull da branch-principal para atualizar)
git pull origin <nome-da-branch-a-ser-adicionada-na-principal>
git push (caso dê conflito, corrigir manualmente)

Excluindo Branchs

git branch -D <nome-da-branch>  (excluindo branch local) 
git branch -dr origin/nome-da-branch-remota (excluindo branch remota)

Incluir na stash um arquivo não monitorado pelo git

git stash --include-untracked

Criando um Merge Request pelo GitLab

Tela 01

Tela 02

Tela 03

Tela 04

Tela 05