Aprendendo GiT + GitHub de uma vez por todas?
- #GitHub
- #Git
Entendendo Git e GitHub de uma vez por todas (tutorial com imagens)!
Este é um tutorial para quem quer aprender (ou relembrar) rapidamente GIT (e GITHUB), talvez já tenha tentado aprender e não conseguiu, este pode ser o tutorial certo!
*inicialmente a ideia era apenas para ser um tutorial rápido para os outros, acabou se tornando um tutorial de referência para eu mesmo relembrar comandos básicos de git no terminal:
Primeiro você precisa saber se no seu computador e sistema operacional o git já está instalado, basta abrir o terminal e digitar: "git --version" git(espaço)--version
Então o terminal precisa retornar a versão, senão houver basta instalar no site oficial: https://git-scm.com
Após a instalação, execute o comando: git --version (no terminal novamente, para saber a versão do git instalado, se não retornar a versão, reinicie seu computador e tente executar o comando novamente) e feche o terminal.
Feito isso vamos iniciar nosso tutorial prático:
1- Primeiro criar uma pasta no desktop mesmo e chamar de "projetogit:"
2- Dentro da pasta, na aba da pasta "view"clique para: "mostrar arquivos ocultos" para conseguir ver a pasta ".git" que será criada.
3- Novamente dentro da pasta, clique com o botão esquerdo do mouse e "inicie o terminal".
Mas antes:
4- Descubra se o "user.name" do seu git já está configurado, digite no terminal (sem as aspas): "git config --global user.name", se não houver retorno, vocôe precisa configurar, para usar git essas são as 2 configurações básicas: "nome de usuário" e "email", então para adicionar o nome de usuário basta repetir o comando e adicionar o nome: "git config --global user.name Fulano", veja o exemplo na imagem abaixo
5- Descubra se o "user.email" do seu git já está configurado, digite no terminal (sem as aspas): "git config --global user.email", se quiser trocar basta repetir o comando e adicionar o nome: "git config --global user.email fulano@email.com"
Verificando e Iniciando o GIT:
6- No terminal digite: git status que retornará um erro avisando que não há um repositório ou pasta .git.
7- No terminal digite: "git init" para iniciar o git dentro desta pasta, se você ativou a opção de: "ver arquivos ocultos" na pasta então verá a pasta: ".git" o terminal também exibirá um aviso que o repositório foi criado. Você também pode conferir usando o comando: "git status".
Na Branch:
8- Você estará dentro da "branch master" ou "main branch" ou "branch (ramo) principal", para mudar o nome da sua branch use o comando: "git branch -m main" e o nome da branch agora será "main", que é o nome mais utilizado, para verificar utilize novamente o comando: "git status".
Adicionando um arquivo no repositório local:
9- Na pasta crie um: "arquivo1.py", no terminal, execute novamente o comando: "git status" para ver o status, execute o comando: "git add arquivo1.py", execute novamente o comando: "git status" para ver o novo status.
"Commitando":
10- No terminal execute: "git commit -m 'primeiro commit' arquivo1.py"
FIM do tutorial de GIT (por enquanto).
-Inicio do tutorial de GITHUB:
1. No site do github crie sua conta.
2. Crie um novo repositório: "projetogithub", conecte este "repositório remoto do github" com o seu "repositório local". Para isso dentro da pasta "projetogit" abra o terminal e execute o comando (sempre sem as aspas): "git remote add origin https://github.com/(seunomedeusuário)/projetogithub.git".
Para verificar se deu tudo certo execute: "git remote -v".
Iniciando o envio de arquivos para o Repositório Remoto do GITHUB via conexão HTTPS:
3. Com o terminal aberto "dentro da pasta"(/Desktop/usuário/projetogit$) execute o comando:
"git push -u origin main"
que vai pedir seu usuário do github, e senha que deve ser um "token de acesso pessoal", se você ainda não tem um, crie da seguinte maneira abaixo:
Criando um Token de Acesso Pessoal (classic):
4. Clique na foto do seu perfil, no canto superior direito e selecione "settings" depois clique em: "< > Developer settings", depois em: "Tokens (classic)" e por fim em: "Generate new token (classic)", configure a expiração e as permissões para criar o token, após a sua criação, copie o token (guarde para usá-lo depois se precisar novamente) e cole no password requisitado no terminal (para colar no terminal: "Ctrl+Shift+v").
*4.2. Para não precisar ficar digitando sempre o usuário e a senha sempre que tiver de fazer alguma alteração no repositório remoto execute o comando: "git config --global credential.helper store" e assim ele vai armazenar suas credenciais para não precisar digitar novamente usuário e senha (token classic).
4.3. Para saber onde estas informações estão sendo armazenadas, basta executar o comando: "git config --global --show-origin credential.helper" que no meu caso vai estar na pasta: "/home/venelouis/.gitconfig" ao ir na pasta ative a visualização de "arquivos ocultos" lá vai estar também o arquivo: ".git-credentials" que podemos acessar através do próprio terminal utilizando o comando: "cd /home/venelouis/" executar o comando: "ls -a" para listar todos os arquivos e pastas (inclusive os ocultos) e por fim podemos utilizar o comando: "cat .gitconfig" para ver o que está no arquivo: ".gitconfig" e executar também: "cat .git-credentials" e lá vão estar suas credenciais globais e sua senha (seu token classic), ou seja se por questões de segurança precisarmos inibir o acesso podemos mudar a senha ou apenas deletar o arquivo, mas no próprio site do github podemos remover-deletar esse token também.
Verificando o envio do "arquivo1.py" do repositório local para o repositório remoto:
5. visite seu o repositório no criado no github que nomeamos de: "projetogithub".
Git Push, Mandando arquivos do Repositório Local para o Repositório Remoto GitHub:
6. Modifique o "arquivo1.py" no seu computador e salve, após isso no terminal dentro da pasta execute o comando: "git status".
7. Execute: "git add ." para adicionar todas modificações dentro da sua pasta "projetogit".
8. Execute: "git status" novamente para visualizar as modificações.
9. Execute: "git commit -m 'commitando modificação do "arquivo1.py" para o repositório remoto' ".
10. Execute novamente: "git status" para verificar que sua "branch main local" está mais atualizada do que a sua "branch main remota" e para que ambas estejam atualizas igualmente execute finalmente mais uma vez: "git push".
Git Pull, Recebendo arquivos do Repositório Remoto GitHub para o Repositório Local:
11. No repositório do Github altere o seu "arquivo1.py" e faça um "commit".
12. Se você executar o comando "git status" no seu terminal talvez ele exiba a mensagem "your branch is up to date with 'origin/main'." o que é falso pois acabamos de alterar o arquivo1.py no repositório remoto e se verificarmos o "arquivo1.py" no repositório local (pasta: "projetogit") ele continua sem a alteração.
13. Então com o terminal "aberto na pasta do projeto" execute o comando "git pull", se pedir coloque novamente usuário e senha (token de acesso pessoal (classic) do github), pronto você verá a confirmação no terminal e agora se você abrir no repositório local (pasta "projetogit") o "arquivo1.py" vai ver que foi alterado.
Git Clone:
14. Vamos imaginar que você está em outro computador, e quer modificar o seu código remoto do github no seu computador em um repositório local, para isso você utiliza o comando: "git clone" na pasta desejada, veja como utilizar este comando abaixo:
15. Então crie uma outra pasta no seu desktop chamada: "NovoComputador" e abra o terminal dentro desta pasta e execute o comando:
"git clone https://github.com/(seunomedeusuário)/projetogithub.git"
Se precisar coloque novamente usuário e senha (personal token (classic)) e pronto, a pasta "projetogithub" será adicionada no seu "NovoComputador" (pasta) juntamente com o "arquivo1.py" e a pasta oculta: ".git".
15.2. * Apenas como curiosidade, se quizermos clonar apenas uma branch podemos utilizar o comando:
"git clone -b <branchname> <remote-repo-url>"
Modificando o repositório remoto do GitHub no seu "NovoComputador":
16. Na sua pasta "NovoComputador" modifique o "arquivo1.py" e salve.
17. No terminal execute os comandos: "git add ." para adicionar a alteração ao git.
18. Para verificar utilize o comando: "git status"
19. Depois: "git commit -m 'alteração a partir do NovoComputador'
20. Por fim como é a primeira vez de um que o push está sendo feito deste novo repositório local, ou seja pasta "NovoComputador" precisamos executar o comando no terminal dentro desta pasta:
"git push -u origin main".
E podemos verificar no repositório remoto (github) a última alteração e o histórico de commits:
Criando Branches (Ramos) no Git/GitHub:
21. Agora novamente dentro da pasta "projetogit" vamos abrir o terminal e executar o comando: "git branch teste".
22. Para verificar as branches existentes no seu repositório basta executar o comando: "git branch", e o terminal vai listar as branches existentes e destacar em qual branch você está.
23. Para entrar na nova branch criada execute no terminal (dentro da pasta desejada em que criou a nova branch) o comando: "git checkout teste" e você vai mudar para a branch "teste".
24. Execute o comando "git branch" para verificar a mudança.
24.2. Para criar uma nova branch e mudar para ela rapidamente basta executar o comando:
"git checkout -b novabranch".
Trabalhando com Branches:
25. Dentro branch "teste2" na pasta "projetogit" crie um novo: "arquivo2.py", execute o comando "git status" para verificar que o arquivo foi criado na branch "teste2".
26. Novamente no terminal dentro da pasta e execute: "git add ."
27. Utilize o comando: "git status" para verificar que a mudança foi adicionada na branch "teste2".
28. Depois execute: "git commit -m 'commit na branch teste2'.
29. Execute o comando: "git checkout main" e veja que na pasta "projetogit" que o "arquivo2.py" parece ter "sumido" da pasta. Para voltar basta executar: "git checkout teste2".
Branches Remotas:
30. Para ver as branches remotas (github) existentes execute no terminal: "git branch -r".
31. Para ver todas as branches: locais e remotas execute: "git branch -a".
Enviando "arquivo2.py" da branch "teste2" para o Repositório Remoto Github:
32. Execute o comando: "git push -u origin teste2"
33. Execute: "git branch -a" para verificar que agora temos 2 branches remotas.
Excluindo Branches
34. Não se pode excluir uma branch dentro dela, portanto vamos criar uma nova branch "teste1" e entrar nela utilizando o comando: "git checkout -b teste1". E utilizando o comando: "git branch" para verificar que saímos da branch "teste".
35. E agora utilizamos o comando: "git branch -D teste". Para conferir que a branch "teste" foi realmente excluida basta executar novamente o comando: "git branch", contudo este comando exclui apenas a branch no repositório local.
36. Para excluir uma branch no repositório remoto, vamos rapidamente criar uma branch com o comando: "git checkout -b teste3" e enviá-la para o repositório remoto utilizando o comando: "git push origin teste3".
37. E por fim vamos excluir essa branch remota utilizamos o comando: "git push -d origin teste3" e exclui-lo da branch local também, entrando na branch "main" com o comando: "git checkout main" e utilizando o comando: "git branch -D teste3". Para verificar basta executar: "git branch -a".
Unindo Branches (Git Merge):
38. Precisamos estar dentro da branch que queremos unir, no caso: "teste1" com a "teste2", portanto no terminal executamos o comando: "git checkout teste2", vamos criar um novo "arquivo3.py", e no terminal executar: "git add ." e 'git commit -m "criação do novo arquivo3.py".'
39. Este "arquivo3.py" vai aparecer apenas na branch "teste2", se executarmos o comando: "git checkout teste1" veremos que ele não aparece na branch "teste1".
40. Para isso basta que executemos o comando: "git merge teste2" e agora veremos as branches "teste1"
e "teste2" com os mesmos arquivos.
41. Vamos publicar tudo para o repositório remoto do github: "git push". Contudo vai aparecer uma mensagem de erro (se estivermos na branch "teste1"), pois a branch "teste1" ainda não está no repositório remoto como podemos conferir: "git branch -a".
42. Então vamos enviar a branch "teste1" executando: "git push -u origin teste1" e verificar novamente executando: "git branch -a".
43. Se tentarmos executar: "git push" dentro da branch "teste1" o terminal vai retornar a mensagem que tudo está atualizado. Mas a branch "teste2" está um "commit" a frente do repositório remoto como poderemos ver se mudarmos pra branch "teste2" com o comando: "git checkout teste2" e executarmos posteriormente: "git status".
44. Então agora sim vamos executar o "git push" para deixar tudo igual: repositório local e remoto. Executamos "git status" e fazemos "git checkout main" para confirmar tudo, também podemos ir no github e verificar cada uma das branches e arquivos.
Git Tag e Release:
45. Feito tudo, vamos criar uma "tag" que é como se fosse a "versão" do nosso repositório que pode ser um programa ou software e etc. Executando no terminal: "git tag -a 1.0.0 -m 'Versão Inicial'." E enviar para o repositório remoto: "git push --tags". Para verificar execute: "git show 1.0.0"
46. Depois é só fazer a "release" (lançamento) que vai estar na opção da "tag" no github.
.gitignore
47. Para projetos grandes geralmente se cria o arquivo de texto ".gitignore" para excluir arquivos de entrarem no projeto acidentalmente.
Fim deste super tutorial básico de Git e Github (por enquanto)?
Não, vamos aos "Comandos Avançados":
- "git log": para ver todo o "histórico de commits".
- "git rm -f arquivo.py": remove (deleta) o "arquivo.py".
- "git revert (+id do commit)": restaura o commit anterior (guarda o histórico).
- "git reset (+id do commit)": volta ao estado completo antes do commit (não guarda nenhum histórico).
- "git stash" (depois de executar o "git add ." em um arquivo modificado): retira um ou mais arquivos para uma área de "stash" que pode ser colocada novamente com o comando: "git stash apply (+ o índice da stash)", por exemplo executando o comando: "git stash list" e selecionando: "git stash apply "stash@{3}" ou apenas: "git stash apply 3" (sem tirar da stash), para aplicar e retirar da stash, utilizamos o comando: "git stash pop 3". E se quisermos limpar a "stash" utilizamos o comando: "git stash clear" (deletar tudo) ou "git stash drop 0" (para deletar apenas o índice selecionado).
*Para criar e colocar uma mensagem na "stash" para ficar mais fácil de localizar na lista, utilizamos o comando: "git stash push -m 'mensagem' " e assim saberemos identificar melhor qual stash queremos após executar: "git stash list".
Agora sim talvez tenhamos acabado com os principais comandos de git/github no terminal.
Mas estas não são as únicas maneiras de utilizar o git/github (terminal e direto no website), existem as interfaces gráficas como:
- > Github Desktop, Git Kraken, e outros que podem ser grátis (para 1 usuário em repositórios abertos) e pagos (para times e repositórios fechados).
-> VSCode puro e/ou + extensões como: GitLens, Git Pull-Requests, etc.
O que é isso (no Github)?
- Fork: copiar todo o repositório para o seu pŕoprio perfil para ter total liberdade para modificar o código e até realizar pull-requests
- issues: "problemas" que são relatados nos repositórios.
- project: planejamento do projeto em tabelas.
- actions: são automações para corrigir, atualizar, fazer deploy, etc.
- wiki: como se fosse uma enciclopédia do seu repositório, com várias páginas e etc.
- marketplace: loja de extensões para integração.
- gists: lugar para compartilhamento de código.
- githubpages: um site seu frontend grátis no github, tutorial completo em: https://pages.github.com/
->> Dica de OURO: Github Education - se você é estudante em instituição de ensino (fundamental, médio ou superior) a platafomra github oferece diversos benefícios, para saber todos os detalhes acesse: https://education.github.com/
Por fim... Por que não abordei conexão via SSH?
-> A resposta mais votada no Stackoverflow sobre o tema:
O GitHub mudou sua recomendação várias vezes (exemplo).
Parece que atualmente eles recomendam HTTPS porque é o mais fácil de configurar na mais ampla variedade de redes e plataformas, e por usuários que são novos em tudo isso.
Não há nenhuma falha inerente ao SSH (se houvesse, eles o desabilitariam) - nos links abaixo, você verá que eles também fornecem detalhes sobre as conexões SSH:
1. É menos provável que HTTPS seja bloqueado por um firewall.
Os URLs clones https:// estão disponíveis em todos os repositórios, independentemente da visibilidade. Os URLs clones https:// funcionam mesmo se você estiver atrás de um firewall ou proxy.
2. Uma conexão HTTPS permite que credential.helper armazene sua senha em cache.
https://docs.github.com/en/get-started/quickstart/set-up-git#connecting-over-https-recommended
Se você clonar com HTTPS, poderá armazenar em cache suas credenciais do GitHub no Git usando um auxiliar de credenciais. Para obter mais informações, consulte "Clonagem com URLs HTTPS" e "Armazenamento em cache de suas credenciais do GitHub no Git".
Extra:
Convenção de Commits - Tipo de Commit e Descrição:
- feat: Adiciona uma nova funcionalidade ao projeto.
- fix: Corrige um bug ou problema no projeto.
- docs: Altera a documentação do projeto. Ex.: README, comentários no código.
- style: Realiza mudanças na aparência, sem alterar a funcionalidade.
- refactor: Realiza mudanças no código que não alteram a funcionalidade.
- test: Adiciona ou modifica testes no projeto.
+ Algumas Referências:
CURIOSIDADE: se você estiver em um repositório github e aperta a tecla: "." (ponto final), você será redirecionado para um "visual studio code versão web" para editar o repositório. Se você apertar a tecla "," (virgula) será redirecionado para o Code Spaces que é quase a mesma coisa do outro, mas a diferença é que você pode usar os servidores para ver o código rodando.
Este mesmo material e mais alguns detalhes sobre como utilizar GitHub GUI (Graphical User Interface):
Curso de git+GitHub com certificado 100% grátis!
