Pesquisa de site

Como usar o sistema de controle de versão Git no Linux [Guia abrangente]

Controle de versão (controle de revisão ou controle de origem) é uma forma de registrar alterações em um arquivo ou coleção de arquivos ao longo do tempo para que você possa recuperar versões específicas posteriormente. Um sistema de controle de versão (ou VCS em resumo) é uma ferramenta que registra alterações em arquivos em um sistema de arquivos.

Existem muitos sistemas de controle de versão por aí, mas o Git é atualmente o mais popular e usado com frequência, especialmente para gerenciamento de código-fonte. Na verdade, o controle de versão pode ser usado para praticamente qualquer tipo de arquivo em um computador, não apenas para o código-fonte.

Os sistemas/ferramentas de controle de versão oferecem vários recursos que permitem que indivíduos ou grupos de pessoas:

  • criar versões de um projeto.
  • rastreie as mudanças com precisão e resolva conflitos.
  • mesclar as alterações em uma versão comum.
  • reverter e desfazer alterações em arquivos selecionados ou em um projeto inteiro.
  • acessar versões históricas de um projeto para comparar mudanças ao longo do tempo.
  • veja quem modificou pela última vez algo que pode estar causando um problema.
  • crie um backup externo seguro de um projeto.
  • use várias máquinas para trabalhar em um único projeto e muito mais.

Um projeto sob um sistema de controle de versão como o Git terá principalmente três seções, a saber:

  • um repositório: um banco de dados para registrar o estado ou alterações nos arquivos do seu projeto. Ele contém todos os metadados e objetos Git necessários para o novo projeto. Observe que normalmente é isso que é copiado quando você clona um repositório de outro computador em uma rede ou servidor remoto.
  • um diretório ou área de trabalho: armazena uma cópia dos arquivos do projeto nos quais você pode trabalhar (fazer adições, exclusões e outras ações de modificação).
  • uma área de teste: um arquivo (conhecido como índice no Git) dentro do diretório Git, que armazena informações sobre alterações que você está pronto para enviar (salvar o estado de um arquivo ou conjunto de arquivos) no repositório.

Existem dois tipos principais de VCSs, sendo a principal diferença o número de repositórios:

  • Sistemas Centralizados de Controle de Versão (CVCSs): aqui cada membro da equipe do projeto obtém seu próprio diretório de trabalho local, porém, eles enviam alterações para apenas um único repositório central.
  • Sistemas de controle de versão distribuídos (DVCSs): sob isso, cada membro da equipe do projeto obtém seu próprio diretório de trabalho local e diretório Git onde pode fazer commits. Depois que um indivíduo faz um commit localmente, outros membros da equipe não podem acessar as alterações até que ele as envie para o repositório central. Git é um exemplo de DVCS.

Além disso, um repositório Git pode ser vazio (um repositório que não possui um diretório de trabalho) ou não-nuo (um com um diretório funcional). diretório). Repositórios compartilhados (ou públicos ou centrais) devem estar sempre vazios – todos os repositórios do Github estão vazios.

Aprenda controle de versão com Git

Git é um sistema de controle de versão gratuito e de código aberto, rápido, poderoso, distribuído, fácil de usar e popular, muito eficiente em grandes projetos e com um notável sistema de ramificação e fusão. Ele foi projetado para lidar com dados mais como uma série de instantâneos de um mini sistema de arquivos, que é armazenado em um diretório Git.

O fluxo de trabalho no Git é muito simples: você faz modificações nos arquivos em seu diretório de trabalho e, em seguida, adiciona seletivamente apenas os arquivos que foram alterados, à área de teste, para fazer parte do seu próximo commit.

Quando estiver pronto, você faz um commit, que pega os arquivos da área de teste e salva esse instantâneo permanentemente no diretório Git.

Para instalar o Git no Linux, use o comando apropriado para sua distribuição preferida:

sudo apt install git   [On Debian/Ubuntu]
sudo yum install git   [On CentOS/RHEL]

Depois de instalar o Git, é recomendado que você diga ao Git quem você é, fornecendo seu nome completo e endereço de e-mail, como segue:

