Cómo utilizar el sistema de control de versiones de Git en Linux [Guía completa]


Control de versión (control de revisión o control de fuente) es una forma de registrar cambios en un archivo o colección de archivos a lo largo del tiempo para que pueda recuperar versiones específicas más adelante. Un sistema de control de versiones (o VCS en breve) es una herramienta que registra los cambios en los archivos de un sistema de archivos.

Existen muchos sistemas de control de versiones, pero Git es actualmente el más popular y de uso frecuente, especialmente para la administración de código fuente. El control de versiones se puede usar para casi cualquier tipo de archivo en una computadora, no solo para el código fuente.

Los sistemas/herramientas de control de versiones ofrecen varias características que permiten a las personas o un grupo de personas:

  • create versions of a project.
  • track changes accurately and resolve conflicts.
  • merge changes into a common version.
  • rollback and undo changes to selected files or an entire project.
  • access historical versions of a project to compare changes over time.
  • see who last modified something that might be causing a problem.
  • create a secure offsite backup of a project.
  • use multiple machines to work on a single project and so much more.

Un proyecto bajo un sistema de control de versiones como Git tendrá principalmente tres secciones, a saber:

  • a repository: a database for recording the state of or changes to your project files. It contains all of the necessary Git metadata and objects for the new project. Note that this is normally what is copied when you clone a repository from another computer on a network or remote server.
  • a working directory or area: stores a copy of the project files which you can work on (make additions, deletions and other modification actions).
  • a staging area: a file (known as index under Git) within the Git directory, that stores information about changes, that you are ready to commit (save the state of a file or set of files) to the repository.

Hay dos tipos principales de VCS, con la diferencia principal en el número de repositorios:

  • Centralized Version Control Systems (CVCSs): here each project team member gets their own local working directory, however, they commit changes to just a single central repository.
  • Distributed Version Control Systems (DVCSs): under this, each project team member gets their own local working directory and Git directory where they can make commits. After an individual makes a commit locally, other team members can’t access the changes until he/she pushes them to the central repository. Git is an example of a DVCS.

Además, un repositorio Git puede ser simple (repositorio que no tiene un directorio de trabajo) o no desnudo (uno con directorio). Los repositorios compartidos (o públicos o centrales) siempre deben estar vacíos: todos los repositorios de Github están vacíos.

Aprende el control de versiones con Git

Git es un sistema de control de versiones popular y de código abierto, rápido, potente, distribuido, fácil de usar, que es muy eficiente en grandes proyectos y cuenta con un notable sistema de ramificación y fusión. Está diseñado para manejar datos más como una serie de instantáneas de un mini sistema de archivos, que se almacena en un directorio Git.

El flujo de trabajo en Git es muy simple: realiza modificaciones a los archivos en su directorio de trabajo, luego agrega selectivamente solo los archivos que han cambiado, al área de preparación, para ser parte de su próxima confirmación.

Una vez que esté listo, realice una confirmación, que toma los archivos del área de preparación y guarda esa instantánea de forma permanente en el directorio de Git.

Para instalar Git en Linux, use el comando apropiado para la distribución que elija:

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

Después de instalar Git, se recomienda que le digas a Git quién eres al proporcionar tu nombre completo y dirección de correo electrónico, de la siguiente manera:

$ git config --global user.name “Aaron Kili”
$ git config --global user.email “[email protected].com”

Para verificar la configuración de Git, use el siguiente comando.

$ git config --list 

Crea un nuevo repositorio Git

Los repositorios compartidos o los flujos de trabajo centralizados son muy comunes y eso es lo que demostraremos aquí. Por ejemplo, asumimos que se le ha asignado la tarea de configurar un repositorio central remoto para administradores/programadores de sistemas de varios departamentos de su organización, para trabajar en un proyecto llamado bashscripts , que se almacenará bajo >/projects/scritpts/ en el servidor.

SSH en el servidor remoto y cree el directorio necesario, cree un grupo llamado sysadmins (agregue todos los miembros del equipo del proyecto a este grupo, por ejemplo, administrador de usuarios) y establezca los permisos adecuados en este directorio

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

Luego inicialice un repositorio de proyecto desnudo.

# git init --bare /projects/scripts/bashscripts

En este punto, ha inicializado con éxito un directorio Git que es la instalación de almacenamiento central para el proyecto. Intente hacer una lista del directorio para ver todos los archivos y directorios allí:

# ls -la /projects/scripts/bashscripts/

Clonar un repositorio Git

