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 maneira de gravar alterações em um arquivo ou coleta de arquivos ao longo do tempo, para que você possa se lembrar de versões específicas posteriormente. Um sistema de controle de versão (ou VCs Em resumo) é uma ferramenta que registra alterações nos arquivos em um sistema de arquivos.

Existem muitos sistemas de controle de versão por aí, mas Git atualmente é o mais popular e freqüentemente usado, especialmente para gerenciamento de código -fonte. O controle de versão pode ser usado para quase qualquer tipo de arquivo em um computador, não apenas o código -fonte.

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

• Crie versões de um projeto.
• Acompanhe as mudanças com precisão e resolva conflitos.
• mesclar mudanças em uma versão comum.
• Rollback e desfazer mudanças nos arquivos selecionados ou em um projeto inteiro.
• Acesse 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 fora do local seguro de um projeto.
• Use várias máquinas para trabalhar em um único projeto e muito mais.

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

• um repositório: Um banco de dados para gravar o estado ou alterações em seus arquivos de projeto. Ele contém todos os metadados e objetos necessários para o novo projeto. Observe que isso é normalmente o 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 em que você pode trabalhar (faça adições, deleções e outras ações de modificação).
• Uma área de estadiamento: um arquivo (conhecido como índice em Git) dentro do diretório Git, que armazena informações sobre alterações, que você está pronto para se comprometer (salve o estado de um arquivo ou conjunto de arquivos) no repositório.

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

• Sistemas de controle de versão centralizada (CVCSS): Aqui cada membro da equipe do projeto recebe seu próprio diretório de trabalho local, no entanto, eles cometem mudanças em apenas um único repositório central.
• Sistemas de controle de versão distribuída (DVCSs): Sob isso, cada membro da equipe do projeto recebe seu próprio diretório de trabalho local e diretório Git, onde eles podem fazer compromissos. Depois que um indivíduo se compromete localmente, outros membros da equipe não podem acessar as mudanças até que ele os empurre para o repositório central. Git é um exemplo de um DVCS.

Além disso, um Git O repositório pode ser nu (repositório que não tem um diretório de trabalho) ou não bare (um com um diretório de trabalho). Compartilhado (ou público ou central) Os repositórios devem sempre estar vazios - todos os repositórios do GitHub estão vazios.

Aprenda controle da versão com git

Git é um sistema de controle de versão popular e de código aberto, rápido, poderoso, distribuído, fácil de usar e popular, que é muito eficiente em grandes projetos e possui um sistema notável de ramificação e mesclagem. 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 sub Git é muito simples: você faz modificações nos arquivos no seu diretório de trabalho e adiciona seletivamente apenas os arquivos que mudaram, à área de estadiamento, para fazer parte do seu próximo compromisso.

Depois de estar pronto, você faz uma confirmação, que leva os arquivos da área de estadiamento e salva esse instantâneo permanentemente para o diretório Git.

Para instalar Git No Linux, use o comando apropriado para sua distribuição de escolha:

$ sudo apt install git [em Debian/Ubuntu] $ sudo yum install git [on CENTOS/RHEL] 

Depois de instalar o Git, é recomendável que você diga Git Quem você é fornecendo seu nome completo e endereço de e -mail, como segue:

$ Git Config -Usuário global.Nome “Aaron Kili” $ Git Config -Usuário global.Email “[Email protegido]” 

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

$ git config -lista 

Veja as configurações do Git

Cria um novo repositório Git

Compartilhado Repositórios ou fluxos de trabalho centralizados são muito comuns e é isso que vamos demonstrar aqui. Por exemplo, assumimos que você teve a tarefa de configurar um repositório central remoto para administradores/programadores de sistemas 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 criar o diretório necessário, crie um grupo chamado sysadmins (Adicione todos os membros da equipe do projeto a este grupo E.G Admin User Admin) e defina as permissões apropriadas neste diretório.

# mkdir -p/projects/scripts/ # groupadd sysadmins # userMod -Ag sysadmins admin # CHOW 

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

# git init -Bare/Projects/Scripts/Bashscripts 

Inicialize o repositório compartilhado do Git