git config --global user.name “Aaron Kili”
git config --global user.email “[email ”

Para verificar suas configurações do Git, use o seguinte comando.

git config --list

Cria um novo repositório Git

Repositórios compartilhados ou fluxos de trabalho centralizados são muito comuns e é isso que demonstraremos aqui. Por exemplo, presumimos que você foi encarregado de configurar um repositório central remoto para administradores/programadores de sistema de vários departamentos da sua organização, para trabalhar em um projeto chamado bashscripts, que será armazenado em /projects/scritpts/ no servidor.

SSH no servidor remoto e crie o diretório necessário, crie um grupo chamado sysadmins (adicione todos os membros da equipe do projeto a este grupo, por exemplo, usuário admin) e defina as permissões apropriadas em este diretório.

mkdir-p /projects/scripts/
groupadd sysadmins
usermod -aG sysadmins admin
chown :sysadmins -R /projects/scripts/
chmod 770 -R /projects/scripts/

Em seguida, inicialize um repositório de projeto vazio.

git init --bare /projects/scripts/bashscripts

Neste ponto, você inicializou com sucesso um diretório Git vazio, que é o recurso de armazenamento central do projeto. Tente fazer uma listagem do diretório para ver todos os arquivos e diretórios contidos nele:

ls -la /projects/scripts/bashscripts/

Clonar um repositório Git

Agora clone o repositório Git compartilhado remoto em seu computador local via SSH (você também pode clonar via HTTP/HTTPS se tiver um servidor web instalado e configurado adequadamente, como é o caso da maioria dos repositórios públicos no Github), por exemplo:

git clone ssh://admin@remote_server_ip:/projects/scripts/bashscripts

Para cloná-lo em um diretório específico (~/bin/bashscripts), use o comando abaixo.

git clone ssh://admin@remote_server_ip:/projects/scripts/bashscripts ~/bin/bashscripts

Agora você tem uma instância local do projeto em um repositório não vazio (com um diretório de trabalho), você pode criar a estrutura inicial do projeto (ou seja, adicionar um README.md arquivo , subdiretórios para diferentes categorias de scripts, por exemplo, recon para armazenar scripts de reconhecimento, sysadmin ro armazenar scripts sysadmin, etc.):

cd ~/bin/bashscripts/
ls -la

Verifique um resumo do status do Git

Para exibir o status do seu diretório de trabalho, use o comando status que mostrará todas as alterações feitas; quais arquivos não estão sendo rastreados pelo Git; aquelas mudanças que foram encenadas e assim por diante.

git status

Mudanças e commit no estágio Git

Em seguida, prepare todas as alterações usando o comando add com a opção -A e faça o commit inicial. O sinalizador -a instrui o comando a preparar automaticamente os arquivos que foram modificados, e -m é usado para especificar uma mensagem de commit:

git add -A
git commit -a -m "Initial Commit"

Publicar commits locais no repositório Git remoto

Como líder da equipe do projeto, agora que você criou a estrutura do projeto, você pode publicar as alterações no repositório central usando o comando push conforme mostrado.

git push origin master

No momento, seu repositório git local deve estar atualizado com o repositório central do projeto (origem). Você pode confirmar isso executando o comando status mais uma vez.

git status

Você também pode informar seus colegas para começarem a trabalhar no projeto clonando o repositório em seus computadores locais.

Crie uma nova ramificação Git

A ramificação permite que você trabalhe em um recurso do seu projeto ou corrija problemas rapidamente sem tocar na base de código (ramificação mestre). Para criar um novo branch e depois mudar para ele, use os comandos branch e checkout respectivamente.

git branch latest
git checkout latest

Alternativamente, você pode criar um novo branch e mudar para ele em uma única etapa usando o comando checkout com o sinalizador -b.

git checkout -b latest

Você também pode criar uma nova ramificação baseada em outra ramificação, por exemplo.

git checkout -b latest master

Para verificar em qual branch você está, use o comando branch (um asterisco indica o branch ativo):

git branch

Depois de criar e mudar para o novo branch, faça algumas alterações nele e faça alguns commits.

vim sysadmin/topprocs.sh
git status
git commit add  sysadmin/topprocs.sh
git commit -a -m 'modified topprocs.sh'

Mesclar alterações de uma ramificação para outra

Para mesclar as alterações do teste de ramificação na ramificação master, mude para a ramificação master e faça a mesclagem.

git checkout master 
git merge test

Se você não precisar mais de um branch específico, poderá excluí-lo usando a opção -d.

git branch -d test

Baixar alterações do repositório central remoto

Supondo que os membros da sua equipe tenham enviado as alterações para o repositório central do projeto, você pode fazer download de quaisquer alterações para a instância local do projeto usando o comando pull.

git pull origin
OR
git pull origin master	#if you have switched to another branch

Inspecione o repositório Git e faça comparações

Nesta última seção, abordaremos alguns recursos úteis do Git que rastreiam todas as atividades que aconteceram em seu repositório, permitindo assim que você visualize o histórico do projeto.

O primeiro recurso é o log do Git, que exibe logs de commit:

git log

Outra funcionalidade importante é o comando show que exibe vários tipos de objetos (como commits, tags, árvores etc.):

git show

O terceiro recurso vital que você precisa conhecer é o comando diff, usado para comparar ou mostrar diferenças entre ramificações, exibir alterações entre o diretório de trabalho e o índice, alterações entre dois arquivos no disco e muito mais.

Por exemplo, para mostrar a diferença entre o branch master e o mais recente, você pode executar o seguinte comando.

git diff master latest

Leia também: 10 melhores alternativas Git para hospedar projetos de código aberto

Resumo

O Git permite que uma equipe de pessoas trabalhe em conjunto usando o(s) mesmo(s) arquivo(s), enquanto grava alterações no(s) arquivo(s) ao longo do tempo para que possam recuperar versões específicas posteriormente.

Dessa forma, você pode usar o Git para gerenciar código-fonte, arquivos de configuração ou qualquer arquivo armazenado em um computador. Você pode consultar a documentação on-line do Git para obter mais documentação.