Ahora clone el repositorio de Git compartido a su computadora local a través de SSH (también puede clonar a través de HTTP/HTTPS si tiene un servidor web instalado y configurado adecuadamente, como lo es caso con la mayoría de los repositorios públicos en Github), por ejemplo:

$ git clone ssh://[email protected]_server_ip:/projects/scripts/bashscripts 

Para clonarlo en un directorio específico ( ~/bin/bashscripts ), use el comando a continuación.

$ git clone ssh://[email protected]_server_ip:/projects/scripts/bashscripts ~/bin/bashscripts

Ahora tiene una instancia local del proyecto en un repositorio no desnudo (con un directorio de trabajo), puede crear la estructura inicial del proyecto (es decir, agregar un README.md fuerte, subdirectorios para diferentes categorías de scripts, por ejemplo, recon para almacenar scripts de reconocimiento, sysadmin ro store sysadmin scripts, etc.):

$ cd ~/bin/bashscripts/
$ ls -la

Compruebe un resumen de estado de Git

Para mostrar el estado de su directorio de trabajo, use el comando de estado que le mostrará cualquier cambio que haya realizado; qué archivos no están siendo rastreados por Git; Esos cambios que se han puesto en escena y así sucesivamente.

$ git status 

Cambios de etapa de Git y compromiso

A continuación, realice todos los cambios con el comando agregar con el interruptor -A y realice la confirmación inicial. El indicador -a indica al comando que realice la etapa de los archivos modificados automáticamente, y -m se usa para especificar un mensaje de confirmación:

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

Publicar compromisos locales en el repositorio de Git remoto

Como líder del equipo del proyecto, ahora que ha creado la estructura del proyecto, puede publicar los cambios en el repositorio central utilizando el comando push como se muestra.

$ git push origin master

En este momento, su repositorio local de git debería estar actualizado con el repositorio central del proyecto (origen), puede confirmarlo ejecutando el comando de estado una vez más.

$ git status

También puede informar a sus colegas para que comiencen a trabajar en el proyecto clonando el repositorio en sus computadoras locales.

Crear una nueva rama de Git

La ramificación le permite trabajar en una característica de su proyecto o solucionar problemas rápidamente sin tocar el código base (rama maestra). Para crear una nueva rama y luego cambiarla, use los comandos rama y pago respectivamente.

$ git branch latest
$ git checkout latest

Alternativamente, puede crear una nueva rama y cambiar a ella en un solo paso utilizando el comando de pago con la bandera -b .

$ git checkout -b latest

También puede crear una nueva rama basada en otra rama, por ejemplo.

$ git checkout -b latest master

Para comprobar en qué rama está, use comando de rama (un carácter de asterisco indica la rama activa):

$ git branch

Después de crear y cambiar a la nueva rama, haga algunos cambios debajo de ella y haga algunos compromisos.

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

Combinar cambios de una rama a otra

Para fusionar los cambios en la prueba de rama en la rama maestra, cambie a la rama maestra y haga la combinación.

$ git checkout master 
$ git merge test 

Si ya no necesita una rama en particular, puede eliminarla con el interruptor -d .

$ git branch -d test

Descargar cambios desde el repositorio central remoto

Suponiendo que los miembros de su equipo hayan introducido cambios en el repositorio central del proyecto, puede descargar cualquier cambio en su instancia local del proyecto utilizando el comando pull .

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

Inspeccionar el repositorio Git y realizar comparaciones

En esta última sección, cubriremos algunas funciones útiles de Git que hacen un seguimiento de todas las actividades que sucedieron en su repositorio, lo que le permite ver el historial del proyecto.

La primera característica es el registro de Git, que muestra los registros de confirmación:

$ git log

Otra característica importante es el comando de demostración que muestra varios tipos de objetos (como confirmaciones, etiquetas, árboles, etc.):

$ git show

La tercera característica vital que debe conocer es el comando diff, que se utiliza para comparar o mostrar la diferencia entre las sucursales, mostrar los cambios entre el directorio de trabajo y el índice, los cambios entre dos archivos en el disco y mucho más.

Por ejemplo, para mostrar la diferencia entre el maestro y la última rama, puede ejecutar el siguiente comando.

$ git diff master latest

Git le permite a un equipo de personas trabajar juntas usando los mismos archivos, mientras se graban los cambios en los archivos a lo largo del tiempo para que puedan recuperar versiones específicas más adelante.

De esta manera, puede usar Git para administrar el código fuente, los archivos de configuración o cualquier archivo almacenado en una computadora. Es posible que desee consultar la documentación en línea de Git para obtener más documentación.