Neste ponto, você inicializou com sucesso um nu Git Diretório, que é a instalação de armazenamento central para o projeto. Tente fazer uma lista do diretório para ver todos os arquivos e diretórios lá:

# LS -LA/Projects/Scripts/Bashscripts/ 

Lista Repositório compartilhado Git

Clone um repositório Git

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

$ git clone ssh: // [email protegido] _server_ip:/Projects/scripts/Bashscripts 

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

$ git clone ssh: // [email protegido] _server_ip:/Projects/scripts/Bashscripts ~/bin/baashscripts 

Clone compartilhou o repositório Git para o local

Agora você tem uma instância local do projeto em um não bare Repositório (com um diretório de trabalho), você pode criar a estrutura inicial do projeto (i.e adicione a Leia-me.MD Arquivo, subdiretos para diferentes categorias de scripts e.G Recon para armazenar scripts de reconhecimento, scripts de sysadmin ro lojas sysadmin etc etc.):

$ CD ~/BIN/BASHscripts/$ ls -la 

Crie a estrutura do projeto Git

Verifique um resumo do status Git

Para exibir o status do seu diretório de trabalho, use o Comando de status que mostrará quaisquer alterações que você fez; Quais arquivos não estão sendo rastreados pelo Git; aquelas mudanças que foram encenadas e assim por diante.

$ git status 

Verifique o status Git

Mudanças no palco e comprometimento

Em seguida, encene todas as mudanças usando o Adicionar comando com o -A alternar e fazer a confirmação inicial. O -a Flag instrui o comando para encenar automaticamente arquivos que foram modificados e -m é usado para especificar uma mensagem de confirmação:

$ git add -a $ git Commit -a -m "Commits inicial" 

Faça um commit Git

Publicar as comprometeções locais para o Remote Git Repository

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 como mostrado.

$ Git Push Origin Master 

Empurrar comprometimento para o repositório Git Centrol

No momento, o seu repositório Git local deve estar atualizado com o repositório central do projeto (origem), você pode confirmar isso executando o execução do Comando de status mais uma vez.

$ git status 

Verifique o status Git

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

Crie um novo ramo 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 (filial mestre). Para criar um novo ramo e depois mudar para ele, use o filial e Confira comandos respectivamente.

$ git ramo mais recente $ git checkout Último 

Como alternativa, você pode criar uma nova ramificação e mudar para ela em uma etapa usando o Comando de checkout com o -b bandeira.

$ git checkout -B mais recente 

Você também pode criar uma nova filial baseada em outra filial, por exemplo.

$ git checkout -B mais recente mestre 

Para verificar em qual filial você está, use Comando da filial (Um caractere de asterisco indica o ramo ativo):

Ramo $ git 

Verifique a ramificação ativa

Depois de criar e mudar para o novo ramo, faça algumas alterações sob ela e faça algumas confirmações.

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

Mesclar mudanças de um ramo para outro

Para mesclar as mudanças no teste da filial no ramo mestre, mude para o ramo mestre e faça a mesclagem.

$ git checkout mestre $ git mescla test 

Mesclar ramo de teste em mestre

Se você não precisar mais de um ramo específico, pode excluí -lo usando o -d trocar.

Teste de ramificação $ git -d 

Baixar alterações do repositório central remoto

Supondo Pull Command.

$ Git Pull Origin ou $ Git Pull Origin Master #Se você mudou para outra filial 

Puxe mudanças do repositório central

Inspecione o repositório Git e execute comparações

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

O primeiro recurso é o Git Log, que exibe logs de confirmação:

$ git log 

Ver Git Commit logs

Outra característica importante é o mostrar comando que exibe vários tipos de objetos (como comprometimentos, tags, árvores etc.):

$ git show 

Git mostra objetos

O terceiro recurso vital que você precisa saber é o comando diff, usado para comparar ou mostrar diferença 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 mestre e a última filial, você pode executar o seguinte comando.

$ Git Diff Master mais recente 

Mostrar diferença entre ramificações

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

Resumo

Git Permite que uma equipe de pessoas trabalhe juntas usando os mesmos arquivos, enquanto grava alterações no (s) arquivo (s) ao longo do tempo, para que possam se lembrar de versões específicas posteriormente.

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