Leia também o artigo:
Home / Git / Como usar o Git e o GitHub em projetos já existentes?

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

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

git-e-github-01
git e github 01

 

git-e-github-02
git e github 02

 

git-e-github-03
git e github 03

 

git-e-github-04
git e github 04

 

git-e-github-05
git e github 05

 

git-e-github-06
git e github 06

 

git-e-github-07
git e github 07

 

git-e-github-08
git e github 08

 

git-e-github-09
git e github 09

 

git-e-github-10
git e github 10

 

git-e-github-11
git e github 11

 

git-e-github-12
git e github 12

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

GitBash
GitBash

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.)

github-free
github-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.

projeto-teste
projeto teste

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
prompt-gitbash
prompt gitbash

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.

git-init
git init

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

git status
git-status
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
git-add
git add

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).

git-local
git local

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.

git-commit
git commit

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.

git-status2
git status2

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.

arquivos-ignorados
arquivos ignorados

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.

git-status-ignorados
git status ignorados

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.

gitignore
gitignore

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.

git-status-gitignore
git status gitignore

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
ssh-keygen
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):

pasta-ssh
pasta ssh

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.

arquivo-id_rsa_pub
arquivo id_rsa_pub

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.

github-ssh-key
github ssh key

Chave SSH criada no GitHub

github-ssh-key-criada
github ssh key criada

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:

repositorio-github
repositorio github

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.

github-opcoes
github opcoes

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
integrando-com-github
integrando com github 1

 

integrando-com-github2
integrando com github 2

 

integrando-com-github3
integrando com github 3

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

integrando-com-github4
integrando com github 4

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 

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] 

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)
(caso dê conflitos aqui, segue os passos abaixo)
-alterar manualmente os arquivos, resolvendo os conflitos.
git add .
git commit -m "mensagem exemplo: 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)

 Descartar todas as alterações feitas

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

Descartar alterações de um arquivo específico

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

 

Sobre Haylson Martins

Me chamo Haylson Martins, formado em Sistemas de Informação, trabalho com T.I de forma geral desde 2002 com suporte depois na área de negócio e treinamentos, e com Desenvolvimento para Sistemas Web desde 2010 com linguagem principal o Java. Amo tecnologia, amo aprender coisas novas, gosto de ensinar embora não seja essa a minha pretensão. Por meio desse blog pretendo reforçar o que ando aprendendo e estudando de outras linguagens e tecnologias, e principalmente como uma espécie de bloco de notas para consultas posteriores e quem sabe também ajude outras pessoas que estudam e têm as mesmas dúvidas que já tive ou que ainda tenho. Vamos começar?

30 comments

  1. E aí, esse artigo foi útil para você? Comenta aí!

  2. Boa matéria parabéns

  3. Jeonatã Oliveira

    Agradeço pela matéria, foi muito útil.

  4. Alainy Viana

    e se eu fosse usar aquela primeira opção, teria como vc dar uma explicada??

  5. A chave ssh tem que ser inserida em settings a cada projeto?

  6. muito bem explicado me ajudou muito com trabalho da faculdade
    Deus te abençoe pela sua bondade e dedicação em ensinar

  7. Obrigada! Ajudou muito 😀

  8. David Silveira

    Também sou de Fortaleza e formado pela estácio. Muito bom seu passo a passo. Na internet existem várias pessoas com boa vontade ensinando, mas confesso que o seu passo a passo foi o melhor, impossível não aprender vendo esse tutorial. Obrigado.

  9. Jonas Henrique Nascimento

    Me ajude por favor. Estou com o seguinte erro no GIT ao tentar upar o código para o github:

    Jonas@DESKTOP-D0J98QO MINGW64 /f/Documentos/python/jogos/jogo_da_velha (master)
    $ git remote add origin git@github.com:W8jonas/jogo_da_velha_.git
    fatal: remote origin already exists.

    Jonas@DESKTOP-D0J98QO MINGW64 /f/Documentos/python/jogos/jogo_da_velha (master)
    $ git push -u origin master
    git@github.com: Permission denied (publickey).
    fatal: Could not read from remote repository.

    Please make sure you have the correct access rights
    and the repository exists.
    Desde já, agradeço.

  10. Emanuelly Oliveira

    Muito bom o seu blog, os artigos são bem explicados e o seu vídeo no youtube também.

  11. Sou iniciante em git e github qual o comando para atualizar o repositório remoto?

  12. Muito bem explicado parabéns!

  13. Meus Parabéns, explicação muito boa! Estava com muitas duvidas e vc me deu uma luz muito obrigada que Deus te abençoe sempre!

  14. Alexandre Camilo

    Até que enfim consegui entender como usar o GIT! Obrigado por compartilhar seu conhecimento!

  15. Sensacional!! Parabens muito bem explicado!

  16. Boa Tarde, Haylson MArtins Muito boa sua aula.
    Vc não deixou a desejar nos detalhes.
    Vc sabe se no mesmo computador local eu consigo adicionar outras ssh? e com outro usuário no github?
    Caso tenha alguma dica

    • Haylson Martins

      Fala Rafael, valeu pelo comentário. Sobre sua pergunta, sinceramente não sei responder pois nunca tentei adicionar outro usuário. Abraço.

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *